4e8927b0b9
* test(#3707): failing-first coverage for reverting the fence-shortfall fold shield Pins the post-revert contract: a phase whose only gap is a fence shortfall must degrade the fold and withhold the milestone percentages, like every other gap class. Five of the eight rows are CONTROLS that pass before the change, and they carry more weight than the failing row. The failure mode of this revert is degrading TOO MUCH: a revert that sets foldScope outside the headingsSeen > 0 branch would withhold every percentage in the project, and only the no-gap control catches that. Another control catches a revert that collapses the two scopes into one and loses the distinction between what a phase reports and what the fold folds -- uat.scope must stay TRUNCATED for every gap either way, which it already is. The row that pinned the shielded behavior is rewritten rather than deleted. Deleting a test because the behavior it asserts is being reversed leaves the reversal unguarded. * fix(#3707): degrade the fold for every UAT gap class, reverting the fence-shortfall shield Maintainer decision. The two orthogonal engines split on this during #3707 and neither filed it as blocking, so it shipped in the shape the engine that raised the objection endorsed after verifying seven fixtures. The call has now gone the other way, restoring the fail-safe direction chosen twice already on this issue. The shield exempted one gap class from the fold's teeth. It could not do that safely: shortfallBlocks is a single tally incremented at exactly one site and spans BOTH a harmless fenced documentation sample AND a genuinely fence-straddled result: blocked row. Exempting it therefore could not exempt only the harmless case -- it also published a milestone percentage over a real, unread outstanding row. SCOPE.TRUNCATED means the scan could not SEE part of the evidence, which is exactly that case. scope and foldScope now agree: every gap class degrades both. The accepted over-report documented in uat.cts is unchanged and still documented there; what changed is only that it no longer buys an exemption from the fold. The comment block above it argued FOR the shield and is rewritten, because a comment defending behavior the code no longer has is worse than no comment. shortfallBlocks leaves this function's destructure but is untouched upstream, where audit-uat still consumes it. * fix(#3707): correct the caller comment, add the changeset, and name what the order tests guard Review found a SECOND comment still documenting the removed shield -- the caller's, beside the worstScope fold, stating that foldScope differs from scope for exactly one case which must not raise phase_scope_degraded or withhold the milestone's percentages. That is now the opposite of what the code does. I rewrote the buildUatRows comment in the previous commit and asserted in its message that a comment defending behavior the code no longer has is worse than no comment, then left exactly that one standing a few hundred lines away. The change had no changeset. It is user-visible: a milestone's percentage goes from published to withheld whenever any phase has a fence-shortfall-only gap. PR gates hard-fail a user-facing code diff without one. The two scopes are now identical at every return site. They are NOT collapsed -- that would change the return shape and the caller on what is meant to be a one-condition revert, and the seam is worth keeping if the distinction is ever wanted again -- but the declaration now says plainly that they agree by decision rather than by accident, so a reader does not have to re-derive it. The two order-independence tests were renamed. foldScope is monotonic with no reset path, so file order is structurally irrelevant and those rows could never have failed for the ordering reason their names promised. They do guard something real -- a multi-file phase degrading when any one file has a shortfall-only gap -- so they now say that instead. * test(#3707): failing-first coverage for the lone-CR UAT false-clean The parser splits on newline only, and the heading tokenizer agrees with it, so a lone carriage return is not a line boundary anywhere in it. CommonMark treats a lone CR as a line ending, so such a row renders to a human reader while being invisible to BOTH sides of the parser's symmetry invariant: no item, no shortfall, no headingsSeen. A phase hiding a result: blocked row this way reports 100 percent with zero diagnostics. Found by the security review of the fold-shield revert. It is the one false-clean class that revert does not reach, and it is the same bug class this issue exists to fix -- an unreadable row reported as clean. Nine rows. The LF control is what proves this is a separator defect rather than a content defect: identical bodies, one separator apart, and only one of them hides the row. CRLF and CR-inside-a-fence controls guard the coming normalization against double-counting or tearing content that legitimately contains a carriage return. Two further manifestations turned up while writing them: a leading CR breaks column-0 anchoring of the first heading, and an all-CR document flags a shortfall it cannot attribute to any row. * fix(#3707): treat a lone carriage return as a line ending in the UAT parser A lone CR was not a line boundary anywhere in the parser -- it split on newline only, and the heading tokenizer agreed with it. CommonMark treats a lone CR as a line ending, so such a row rendered to a human reader while being invisible to BOTH sides of the parser's symmetry invariant: no item, no shortfall, no headingsSeen. A phase hiding a result: blocked row that way reported 100 percent with zero diagnostics. Line endings are now normalized once at document ingress -- CRLF and lone CR both to newline -- at the two independent entry points, rather than teaching each split site about CR. Every downstream scan, offset and span therefore reads one convention. That single-frame property is deliberate: this issue already cost a HIGH when two scans read the same document through different frames. MY OWN END-TO-END TEST WAS WRONG and is replaced rather than weakened. It asserted that a lone-CR document must withhold its percentage, which reasons from the pre-fix symptom: after the fix the row is not hidden, it is surfaced, and this module deliberately keeps visible outstanding UAT work separate from completion percentages -- only unreadable evidence degrades scope. The success of the fix is what made the assertion false. The implementing agent refused to satisfy both it and the architecture and asked instead of bending either; it was right. What replaces it is a stronger contract: a lone-CR document and its LF twin, built from one source, must produce identical audit output -- scope, percent, every unresolved row by identity, and the diagnostic set. That is what 'a line-ending convention must not change what the audit reports' actually means, and it carries a non-vacuity check so it cannot pass with both sides empty. shortfallBlocks keeps being returned, now documented as currently unconsumed. An earlier reviewer told me audit-uat still consumed it and I passed that on as an instruction; it was wrong, and it was caught by checking rather than by me. * fix(#3707): normalize at the document read boundary, not at two call sites The lone-CR fix was half-applied and both review engines caught it independently. cmdAuditUat has four document ingresses, not the two I normalized: VERIFICATION.md and deferred-items.md still handed raw text to newline-only splitters, and the frontmatter extract in the UAT loop read raw content while its parser read normalized -- one audit entry mixing the two frames the fix exists to unify. Measured: a phase written twice from one source gave total_files 2 / total_items 4 under LF and results [] / total_items 0 under lone CR, with zero diagnostics. Normalizing two call sites and declaring it done is exactly why two were missed, so this moves it to the read boundary: every document now enters through a helper that normalizes, in audit-uat, in planning-inspect's readDocument, and in the shared verification-status read. Future parsers downstream get normalized text by construction rather than because someone remembered. That last seam also fixes an under-reporting case of the same root: a lone-CR VERIFICATION.md saying status: passed was read as missing, telling the user a verify step that had completed never ran. The parity test's load-bearing assertion is now marked as such. Four of its five equality checks still pass with the bug present -- only the unresolved-row identity differs -- so trimming that one as redundant would make the row vacuous. Second changeset added: the CR fix is user-visible independently of the fold revert, and one fragment covering both would have described neither. * test(#3707): failing-first coverage for the U+2028 and duplicate-result false-cleans Two more of the same class, both found by the security review of this branch and both reproduced before writing a line. normalizeLineEndings folds only carriage returns, but a JS /m anchor also treats U+2028 and U+2029 as line terminators while split on newline does not. That is the identical asymmetry the carriage-return bug exploited, one separator over, and worse in one respect: these are not CommonMark line endings, so a reader still sees the column-0 result: blocked that the tool discards. Measured: a scalar-internal result: pass placed after U+2028 wins over the real blocked line and the row disappears with no gap raised. Separately, and independent of any separator, a block with two column-0 result: lines resolves to the first with no ambiguity signalled. Prepending result: pass to a block therefore deletes an outstanding row silently; reversing the order surfaces it. Order deciding meaning is the defect, so the pair of rows pins the contract as ambiguity-is-a-gap rather than last-one-wins, leaving the fix room to implement the gap sensibly. Four controls: an ordinary marker in the same position (proving separator not content), legitimate U+2028 inside prose that must not be torn, a single result line, and a result line inside a fence that must not count as a second occurrence. * fix(#3707): scan result lines by split, not by a multiline anchor Two more false-cleans from the security review, both closed by the same change. A JS /m anchor treats U+2028 and U+2029 as line terminators while split on newline does not. A scalar-internal result: pass placed after one of those separators therefore matched as a line start and beat the real column-0 result: blocked, and the row vanished at 100 percent with no gap. Worse than the carriage-return case in one respect: these are not CommonMark line endings, so a reader still saw the blocked row the tool discarded. Separately, the non-global match returned the leftmost hit, so a block with two column-0 result: lines silently resolved to the first. Prepending result: pass deleted an outstanding row; reversing the order surfaced it. Order deciding meaning was the defect. Both close by scanning lines produced by split rather than by anchoring a regex inside the whole document: each line is tested on its own, and a count other than exactly one is reported as a parse gap instead of resolved to either candidate. I asked for U+2028 to be folded in normalizeLineEndings and that was wrong. Folding is length-preserving, so it would have made the U+2028 fixture byte-identical to the genuine two-result-line fixture -- while one requires a confident item and the other requires an ambiguity gap. No implementation can satisfy both once the distinguishing character is erased. The agent proved that and deviated rather than forcing it, which is why normalizeLineEndings still folds only carriage returns, now with a comment saying why. * fix(#3707): bound the ambiguity scan at the next heading-shaped line The split-based result scan regressed four pre-existing #3078/#3707 guards, each off by exactly one gap. My diagnosis was wrong. I read the off-by-one as double counting -- zero-result blocks taking both the new path and the pre-existing one -- and said to change the ambiguity condition from not-equal-one to greater-than-one. The agent checked and refused: the zero path was never duplicated. The real cause is double ATTRIBUTION. A block is sliced to the next TOKENIZED heading, so when the next row is untokenized -- hidden by a straddling fence, or indented and already counted by the shortfall scan -- that row's own result: line is absorbed into the previous block. The scan then saw two result lines across what are really two rows and raised a second, redundant gap on top of the one already counted elsewhere. Had the greater-than-one change gone in, the counts would have matched while the double attribution stayed. That is the compensating-adjustment failure I had asked it to refuse, and it did. The scan is now bounded at the first following heading-shaped line, either indent class, so a genuine same-block ambiguity is untouched while spillover from a row counted elsewhere is excluded. * fix(#3707): keep the U+2028 immunity, revert the ambiguity detection The ambiguity half of this change regressed the suite twice and is coming out. Attempt one double-attributed: a block is sliced to the next TOKENIZED heading, so when the real next row is untokenized its result: line was absorbed into the previous block and raised a second gap on a row already counted elsewhere. Four guards broke. Attempt two bounded the scan at the next heading-shaped line and broke thirty. An indented ### N. inside a block scalar is legitimate scalar CONTENT, not a heading, and truncating there defeats every #3078 guard that exists to stop scalar bodies being read as rows. Telling a genuinely hidden indented row apart from indented scalar text is a classification countUnattributedIndentedRows already owns; a raw regex does not have that information. What survives is the half that is sound and was never implicated in either regression: the result scan tests each line produced by split rather than anchoring a regex with the multiline flag over the whole block. split never treats U+2028 or U+2029 as a delimiter, so those separators can no longer manufacture a line start and steal a row. Everything else returns to first-match-wins, byte-identical to origin/next. The two tests pinning ambiguity-as-a-gap are removed with it, since the contract is no longer implemented here. The defect they described is real, pre-existing and independent of any separator -- result: pass before result: blocked silently deletes an outstanding row -- and it needs its own change with a scalar-aware counter rather than being wedged into a branch already carrying three fixes. * fix(#3707): correct the shared-seam rationale and restore U+2028 trailing text The revert left a stale rationale in core-utils, justifying the decision not to fold U+2028 by claiming uat.cts must tell a fake line start apart from a real second column-0 result: declaration that gets flagged as ambiguous. Nothing flags ambiguity any more; that behavior was reverted and the same file says so a few lines away. The decision is still right, the stated reason was false. This is the third stale comment this branch has shipped and had to fix, and the worst placed of them: core-utils is a shared leaf that every future document consumer will read for guidance. Rewritten to the true reason -- the scan tests each split line individually rather than anchoring over the block, so an exotic separator cannot manufacture a line start and folding is unnecessary. Also a real behavior delta I had not noticed. Dropping the multiline flag left the pattern's trailing .*$ in place, and dot never matches U+2028, so a genuine column-0 result: blocked whose TRAILING text contained one stopped parsing entirely -- a visible parse gap rather than a false clean, so fail-safe, but a regression against origin/next that nothing pinned. The trailing portion now matches any character and a test pins it by identity against its plain-LF twin. Plus the JSDoc orphaned when normalizeLineEndings moved to core-utils, and the changeset, which described neither the separator fix nor planning-inspect surfacing lone-CR rows. * fix(#3707): harden the acceptance gate, which had both halves of the same bug uat-predicate is a SECOND, independent UAT parser, and it is the one that decides phase uat-passed. It read raw bytes and anchored a multiline regex over unsplit text -- exactly the two defects this branch closed one module away in uat.cts. The consequence is worse than the audit surface it mirrors. Measured on identical bytes: a U+2028 scalar injection made the gate return passed true while planning inspect reported the same row as blocked and outstanding. The hardened surface and the gate disagreed, and the gate was the permissive one -- so a phase could be accepted over a row the audit could see and the gate could not. Both raw reads now go through the shared normalize seam and both scans test lines produced by split rather than anchoring over the document. First-match-wins, matching uat.cts; no ambiguity counting is reintroduced. Tests assert the AGREEMENT between the two surfaces rather than each separately, because divergence is the defect. Also finishes the same root cause one module over: phase complete's advisory pre-scan read raw bytes, so a lone-CR VERIFICATION.md lost its human_needed or gaps_found warning -- the fix verification.cts already got on this branch. And narrows the core-utils rationale I reworded last commit, which claimed consumers already avoid multiline anchors. uat.cts still has five over unsplit text. That is the fourth comment on this branch to assert something the code does not do, so it now states only what is true of core-utils itself. * fix(#3707): give structure and attribution different line frames, normalize the close audit Two more from review, and the first was a regression I introduced one commit earlier. Converting the gate's heading scan to split-then-match removed a detection origin/next had: a ### N. heading delimited by U+2028 was found by the old multiline scan and was not found after. So hardening the result scan quietly weakened the heading scan, and the gate stopped blocking on rows origin/next blocked -- the permissive direction, on the surface that decides acceptance. The insight I had missed is that the two scans need DIFFERENT frames. Heading detection is structure: there is no distinction to preserve, so it splits on newline or either exotic separator and finds a heading however it is delimited. The result scan is attribution: the newline-only frame is exactly what stops a scalar-internal result: from being read as a column-0 line, so it stays. One frame applied uniformly was the error. Second, a THIRD unnormalized parser family: the milestone-close audit read every artifact raw. A lone-CR VERIFICATION.md degraded to status unknown and was skipped, and deferred entries vanished outright -- measured as three items requiring decisions under LF and one under CR, on identical bytes. All nine scanner reads now normalize; six of them had the identical defect beyond the three review named. The acknowledge path stays deliberately raw, since it splices by byte offset, and now says so. Also pins the cross-newline result: divergence, and replaces three raw U+2028 literals in test source with escapes. A raw separator in a fixture is one formatter away from becoming an ordinary-character control that still passes -- vacuous in the only test pinning the separator fix. * fix(#3707): share one frame between the acknowledge writer and the audit reader Normalizing the audit scanners left the writer and the reader on different frames. cmdAuditAcknowledge derives its stored snapshot values from raw content -- correct for the SPLICE, which rewrites by byte offset -- but scanUatGaps and scanContextQuestions now recompute those same values from normalized content. For a lone-CR artifact the two can never match, so an acknowledgement never suppresses its item and it resurfaces on every audit: acknowledge became a silent no-op. Fail-safe in direction, since the item stays visible rather than being wrongly suppressed, but it is the writer and reader disagreeing about what a line is -- the exact class this branch exists to eliminate, and the fourth instance of it here. The derive functions now read a normalized copy while the splice keeps raw bytes and raw offsets, so both sides share one frame and the byte-offset rewrite is untouched. Round trip pinned for lone-CR and LF, with an existing LF marker asserted still recognised so the change cannot silently invalidate acknowledgements already in users' files. Also tightens an assertion that pinned this branch's own heading fix with a proxy: notStrictEqual against 'passed' also passes on 'pass', which IS a passing token, so it could not have caught a regression attributing a passing result to the recovered heading. It now pins the exact token. * chore(#3707): backfill changeset pr numbers Both fragments still carried the pr: 0 placeholder, which failed changeset-lint and docs-lint on PR 3903. The review had flagged the backfill as pending and I opened the PR without doing it. --------- Co-authored-by: sim <sim@local>
2504 lines
122 KiB
JavaScript
2504 lines
122 KiB
JavaScript
'use strict';
|
||
/**
|
||
* audit-command-cutover.test.cjs — ADR-959 phase 4d-impl-3 equivalence tests.
|
||
*
|
||
* Verifies that `audit-uat` and `audit-open`, after cutover from the hardcoded
|
||
* `case 'audit-uat':` and `case 'audit-open':` arms in gsd-tools.cjs to the
|
||
* capability registry dispatch path (default → dispatchCapabilityCommand →
|
||
* audit-command-router.cjs → routeAuditUat | routeAuditOpen), behave
|
||
* identically to the old inline cases.
|
||
*
|
||
* Test categories:
|
||
* 1. UNIT (recording mock) — precise arg/call equivalence for each router
|
||
* 2. DISPATCH — commands reach routers via default-case registry dispatch
|
||
* 3. BEHAVIOR — subprocess tests with real output-shape assertions
|
||
* 4. JSON-ERRORS — structured {ok:false,reason,message} for error paths
|
||
* 5. REGISTRY — commandFamilies entries, audit capability in registry
|
||
*/
|
||
|
||
const { describe, test, beforeEach, afterEach } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
|
||
const { runGsdTools, createTempProject, cleanup } = require('./helpers.cjs');
|
||
|
||
const registry = require('../gsd-core/bin/lib/capability-registry.cjs');
|
||
const { routeAuditUat, routeAuditOpen } = require('../gsd-core/bin/lib/audit-command-router.cjs');
|
||
|
||
// ─── helpers ─────────────────────────────────────────────────────────────────
|
||
|
||
function makeErrorRecorder() {
|
||
const calls = [];
|
||
const fn = (msg, reason) => calls.push({ msg, reason });
|
||
fn.calls = calls;
|
||
return fn;
|
||
}
|
||
|
||
// ─── 1. UNIT — recording mocks (precise routing equivalence) ─────────────────
|
||
|
||
describe('audit routers: unit tests via recording mocks', () => {
|
||
const CWD = '/fake/cwd';
|
||
const RAW = false;
|
||
|
||
// ── routeAuditUat ──────────────────────────────────────────────────────────
|
||
|
||
test('routeAuditUat: calls _uat.cmdAuditUat(cwd, raw) exactly once', () => {
|
||
const uatCalls = [];
|
||
const mockUat = {
|
||
cmdAuditUat: (cwd, raw) => uatCalls.push({ cwd, raw }),
|
||
};
|
||
const errFn = makeErrorRecorder();
|
||
|
||
routeAuditUat({
|
||
args: ['audit-uat'],
|
||
cwd: CWD, raw: RAW, error: errFn,
|
||
_uat: mockUat,
|
||
});
|
||
|
||
assert.strictEqual(errFn.calls.length, 0, 'error must not be called');
|
||
assert.strictEqual(uatCalls.length, 1, 'cmdAuditUat must be called exactly once');
|
||
assert.strictEqual(uatCalls[0].cwd, CWD, 'cwd passed through correctly');
|
||
assert.strictEqual(uatCalls[0].raw, RAW, 'raw passed through correctly');
|
||
});
|
||
|
||
test('routeAuditUat: raw=true is forwarded correctly', () => {
|
||
const uatCalls = [];
|
||
const mockUat = {
|
||
cmdAuditUat: (cwd, raw) => uatCalls.push({ cwd, raw }),
|
||
};
|
||
routeAuditUat({
|
||
args: ['audit-uat'],
|
||
cwd: CWD, raw: true, error: makeErrorRecorder(),
|
||
_uat: mockUat,
|
||
});
|
||
assert.strictEqual(uatCalls[0].raw, true, 'raw=true must be forwarded');
|
||
});
|
||
|
||
// ── routeAuditOpen ─────────────────────────────────────────────────────────
|
||
|
||
test('routeAuditOpen (no --json): calls auditOpenArtifacts, formatAuditReport; output(null, true, report)', () => {
|
||
const auditCalls = [];
|
||
const coreCalls = [];
|
||
const FAKE_RESULT = { fake: true };
|
||
const FAKE_REPORT = 'REPORT TEXT';
|
||
const mockAudit = {
|
||
auditOpenArtifacts: (cwd) => { auditCalls.push({ fn: 'auditOpenArtifacts', cwd }); return FAKE_RESULT; },
|
||
formatAuditReport: (res) => { auditCalls.push({ fn: 'formatAuditReport', res }); return FAKE_REPORT; },
|
||
};
|
||
// Inject a recording _core stub so no bytes reach the real process stdout.
|
||
const mockCore = {
|
||
output: (...callArgs) => coreCalls.push(callArgs),
|
||
};
|
||
routeAuditOpen({
|
||
args: ['audit-open'],
|
||
cwd: CWD, raw: RAW, error: makeErrorRecorder(),
|
||
_audit: mockAudit,
|
||
_core: mockCore,
|
||
});
|
||
// auditOpenArtifacts called first, then formatAuditReport with its result
|
||
assert.strictEqual(auditCalls.length, 2, 'must call auditOpenArtifacts then formatAuditReport');
|
||
assert.strictEqual(auditCalls[0].fn, 'auditOpenArtifacts', 'first call must be auditOpenArtifacts');
|
||
assert.strictEqual(auditCalls[0].cwd, CWD, 'auditOpenArtifacts cwd must match');
|
||
assert.strictEqual(auditCalls[1].fn, 'formatAuditReport', 'second call must be formatAuditReport');
|
||
assert.strictEqual(auditCalls[1].res, FAKE_RESULT, 'formatAuditReport must receive auditOpenArtifacts result');
|
||
// Assert the exact 3-arg core.output call form for text mode:
|
||
// core.output(null, true, formatAuditReport(result))
|
||
assert.strictEqual(coreCalls.length, 1, 'core.output must be called exactly once');
|
||
assert.strictEqual(coreCalls[0][0], null, 'text mode: first arg to core.output must be null');
|
||
assert.strictEqual(coreCalls[0][1], true, 'text mode: second arg to core.output must be true');
|
||
assert.strictEqual(coreCalls[0][2], FAKE_REPORT, 'text mode: third arg to core.output must be the formatted report');
|
||
});
|
||
|
||
test('routeAuditOpen (--json): calls auditOpenArtifacts but NOT formatAuditReport; output(result, raw)', () => {
|
||
const auditCalls = [];
|
||
const coreCalls = [];
|
||
const FAKE_RESULT = { fake: true };
|
||
const mockAudit = {
|
||
auditOpenArtifacts: (cwd) => { auditCalls.push({ fn: 'auditOpenArtifacts', cwd }); return FAKE_RESULT; },
|
||
formatAuditReport: (res) => { auditCalls.push({ fn: 'formatAuditReport', res }); return 'REPORT'; },
|
||
};
|
||
// Inject a recording _core stub so no bytes reach the real process stdout.
|
||
const mockCore = {
|
||
output: (...callArgs) => coreCalls.push(callArgs),
|
||
};
|
||
routeAuditOpen({
|
||
args: ['audit-open', '--json'],
|
||
cwd: CWD, raw: RAW, error: makeErrorRecorder(),
|
||
_audit: mockAudit,
|
||
_core: mockCore,
|
||
});
|
||
// auditOpenArtifacts called; formatAuditReport must NOT be called for --json
|
||
const fmtCalls = auditCalls.filter(c => c.fn === 'formatAuditReport');
|
||
assert.strictEqual(fmtCalls.length, 0, '--json mode must NOT call formatAuditReport');
|
||
const artifactCalls = auditCalls.filter(c => c.fn === 'auditOpenArtifacts');
|
||
assert.strictEqual(artifactCalls.length, 1, '--json mode must call auditOpenArtifacts once');
|
||
// Assert the exact 2-arg core.output call form for JSON mode:
|
||
// core.output(result, raw)
|
||
assert.strictEqual(coreCalls.length, 1, 'core.output must be called exactly once');
|
||
assert.strictEqual(coreCalls[0][0], FAKE_RESULT, 'json mode: first arg to core.output must be the result object');
|
||
assert.strictEqual(coreCalls[0][1], RAW, 'json mode: second arg to core.output must be raw');
|
||
assert.strictEqual(coreCalls[0].length, 2, 'json mode: core.output must be called with exactly 2 args');
|
||
});
|
||
});
|
||
|
||
// ─── 2. DISPATCH — commands reach routers via default-case ───────────────────
|
||
|
||
describe('audit cutover: dispatch path (default-case → capability registry)', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => {
|
||
tmpDir = createTempProject('gsd-audit-cutover-');
|
||
});
|
||
|
||
afterEach(() => {
|
||
cleanup(tmpDir);
|
||
});
|
||
|
||
test('audit-uat dispatches via capability registry (no "Unknown command" error)', () => {
|
||
const result = runGsdTools(['audit-uat'], tmpDir);
|
||
// audit-uat with a minimal project may succeed or fail on file-not-found;
|
||
// the key assertion is it never emits "Unknown command: audit-uat"
|
||
const isUnknownCmd = (result.error || '').includes('Unknown command: audit-uat');
|
||
assert.strictEqual(isUnknownCmd, false,
|
||
`Must not emit "Unknown command: audit-uat". stderr: ${result.error}`);
|
||
assert.ok(result.success,
|
||
`audit-uat must exit 0. stderr: ${result.error}`);
|
||
});
|
||
|
||
test('audit-open dispatches via capability registry (no "Unknown command" error)', () => {
|
||
const result = runGsdTools(['audit-open'], tmpDir);
|
||
const isUnknownCmd = (result.error || '').includes('Unknown command: audit-open');
|
||
assert.strictEqual(isUnknownCmd, false,
|
||
`Must not emit "Unknown command: audit-open". stderr: ${result.error}`);
|
||
assert.ok(result.success,
|
||
`audit-open must exit 0. stderr: ${result.error}`);
|
||
});
|
||
|
||
test('audit-open --json dispatches via capability registry', () => {
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
const isUnknownCmd = (result.error || '').includes('Unknown command: audit-open');
|
||
assert.strictEqual(isUnknownCmd, false,
|
||
`Must not emit "Unknown command: audit-open" with --json. stderr: ${result.error}`);
|
||
// Must also produce valid JSON output
|
||
assert.ok(result.success,
|
||
`audit-open --json must succeed. stderr: ${result.error}`);
|
||
assert.doesNotThrow(
|
||
() => JSON.parse(result.output),
|
||
'audit-open --json must produce valid JSON',
|
||
);
|
||
});
|
||
});
|
||
|
||
// ─── 3. BEHAVIOR — subprocess output shape (equivalence to old inline cases) ──
|
||
|
||
describe('audit cutover: output shape equivalence', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => {
|
||
tmpDir = createTempProject('gsd-audit-behavior-');
|
||
});
|
||
|
||
afterEach(() => {
|
||
cleanup(tmpDir);
|
||
});
|
||
|
||
test('audit-open (text) succeeds and produces non-empty output', () => {
|
||
const result = runGsdTools(['audit-open'], tmpDir);
|
||
assert.ok(result.success,
|
||
`audit-open must succeed. stderr: ${result.error}`);
|
||
assert.ok(result.output && result.output.length > 0,
|
||
'audit-open text output must be non-empty');
|
||
// Must be raw text, not JSON-encoded (regression guard from #2911)
|
||
assert.ok(!result.output.startsWith('"'),
|
||
'text mode must not start with a JSON quote');
|
||
assert.ok(!result.output.includes('\\n'),
|
||
'text mode must not contain literal \\n sequences');
|
||
});
|
||
|
||
test('audit-open --json produces valid JSON with expected shape', () => {
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success,
|
||
`audit-open --json must succeed. stderr: ${result.error}`);
|
||
let parsed;
|
||
assert.doesNotThrow(
|
||
() => { parsed = JSON.parse(result.output); },
|
||
'audit-open --json must emit valid JSON',
|
||
);
|
||
assert.equal(typeof parsed, 'object', 'parsed payload must be an object');
|
||
assert.ok(parsed !== null, 'parsed payload must not be null');
|
||
// Shape contract from auditOpenArtifacts() (regression guard from #2911)
|
||
assert.equal(typeof parsed.scanned_at, 'string', 'must include scanned_at');
|
||
assert.equal(typeof parsed.has_open_items, 'boolean', 'must include has_open_items');
|
||
assert.equal(typeof parsed.counts, 'object', 'must include counts');
|
||
assert.equal(typeof parsed.items, 'object', 'must include items');
|
||
});
|
||
|
||
test('audit-open (text) report title present as standalone line', () => {
|
||
const result = runGsdTools(['audit-open'], tmpDir);
|
||
assert.ok(result.success,
|
||
`audit-open must succeed. stderr: ${result.error}`);
|
||
const lines = result.output.split('\n').map(l => l.trim()).filter(Boolean);
|
||
assert.ok(
|
||
lines.includes('### Milestone Close: Open Artifact Audit'),
|
||
`report title must appear as a standalone Markdown heading line; got: ${JSON.stringify(lines.slice(0, 5))}`,
|
||
);
|
||
});
|
||
|
||
test('audit-uat succeeds and produces non-empty stdout', () => {
|
||
const result = runGsdTools(['audit-uat'], tmpDir);
|
||
assert.ok(result.success,
|
||
`audit-uat must succeed. stderr: ${result.error}`);
|
||
assert.ok(result.output && result.output.length > 0,
|
||
'audit-uat must write non-empty output to stdout');
|
||
});
|
||
|
||
test('audit-uat --raw flag passes through (does not break dispatch)', () => {
|
||
const result = runGsdTools(['audit-uat', '--raw'], tmpDir);
|
||
// --raw is a gsd-tools global flag; it modifies output encoding but
|
||
// the command must still succeed and produce output
|
||
assert.ok(result.success,
|
||
`audit-uat --raw must succeed. stderr: ${result.error}`);
|
||
});
|
||
});
|
||
|
||
// ─── 4. JSON-ERRORS — GSD_JSON_ERRORS mode passes through cleanly ────────────
|
||
|
||
describe('audit cutover: GSD_JSON_ERRORS mode (both commands succeed without structured error)', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => {
|
||
tmpDir = createTempProject('gsd-audit-jsonerr-');
|
||
});
|
||
|
||
afterEach(() => {
|
||
cleanup(tmpDir);
|
||
});
|
||
|
||
test('audit-open --json with GSD_JSON_ERRORS=1 succeeds (no spurious error payload)', () => {
|
||
// Successful commands must not emit JSON error payloads; verify exit 0.
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir, { GSD_JSON_ERRORS: '1' });
|
||
assert.ok(result.success,
|
||
`audit-open --json must succeed even with GSD_JSON_ERRORS=1; stderr: ${result.error}`);
|
||
});
|
||
|
||
test('audit-open text with GSD_JSON_ERRORS=1 succeeds (no spurious error payload)', () => {
|
||
const result = runGsdTools(['audit-open'], tmpDir, { GSD_JSON_ERRORS: '1' });
|
||
assert.ok(result.success,
|
||
`audit-open text mode must succeed even with GSD_JSON_ERRORS=1; stderr: ${result.error}`);
|
||
});
|
||
|
||
test('audit-uat with GSD_JSON_ERRORS=1 succeeds (no spurious error payload)', () => {
|
||
const result = runGsdTools(['audit-uat'], tmpDir, { GSD_JSON_ERRORS: '1' });
|
||
assert.ok(result.success,
|
||
`audit-uat must succeed even with GSD_JSON_ERRORS=1; stderr: ${result.error}`);
|
||
});
|
||
});
|
||
|
||
// ─── 5. REGISTRY — commandFamilies entries ───────────────────────────────────
|
||
|
||
describe('audit cutover: registry entries correct', () => {
|
||
test('commandFamilies["audit-uat"] present and well-shaped', () => {
|
||
const entry = registry.commandFamilies['audit-uat'];
|
||
assert.ok(entry, 'commandFamilies["audit-uat"] must be present');
|
||
assert.strictEqual(entry.capId, 'audit',
|
||
'commandFamilies["audit-uat"].capId must be "audit"');
|
||
assert.strictEqual(entry.module, 'audit-command-router.cjs',
|
||
'commandFamilies["audit-uat"].module must be "audit-command-router.cjs"');
|
||
assert.strictEqual(entry.router, 'routeAuditUat',
|
||
'commandFamilies["audit-uat"].router must be "routeAuditUat"');
|
||
});
|
||
|
||
test('commandFamilies["audit-open"] present and well-shaped', () => {
|
||
const entry = registry.commandFamilies['audit-open'];
|
||
assert.ok(entry, 'commandFamilies["audit-open"] must be present');
|
||
assert.strictEqual(entry.capId, 'audit',
|
||
'commandFamilies["audit-open"].capId must be "audit"');
|
||
assert.strictEqual(entry.module, 'audit-command-router.cjs',
|
||
'commandFamilies["audit-open"].module must be "audit-command-router.cjs"');
|
||
assert.strictEqual(entry.router, 'routeAuditOpen',
|
||
'commandFamilies["audit-open"].router must be "routeAuditOpen"');
|
||
});
|
||
|
||
test('capabilities.audit present with role:feature and tier:full', () => {
|
||
const cap = registry.capabilities.audit;
|
||
assert.ok(cap, 'capabilities.audit must be present');
|
||
assert.strictEqual(cap.role, 'feature', 'audit capability must have role: feature');
|
||
assert.strictEqual(cap.tier, 'full', 'audit capability must have tier: full');
|
||
});
|
||
|
||
test('capabilities.audit.commands has both audit-uat and audit-open entries', () => {
|
||
const cap = registry.capabilities.audit;
|
||
assert.ok(Array.isArray(cap.commands) && cap.commands.length === 2,
|
||
'audit capability must have exactly 2 commands');
|
||
|
||
const uatCmd = cap.commands.find(c => c.family === 'audit-uat');
|
||
assert.ok(uatCmd, 'commands must include audit-uat family');
|
||
assert.strictEqual(uatCmd.module, 'audit-command-router.cjs');
|
||
assert.strictEqual(uatCmd.router, 'routeAuditUat');
|
||
|
||
const openCmd = cap.commands.find(c => c.family === 'audit-open');
|
||
assert.ok(openCmd, 'commands must include audit-open family');
|
||
assert.strictEqual(openCmd.module, 'audit-command-router.cjs');
|
||
assert.strictEqual(openCmd.router, 'routeAuditOpen');
|
||
});
|
||
|
||
test('routeAuditUat and routeAuditOpen are exported functions', () => {
|
||
assert.strictEqual(typeof routeAuditUat, 'function',
|
||
'routeAuditUat must be an exported function');
|
||
assert.strictEqual(typeof routeAuditOpen, 'function',
|
||
'routeAuditOpen must be an exported function');
|
||
});
|
||
|
||
test('profileMembership.audit is vacuous (no skills → no skill-cluster entry)', () => {
|
||
// audit declares skills:[] → no skill-cluster-based profileMembership entry.
|
||
// This is correct: profileMembership tracks skill ownership, not capability existence.
|
||
const pm = registry.profileMembership.audit;
|
||
assert.strictEqual(pm, undefined,
|
||
'profileMembership.audit must be undefined (no skills declared)');
|
||
});
|
||
|
||
test('capabilityClusters.audit is vacuous (no skills → no cluster entry)', () => {
|
||
// Same as profileMembership — skill-less capabilities produce no cluster entries.
|
||
const clusters = registry.capabilityClusters.audit;
|
||
assert.strictEqual(clusters, undefined,
|
||
'capabilityClusters.audit must be undefined (no skills declared)');
|
||
});
|
||
|
||
test('audit has no skills — vacuous install/surface (no skill-index entries)', () => {
|
||
// audit capability declares no skills, so bySkill has no "audit" entry
|
||
// (there is no skill named "audit")
|
||
const cap = registry.capabilities.audit;
|
||
assert.deepStrictEqual(cap.skills, [],
|
||
'audit capability must have empty skills array');
|
||
});
|
||
|
||
test('graphify commandFamilies entry still present (no regression)', () => {
|
||
const entry = registry.commandFamilies['graphify'];
|
||
assert.ok(entry, 'commandFamilies["graphify"] must still be present');
|
||
assert.strictEqual(entry.capId, 'graphify');
|
||
assert.strictEqual(entry.module, 'graphify-command-router.cjs');
|
||
assert.strictEqual(entry.router, 'routeGraphifyCommand');
|
||
});
|
||
});
|
||
|
||
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
// Folded from tests/bug-2659-audit-open-crash.test.cjs — consolidation epic #1969 (B2 #1971)
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
{
|
||
const { describe: __foldDescribe } = require('node:test');
|
||
__foldDescribe("folded:bug-2659-audit-open-crash (consolidation epic #1969 B2 #1971)", () => {
|
||
'use strict';
|
||
|
||
/**
|
||
* Regression test for #2659.
|
||
*
|
||
* The `audit-open` dispatch case in bin/gsd-tools.cjs previously called bare
|
||
* `output(...)` on both the --json and text branches. `output` is never in
|
||
* local scope — the entire core module is imported as `const core`, so every
|
||
* other case uses `core.output(...)`. The bare calls therefore crashed with
|
||
* `ReferenceError: output is not defined` the moment `audit-open` ran.
|
||
*
|
||
* This test runs both invocations against a minimal temp project and asserts
|
||
* they exit successfully with non-empty stdout. It fails with the
|
||
* ReferenceError on any revision that still has the bare `output(...)` calls.
|
||
*/
|
||
|
||
const { test, describe, beforeEach, afterEach } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
|
||
const { runGsdTools, createTempProject, cleanup } = require('./helpers.cjs');
|
||
|
||
describe('audit-open — does not crash with ReferenceError (#2659)', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => {
|
||
tmpDir = createTempProject('gsd-bug-2659-');
|
||
});
|
||
|
||
afterEach(() => {
|
||
cleanup(tmpDir);
|
||
});
|
||
|
||
test('audit-open (text output) succeeds and produces stdout', () => {
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(
|
||
result.success,
|
||
`audit-open must not crash. stderr: ${result.error}`
|
||
);
|
||
assert.ok(
|
||
!/ReferenceError.*output is not defined/.test(result.error || ''),
|
||
`audit-open must not throw ReferenceError. stderr: ${result.error}`
|
||
);
|
||
assert.ok(
|
||
result.output && result.output.length > 0,
|
||
'audit-open must write a non-empty report to stdout'
|
||
);
|
||
});
|
||
|
||
test('audit-open --json succeeds and produces stdout', () => {
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(
|
||
result.success,
|
||
`audit-open --json must not crash. stderr: ${result.error}`
|
||
);
|
||
assert.ok(
|
||
!/ReferenceError.*output is not defined/.test(result.error || ''),
|
||
`audit-open --json must not throw ReferenceError. stderr: ${result.error}`
|
||
);
|
||
assert.ok(
|
||
result.output && result.output.length > 0,
|
||
'audit-open --json must write output to stdout'
|
||
);
|
||
let parsed;
|
||
assert.doesNotThrow(
|
||
() => { parsed = JSON.parse(result.output); },
|
||
'audit-open --json must emit valid JSON'
|
||
);
|
||
assert.ok(
|
||
parsed !== null && typeof parsed === 'object',
|
||
'audit-open --json must emit a JSON object or array'
|
||
);
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
// Folded from tests/bug-2911-audit-open-output-shape.test.cjs — consolidation epic #1969 (B2 #1971)
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
{
|
||
const { describe: __foldDescribe } = require('node:test');
|
||
__foldDescribe("folded:bug-2911-audit-open-output-shape (consolidation epic #1969 B2 #1971)", () => {
|
||
'use strict';
|
||
|
||
/**
|
||
* Regression test for #2911.
|
||
*
|
||
* Two bugs in the `audit-open` dispatch case in bin/gsd-tools.cjs:
|
||
*
|
||
* 1. Bare `output(...)` calls (only `core.output` is in scope) → ReferenceError.
|
||
* 2. Even after switching to `core.output(formatted, raw)`, the human-readable
|
||
* branch JSON-stringifies the formatted string because `core.output` only
|
||
* bypasses JSON encoding when called as `core.output(null, true, rawValue)`.
|
||
* Result: stdout contains `"### Milestone Close: …\n…"` (a JSON string
|
||
* literal) instead of the rendered report.
|
||
*
|
||
* The shape assertions below catch both regressions structurally — never via
|
||
* substring matching on serialized output:
|
||
*
|
||
* - text mode: parse stdout as a sequence of lines and assert the expected
|
||
* section headers exist as standalone lines (i.e. raw text, not escaped).
|
||
* If the report is JSON-stringified, the stdout is a single line wrapped
|
||
* in double quotes with `\n` escapes — line-array assertions fail.
|
||
* - --json mode: JSON.parse the stdout and assert the keys returned by
|
||
* `auditOpenArtifacts(cwd)` (scanned_at, has_open_items, counts, items)
|
||
* are present and well-typed.
|
||
*/
|
||
|
||
const { test, describe, beforeEach, afterEach } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
|
||
const { runGsdTools, createTempProject, cleanup } = require('./helpers.cjs');
|
||
|
||
// ─── #3458 fixtures: phase-scoped scanners must also see archived phases ─────
|
||
//
|
||
// scanUatGaps, scanVerificationGaps, scanContextQuestions, and scanDeferredItems
|
||
// resolve ONLY the active `.planning/phases/` root. Once a milestone closes and
|
||
// its phase dirs move to `.planning/milestones/v<X.Y>-phases/`, items still
|
||
// unresolved at that moment become invisible to every later audit — these
|
||
// fixtures carry one item of each of the four kinds, in both an "unresolved"
|
||
// (must be counted) and a "resolved" (must NOT be counted) shape, verified
|
||
// against the real scanner formats before being repurposed for the archived
|
||
// layout below.
|
||
|
||
const UAT_GAP_UNRESOLVED = [
|
||
'# UAT',
|
||
'',
|
||
'## Gaps',
|
||
'',
|
||
'- truth: an unresolved UAT gap that survived milestone close',
|
||
' status: open',
|
||
'',
|
||
].join('\n');
|
||
|
||
const UAT_GAP_RESOLVED = [
|
||
'---',
|
||
'status: resolved',
|
||
'---',
|
||
'',
|
||
'# UAT',
|
||
'',
|
||
'## Gaps',
|
||
'',
|
||
'- truth: a gap that was resolved',
|
||
'',
|
||
].join('\n');
|
||
|
||
const VERIFICATION_GAP_UNRESOLVED = [
|
||
'---',
|
||
'status: gaps_found',
|
||
'---',
|
||
'',
|
||
'# Verification',
|
||
'',
|
||
'Gaps found during verification.',
|
||
'',
|
||
].join('\n');
|
||
|
||
const VERIFICATION_GAP_RESOLVED = [
|
||
'---',
|
||
'status: passed',
|
||
'---',
|
||
'',
|
||
'# Verification',
|
||
'',
|
||
'All checks passed.',
|
||
'',
|
||
].join('\n');
|
||
|
||
const CONTEXT_QUESTION_OPEN = [
|
||
'# Context',
|
||
'',
|
||
'## Open Questions',
|
||
'',
|
||
'- Should this default to strict mode?',
|
||
'',
|
||
].join('\n');
|
||
|
||
const CONTEXT_QUESTION_RESOLVED = [
|
||
'# Context',
|
||
'',
|
||
'## Open Questions',
|
||
'',
|
||
'None',
|
||
'',
|
||
].join('\n');
|
||
|
||
const DEFERRED_ITEM_UNRESOLVED = [
|
||
'# Deferred Items',
|
||
'',
|
||
'- **STILL-OPEN:** an unresolved deferred item that survived milestone close',
|
||
'',
|
||
].join('\n');
|
||
|
||
const DEFERRED_ITEM_RESOLVED = [
|
||
'# Deferred Items',
|
||
'',
|
||
'- **RESOLVED-ITEM:** an item that was resolved',
|
||
' status: resolved',
|
||
'',
|
||
].join('\n');
|
||
|
||
/**
|
||
* Write one phase's worth of UAT/VERIFICATION/CONTEXT/deferred-items files
|
||
* (one of each of the four scanner-recognized kinds) into `phaseDir`, using
|
||
* `phaseNumberPrefix` (e.g. '01') as the file-token so `scopeToPhase` (#3511)
|
||
* accepts them for a dir named `<phaseNumberPrefix>-<slug>`.
|
||
*/
|
||
function writePhaseArtifacts(phaseDir, phaseNumberPrefix, { uat, verification, context, deferred }) {
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(path.join(phaseDir, `${phaseNumberPrefix}-UAT.md`), uat);
|
||
fs.writeFileSync(path.join(phaseDir, `${phaseNumberPrefix}-VERIFICATION.md`), verification);
|
||
fs.writeFileSync(path.join(phaseDir, `${phaseNumberPrefix}-CONTEXT.md`), context);
|
||
fs.writeFileSync(path.join(phaseDir, 'deferred-items.md'), deferred);
|
||
}
|
||
|
||
const UNRESOLVED_ARTIFACTS = {
|
||
uat: UAT_GAP_UNRESOLVED,
|
||
verification: VERIFICATION_GAP_UNRESOLVED,
|
||
context: CONTEXT_QUESTION_OPEN,
|
||
deferred: DEFERRED_ITEM_UNRESOLVED,
|
||
};
|
||
|
||
const RESOLVED_ARTIFACTS = {
|
||
uat: UAT_GAP_RESOLVED,
|
||
verification: VERIFICATION_GAP_RESOLVED,
|
||
context: CONTEXT_QUESTION_RESOLVED,
|
||
deferred: DEFERRED_ITEM_RESOLVED,
|
||
};
|
||
|
||
describe('audit-open — output shape (#2911)', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => {
|
||
tmpDir = createTempProject('gsd-bug-2911-');
|
||
});
|
||
|
||
afterEach(() => {
|
||
cleanup(tmpDir);
|
||
});
|
||
|
||
test('text mode emits the formatted report as raw text (not JSON-encoded)', () => {
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(
|
||
result.success,
|
||
`audit-open must not crash. stderr: ${result.error}`
|
||
);
|
||
|
||
const lines = result.output.split('\n').map(l => l.trim()).filter(Boolean);
|
||
|
||
// The first non-empty line must be the rendered Markdown heading row, *not*
|
||
// a JSON-encoded string starting with a quote. If core.output JSON-stringified
|
||
// the formatted report, the entire payload sits on one line wrapped in
|
||
// double quotes ("### Milestone Close: …\n…").
|
||
assert.ok(
|
||
!result.output.startsWith('"'),
|
||
'text-mode stdout must not begin with a JSON quote (would mean the report was JSON.stringified)'
|
||
);
|
||
assert.ok(
|
||
!result.output.includes('\\n'),
|
||
'text-mode stdout must not contain literal "\\n" sequences (would mean the report was JSON.stringified)'
|
||
);
|
||
|
||
// Section headers from formatAuditReport that must appear as standalone lines.
|
||
assert.ok(
|
||
lines.includes('### Milestone Close: Open Artifact Audit'),
|
||
`expected report title as a standalone Markdown heading line; got lines: ${JSON.stringify(lines.slice(0, 5))}`
|
||
);
|
||
assert.ok(
|
||
lines.includes('All artifact types clear. Safe to proceed.'),
|
||
`expected the empty-state line as standalone text; got lines: ${JSON.stringify(lines)}`
|
||
);
|
||
});
|
||
|
||
test('--json mode emits parseable JSON matching auditOpenArtifacts shape', () => {
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(
|
||
result.success,
|
||
`audit-open --json must not crash. stderr: ${result.error}`
|
||
);
|
||
|
||
let parsed;
|
||
assert.doesNotThrow(
|
||
() => { parsed = JSON.parse(result.output); },
|
||
'audit-open --json must emit valid JSON (not a doubly-stringified string)'
|
||
);
|
||
|
||
assert.equal(typeof parsed, 'object', 'parsed payload must be an object');
|
||
assert.ok(parsed !== null, 'parsed payload must not be null');
|
||
|
||
// Shape contract from auditOpenArtifacts() in gsd-core/bin/lib/audit.cjs.
|
||
assert.equal(typeof parsed.scanned_at, 'string', 'must include scanned_at ISO timestamp');
|
||
assert.equal(typeof parsed.has_open_items, 'boolean', 'must include has_open_items boolean');
|
||
assert.equal(typeof parsed.counts, 'object', 'must include counts object');
|
||
assert.equal(typeof parsed.items, 'object', 'must include items object');
|
||
|
||
const expectedCountKeys = [
|
||
'debug_sessions', 'quick_tasks', 'threads', 'todos',
|
||
'seeds', 'uat_gaps', 'verification_gaps', 'context_questions',
|
||
'deferred_items', 'total',
|
||
];
|
||
for (const key of expectedCountKeys) {
|
||
assert.equal(
|
||
typeof parsed.counts[key], 'number',
|
||
`counts.${key} must be a number`
|
||
);
|
||
}
|
||
|
||
const expectedItemKeys = [
|
||
'debug_sessions', 'quick_tasks', 'threads', 'todos',
|
||
'seeds', 'uat_gaps', 'verification_gaps', 'context_questions',
|
||
'deferred_items',
|
||
];
|
||
for (const key of expectedItemKeys) {
|
||
assert.ok(
|
||
Array.isArray(parsed.items[key]),
|
||
`items.${key} must be an array`
|
||
);
|
||
}
|
||
});
|
||
|
||
// ── #3458: phase-scoped scanners must also see archived phases ────────────
|
||
//
|
||
// scanUatGaps, scanVerificationGaps, scanContextQuestions, and
|
||
// scanDeferredItems resolve ONLY the active `.planning/phases/` root. Once a
|
||
// milestone closes and its phase dirs move to
|
||
// `.planning/milestones/v<X.Y>-phases/`, items still unresolved at that
|
||
// moment become invisible to every later audit.
|
||
|
||
test('#3458 archived-only project: unresolved items in .planning/milestones/vX.Y-phases/ are counted', () => {
|
||
// The active phases root is scaffolded empty by createTempProject; the bug
|
||
// report's own repro has it ABSENT entirely in a fully-archived project —
|
||
// remove it so this fixture matches that exactly, not just "empty".
|
||
// eslint-disable-next-line local/no-raw-rmsync-in-tests -- removing only the .planning/phases subdir within a still-live fixture (INFO-7 fix for #3458 review: fs.rmdirSync threw on a non-empty dir); helpers.cleanup() tears down the whole tmpDir, not a subdirectory, so it cannot substitute here.
|
||
fs.rmSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true, force: true });
|
||
|
||
const archivedPhaseDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '01-alpha');
|
||
writePhaseArtifacts(archivedPhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
assert.equal(parsed.counts.uat_gaps, 1, `uat_gaps: expected 1, got ${parsed.counts.uat_gaps}`);
|
||
assert.equal(parsed.counts.verification_gaps, 1, `verification_gaps: expected 1, got ${parsed.counts.verification_gaps}`);
|
||
assert.equal(parsed.counts.context_questions, 1, `context_questions: expected 1, got ${parsed.counts.context_questions}`);
|
||
assert.equal(parsed.counts.deferred_items, 1, `deferred_items: expected 1, got ${parsed.counts.deferred_items}`);
|
||
assert.equal(parsed.has_open_items, true, 'has_open_items must be true when an archived phase carries unresolved items');
|
||
});
|
||
|
||
test('#3458 mixed project: active AND archived phases are both scanned and summed (not one replacing the other)', () => {
|
||
const activePhaseDir = path.join(tmpDir, '.planning', 'phases', '01-alpha');
|
||
writePhaseArtifacts(activePhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const archivedPhaseDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '02-beta');
|
||
writePhaseArtifacts(archivedPhaseDir, '02', UNRESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
assert.equal(parsed.counts.uat_gaps, 2, `uat_gaps: expected 2 (1 active + 1 archived), got ${parsed.counts.uat_gaps}`);
|
||
assert.equal(parsed.counts.verification_gaps, 2, `verification_gaps: expected 2, got ${parsed.counts.verification_gaps}`);
|
||
assert.equal(parsed.counts.context_questions, 2, `context_questions: expected 2, got ${parsed.counts.context_questions}`);
|
||
assert.equal(parsed.counts.deferred_items, 2, `deferred_items: expected 2, got ${parsed.counts.deferred_items}`);
|
||
assert.equal(parsed.has_open_items, true, 'has_open_items must be true');
|
||
});
|
||
|
||
test('#3458 active-only project: unchanged behavior, unresolved items still counted (guards the pre-existing path)', () => {
|
||
const activePhaseDir = path.join(tmpDir, '.planning', 'phases', '01-alpha');
|
||
writePhaseArtifacts(activePhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
assert.equal(parsed.counts.uat_gaps, 1, `uat_gaps: expected 1, got ${parsed.counts.uat_gaps}`);
|
||
assert.equal(parsed.counts.verification_gaps, 1, `verification_gaps: expected 1, got ${parsed.counts.verification_gaps}`);
|
||
assert.equal(parsed.counts.context_questions, 1, `context_questions: expected 1, got ${parsed.counts.context_questions}`);
|
||
assert.equal(parsed.counts.deferred_items, 1, `deferred_items: expected 1, got ${parsed.counts.deferred_items}`);
|
||
assert.equal(parsed.has_open_items, true, 'has_open_items must be true');
|
||
});
|
||
|
||
test('#3458 archived-only project with all-RESOLVED items: contributes 0 (fix must not blindly count archived files)', () => {
|
||
// eslint-disable-next-line local/no-raw-rmsync-in-tests -- removing only the .planning/phases subdir within a still-live fixture (INFO-7 fix for #3458 review: fs.rmdirSync threw on a non-empty dir); helpers.cleanup() tears down the whole tmpDir, not a subdirectory, so it cannot substitute here.
|
||
fs.rmSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true, force: true });
|
||
|
||
const archivedPhaseDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '01-alpha');
|
||
writePhaseArtifacts(archivedPhaseDir, '01', RESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
assert.equal(parsed.counts.uat_gaps, 0, `uat_gaps: expected 0 (resolved), got ${parsed.counts.uat_gaps}`);
|
||
assert.equal(parsed.counts.verification_gaps, 0, `verification_gaps: expected 0 (resolved), got ${parsed.counts.verification_gaps}`);
|
||
assert.equal(parsed.counts.context_questions, 0, `context_questions: expected 0 (resolved), got ${parsed.counts.context_questions}`);
|
||
assert.equal(parsed.counts.deferred_items, 0, `deferred_items: expected 0 (resolved), got ${parsed.counts.deferred_items}`);
|
||
assert.equal(parsed.has_open_items, false, 'has_open_items must be false when the only archived phase is fully resolved');
|
||
});
|
||
|
||
// ── phase-directory-name forgery (sanitizeLabel) ───────────────────────────
|
||
//
|
||
// A phase directory NAME (not file content) is filesystem-controlled, not
|
||
// frontmatter-controlled — a doctored checkout can name a directory
|
||
// anything. `phaseNum` falls back to the raw directory name verbatim when
|
||
// it doesn't match PHASE_NUMBER_TOKEN_SOURCE, so an embedded `\n`/ESC in
|
||
// the NAME itself used to reach the human report unescaped
|
||
// (`sanitizeForDisplay` deliberately preserves newlines — it is not the
|
||
// right tool for a single-line label). `sanitizeLabel` (src/security.cts)
|
||
// closes this by escaping control bytes rather than stripping them.
|
||
const FORGED_PHASE_DIR_NAME = 'zz\n0 open items require decisions.\n\x1b[2K\x1b[1G FORGED';
|
||
|
||
/**
|
||
* Windows/NTFS forbids control characters (including \n and ESC/0x1B) in
|
||
* path components, so `mkdirSync` throws ENOENT there rather than creating
|
||
* the doctored directory — the directory-name forgery vector these tests
|
||
* exercise does not exist on that platform. `t.skip()` degrades cleanly
|
||
* (same convention as trySymlink() in tests/adr-index-gate.test.cjs, which
|
||
* skips on EPERM for the analogous symlink-creation gap); a bare `return`
|
||
* would silently report a PASS in node:test and hide the gap. The
|
||
* sanitizer itself (`sanitizeLabel`) remains fully covered on every
|
||
* platform by the platform-independent, filesystem-free string tests in
|
||
* tests/security.test.cjs (describe('sanitizeLabel', ...)).
|
||
*/
|
||
function tryMkdirForgedName(t, dirPath) {
|
||
try {
|
||
fs.mkdirSync(dirPath, { recursive: true });
|
||
return true;
|
||
} catch (err) {
|
||
if (err && (err.code === 'ENOENT' || err.code === 'EINVAL')) {
|
||
t.skip(`cannot create a directory name with control characters on this platform (${err.code})`);
|
||
return false;
|
||
}
|
||
throw err;
|
||
}
|
||
}
|
||
|
||
test('a phase directory name containing a newline cannot forge a new report line', (t) => {
|
||
const forgedPhaseDir = path.join(tmpDir, '.planning', 'phases', FORGED_PHASE_DIR_NAME);
|
||
if (!tryMkdirForgedName(t, forgedPhaseDir)) return;
|
||
fs.writeFileSync(path.join(forgedPhaseDir, 'deferred-items.md'), DEFERRED_ITEM_UNRESOLVED);
|
||
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(result.success, `audit-open must not crash. stderr: ${result.error}`);
|
||
|
||
const lines = result.output.split('\n').map(l => l.trim());
|
||
assert.ok(
|
||
!lines.includes('0 open items require decisions.'),
|
||
`the doctored directory name must not inject its own report line; got lines: ${JSON.stringify(lines)}`
|
||
);
|
||
});
|
||
|
||
test('a phase directory name with an ESC/ANSI payload never reaches raw output', (t) => {
|
||
const forgedPhaseDir = path.join(tmpDir, '.planning', 'phases', FORGED_PHASE_DIR_NAME);
|
||
if (!tryMkdirForgedName(t, forgedPhaseDir)) return;
|
||
fs.writeFileSync(path.join(forgedPhaseDir, 'deferred-items.md'), DEFERRED_ITEM_UNRESOLVED);
|
||
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(result.success, `audit-open must not crash. stderr: ${result.error}`);
|
||
|
||
assert.ok(
|
||
!result.output.includes('\x1b'),
|
||
'no raw ESC byte from the doctored directory name may reach the report output'
|
||
);
|
||
});
|
||
|
||
// ── adversarial-review follow-ups on #3458 ─────────────────────────────────
|
||
|
||
test('WARNING-4a: archived_milestone is present (correct value) on archived items and absent (no key at all) on active items', () => {
|
||
const activePhaseDir = path.join(tmpDir, '.planning', 'phases', '01-alpha');
|
||
writePhaseArtifacts(activePhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const archivedPhaseDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '02-beta');
|
||
writePhaseArtifacts(archivedPhaseDir, '02', UNRESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
for (const category of ['uat_gaps', 'verification_gaps', 'context_questions', 'deferred_items']) {
|
||
const items = parsed.items[category].filter(i => !i.scan_error);
|
||
const active = items.find(i => i.phase === '01');
|
||
const archived = items.find(i => i.phase === '02');
|
||
assert.ok(active, `${category}: expected an active-phase item; got: ${JSON.stringify(items)}`);
|
||
assert.ok(archived, `${category}: expected an archived-phase item; got: ${JSON.stringify(items)}`);
|
||
assert.strictEqual('archived_milestone' in active, false,
|
||
`${category}: active item must not carry the archived_milestone key at all`);
|
||
assert.strictEqual(archived.archived_milestone, 'v1.0',
|
||
`${category}: archived item must carry archived_milestone: 'v1.0'`);
|
||
}
|
||
});
|
||
|
||
test('BLOCKER-1 regression: an unreadable active root (a FILE at .planning/phases) still yields a scan_error sentinel in all four phase-scoped categories', () => {
|
||
// eslint-disable-next-line local/no-raw-rmsync-in-tests -- removing only the .planning/phases subdir within a still-live fixture (INFO-7 fix for #3458 review: fs.rmdirSync threw on a non-empty dir); helpers.cleanup() tears down the whole tmpDir, not a subdirectory, so it cannot substitute here.
|
||
fs.rmSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true, force: true });
|
||
fs.writeFileSync(path.join(tmpDir, '.planning', 'phases'), 'not a directory');
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
for (const category of ['uat_gaps', 'verification_gaps', 'context_questions', 'deferred_items']) {
|
||
const sentinel = parsed.items[category].find(i => i.scan_error === true);
|
||
assert.ok(sentinel,
|
||
`${category}: expected a scan_error sentinel when the active root is unreadable (ENOTDIR); ` +
|
||
`got: ${JSON.stringify(parsed.items[category])}`);
|
||
}
|
||
});
|
||
|
||
test('an unreadable archived root does not prevent the active half from being scanned (no sentinel for the archive half — see docstring)', () => {
|
||
const activePhaseDir = path.join(tmpDir, '.planning', 'phases', '01-alpha');
|
||
writePhaseArtifacts(activePhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
// Make `.planning/milestones` an unreadable FILE instead of a directory so
|
||
// getArchivedPhaseDirs's readdirSync throws (ENOTDIR).
|
||
fs.writeFileSync(path.join(tmpDir, '.planning', 'milestones'), 'not a directory');
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
// Active half still scanned — the four counts include the active item.
|
||
assert.equal(parsed.counts.uat_gaps, 1, `uat_gaps: expected 1 (active only), got ${parsed.counts.uat_gaps}`);
|
||
assert.equal(parsed.counts.verification_gaps, 1, `verification_gaps: expected 1, got ${parsed.counts.verification_gaps}`);
|
||
assert.equal(parsed.counts.context_questions, 1, `context_questions: expected 1, got ${parsed.counts.context_questions}`);
|
||
assert.equal(parsed.counts.deferred_items, 1, `deferred_items: expected 1, got ${parsed.counts.deferred_items}`);
|
||
|
||
// Pinned decision: an unreadable archive root does NOT get a scan_error
|
||
// sentinel (no pre-#3458 contract to preserve for it — see the
|
||
// listAuditPhaseTargets docstring).
|
||
for (const category of ['uat_gaps', 'verification_gaps', 'context_questions', 'deferred_items']) {
|
||
const hasSentinel = parsed.items[category].some(i => i.scan_error === true);
|
||
assert.strictEqual(hasSentinel, false,
|
||
`${category}: an unreadable archive root must not produce a scan_error sentinel; got: ${JSON.stringify(parsed.items[category])}`);
|
||
}
|
||
});
|
||
|
||
test('WARNING-3: duplicate phase name across active and archived roots produces two distinct entries, and the human report distinguishes them', () => {
|
||
const activePhaseDir = path.join(tmpDir, '.planning', 'phases', '01-alpha');
|
||
writePhaseArtifacts(activePhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const archivedPhaseDir = path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '01-alpha');
|
||
writePhaseArtifacts(archivedPhaseDir, '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const jsonResult = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(jsonResult.success, `audit-open --json must not crash. stderr: ${jsonResult.error}`);
|
||
const parsed = JSON.parse(jsonResult.output);
|
||
|
||
const uatEntries = parsed.items.uat_gaps.filter(i => !i.scan_error);
|
||
assert.equal(uatEntries.length, 2,
|
||
`same-named active + archived phase must produce two distinct uat_gaps entries; got: ${JSON.stringify(uatEntries)}`);
|
||
const archivedFlags = uatEntries.map(i => Boolean(i.archived_milestone)).sort();
|
||
assert.deepEqual(archivedFlags, [false, true],
|
||
'exactly one of the two duplicate-named entries must carry archived_milestone');
|
||
|
||
const textResult = runGsdTools(['audit-open'], tmpDir);
|
||
assert.ok(textResult.success, `audit-open (text) must not crash. stderr: ${textResult.error}`);
|
||
const uatLines = textResult.output.split('\n').filter(l => l.includes('01-UAT.md'));
|
||
assert.equal(uatLines.length, 2,
|
||
`expected two UAT-gap report lines (one active, one archived); got: ${JSON.stringify(uatLines)}`);
|
||
assert.notStrictEqual(uatLines[0], uatLines[1],
|
||
'the active and archived duplicate-named entries must render as distinguishable lines, not byte-identical duplicates');
|
||
assert.ok(uatLines.some(l => l.includes('archived v1.0')),
|
||
`expected one report line to be labeled with its archived milestone; got: ${JSON.stringify(uatLines)}`);
|
||
});
|
||
|
||
test('INFO-5: archived milestones v1.0, v1.9, v1.10 sort newest-first, numerically (v1.10 before v1.9, not lexicographically)', () => {
|
||
writePhaseArtifacts(path.join(tmpDir, '.planning', 'milestones', 'v1.0-phases', '01-a'), '01', UNRESOLVED_ARTIFACTS);
|
||
writePhaseArtifacts(path.join(tmpDir, '.planning', 'milestones', 'v1.9-phases', '01-b'), '01', UNRESOLVED_ARTIFACTS);
|
||
writePhaseArtifacts(path.join(tmpDir, '.planning', 'milestones', 'v1.10-phases', '01-c'), '01', UNRESOLVED_ARTIFACTS);
|
||
|
||
const result = runGsdTools(['audit-open', '--json'], tmpDir);
|
||
assert.ok(result.success, `audit-open --json must not crash. stderr: ${result.error}`);
|
||
const parsed = JSON.parse(result.output);
|
||
|
||
const milestoneOrder = parsed.items.uat_gaps.filter(i => !i.scan_error).map(i => i.archived_milestone);
|
||
assert.deepEqual(milestoneOrder, ['v1.10', 'v1.9', 'v1.0'],
|
||
`expected numeric-aware newest-first ordering (v1.10, v1.9, v1.0); got: ${JSON.stringify(milestoneOrder)}`);
|
||
});
|
||
|
||
// ── quick-task directory-name forgery (sanitizeLabel) ──────────────────────
|
||
//
|
||
// scanQuickTasks derives `slug` from the `.planning/quick/<dirName>`
|
||
// directory NAME (filesystem-controlled, same shape as the phase-directory
|
||
// case above), not from file content. Before sanitizeLabel was applied
|
||
// here, an embedded `\n`/ESC byte in the directory name reached the human
|
||
// report unescaped via `sanitizeForDisplay` (which deliberately preserves
|
||
// newlines — it is not the right tool for a single-line label).
|
||
const FORGED_QUICK_TASK_DIR_NAME = 'zz\n0 open items require decisions.\n\x1b[2K\x1b[1G FORGED';
|
||
|
||
test('a quick-task directory name containing a newline cannot forge a new report line', (t) => {
|
||
const forgedQuickDir = path.join(tmpDir, '.planning', 'quick', FORGED_QUICK_TASK_DIR_NAME);
|
||
if (!tryMkdirForgedName(t, forgedQuickDir)) return;
|
||
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(result.success, `audit-open must not crash. stderr: ${result.error}`);
|
||
|
||
const lines = result.output.split('\n').map(l => l.trim());
|
||
assert.ok(
|
||
!lines.includes('0 open items require decisions.'),
|
||
`the doctored directory name must not inject its own report line; got lines: ${JSON.stringify(lines)}`
|
||
);
|
||
});
|
||
|
||
test('a quick-task directory name with an ESC/ANSI payload never reaches raw output', (t) => {
|
||
const forgedQuickDir = path.join(tmpDir, '.planning', 'quick', FORGED_QUICK_TASK_DIR_NAME);
|
||
if (!tryMkdirForgedName(t, forgedQuickDir)) return;
|
||
|
||
const result = runGsdTools('audit-open', tmpDir);
|
||
assert.ok(result.success, `audit-open must not crash. stderr: ${result.error}`);
|
||
|
||
assert.ok(
|
||
!result.output.includes('\x1b'),
|
||
'no raw ESC byte from the doctored directory name may reach the report output'
|
||
);
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
// Folded from tests/bug-2836-audit-open-summary-uat-drift.test.cjs — consolidation epic #1969 (B3 #1972)
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
{
|
||
const { describe: __foldDescribe } = require('node:test');
|
||
__foldDescribe("folded:bug-2836-audit-open-summary-uat-drift (consolidation epic #1969 B3 #1972)", () => {
|
||
/**
|
||
* Regression tests for bug #2836
|
||
*
|
||
* audit-open had two convention drifts vs the documented workflows:
|
||
* 1. quick-task scanner looked for bare `SUMMARY.md`, but workflows/quick.md
|
||
* mandates `${quick_id}-SUMMARY.md`. Result: every documented quick task
|
||
* reported as `status: missing`.
|
||
* 2. UAT terminal-status enum only accepted `complete`, but
|
||
* workflows/execute-phase.md uses `resolved` post-gap-closure.
|
||
* Result: gap-closed UATs reported as open.
|
||
*
|
||
* Tests structurally invoke auditOpenArtifacts() against real fixtures on disk
|
||
* and assert the returned items array — never regex on raw file content.
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
const { describe, test, before, after } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
const os = require('node:os');
|
||
|
||
const auditModule = require('../gsd-core/bin/lib/audit.cjs');
|
||
const { auditOpenArtifacts } = auditModule;
|
||
const { cleanup } = require('./helpers.cjs');
|
||
|
||
function mkTmp() {
|
||
return fs.mkdtempSync(path.join(os.tmpdir(), 'bug-2836-'));
|
||
}
|
||
|
||
describe('bug #2836: audit-open quick-task summary filename + UAT terminal status', () => {
|
||
// Ensure GSD env vars do not redirect planningDir() away from our fixture.
|
||
let prevProject, prevWorkstream;
|
||
before(() => {
|
||
prevProject = process.env.GSD_PROJECT;
|
||
prevWorkstream = process.env.GSD_WORKSTREAM;
|
||
delete process.env.GSD_PROJECT;
|
||
delete process.env.GSD_WORKSTREAM;
|
||
});
|
||
after(() => {
|
||
if (prevProject !== undefined) process.env.GSD_PROJECT = prevProject;
|
||
if (prevWorkstream !== undefined) process.env.GSD_WORKSTREAM = prevWorkstream;
|
||
});
|
||
|
||
test('quick task with ${quick_id}-SUMMARY.md is recognized as complete (not missing)', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260429-test-foo';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(taskDir, `${quickId}-SUMMARY.md`),
|
||
'---\nstatus: complete\n---\ntest summary\n',
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
|
||
assert.equal(
|
||
realQuickTasks.length, 0,
|
||
`quick task with ${quickId}-SUMMARY.md (status: complete) must not appear ` +
|
||
`as an open item; got: ${JSON.stringify(realQuickTasks)}`
|
||
);
|
||
assert.equal(result.counts.quick_tasks, 0);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('UAT with status: resolved is treated as terminal (not an open gap)', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '01-test');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '01-UAT.md'),
|
||
'---\nstatus: resolved\n---\nUAT body — gap closed via execute-phase flow.\n',
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realUatGaps = result.items.uat_gaps.filter(i => !i.scan_error);
|
||
|
||
assert.equal(
|
||
realUatGaps.length, 0,
|
||
`UAT with status: resolved must not appear as an open gap; ` +
|
||
`got: ${JSON.stringify(realUatGaps)}`
|
||
);
|
||
assert.equal(result.counts.uat_gaps, 0);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('UAT with status: complete remains terminal (no regression)', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '02-test');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '02-UAT.md'),
|
||
'---\nstatus: complete\n---\nUAT body.\n',
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realUatGaps = result.items.uat_gaps.filter(i => !i.scan_error);
|
||
assert.equal(realUatGaps.length, 0);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('UAT with status: pending is still flagged as an open gap', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '03-test');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '03-UAT.md'),
|
||
'---\nstatus: pending\n---\nresult: pending\n',
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realUatGaps = result.items.uat_gaps.filter(i => !i.scan_error);
|
||
assert.equal(realUatGaps.length, 1, 'pending UAT must still be flagged');
|
||
assert.equal(realUatGaps[0].status, 'pending');
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('#3511: scanUatGaps excludes a cross-phase stray UAT file sitting in the same phase dir; this phase\'s own open gap still reports', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '03-test');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
// This phase's own open UAT gap.
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '03-UAT.md'),
|
||
'---\nstatus: pending\n---\nresult: pending\n',
|
||
'utf-8',
|
||
);
|
||
// Cross-phase stray in the SAME directory — token "04", not "03".
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '04-UAT.md'),
|
||
'---\nstatus: pending\n---\nresult: pending\n',
|
||
'utf-8',
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realUatGaps = result.items.uat_gaps.filter(i => !i.scan_error);
|
||
|
||
assert.equal(realUatGaps.length, 1,
|
||
`only this phase's own gap must report; got: ${JSON.stringify(realUatGaps)}`);
|
||
assert.equal(realUatGaps[0].file, '03-UAT.md');
|
||
assert.equal(realUatGaps[0].phase, '03');
|
||
assert.ok(!realUatGaps.some(i => i.file === '04-UAT.md'),
|
||
'the cross-phase stray must not appear in uat_gaps');
|
||
assert.equal(result.counts.uat_gaps, 1);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('#3511: scanVerificationGaps excludes a cross-phase stray VERIFICATION file sitting in the same phase dir; this phase\'s own open gap still reports', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '03-test');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
// This phase's own open VERIFICATION gap.
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '03-VERIFICATION.md'),
|
||
'---\nstatus: gaps_found\n---\n# Verification\n',
|
||
'utf-8',
|
||
);
|
||
// Cross-phase stray in the SAME directory — token "04", not "03".
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '04-VERIFICATION.md'),
|
||
'---\nstatus: human_needed\n---\n# Verification\n',
|
||
'utf-8',
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realVerificationGaps = result.items.verification_gaps.filter(i => !i.scan_error);
|
||
|
||
assert.equal(realVerificationGaps.length, 1,
|
||
`only this phase's own gap must report; got: ${JSON.stringify(realVerificationGaps)}`);
|
||
assert.equal(realVerificationGaps[0].file, '03-VERIFICATION.md');
|
||
assert.equal(realVerificationGaps[0].phase, '03');
|
||
assert.ok(!realVerificationGaps.some(i => i.file === '04-VERIFICATION.md'),
|
||
'the cross-phase stray must not appear in verification_gaps');
|
||
assert.equal(result.counts.verification_gaps, 1);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('#3511 follow-up: own gap still reports from a NON-canonical dir shape (over-exclusion check)', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
// "1-unpadded" tokenizes to literal "1", but scaffold writes the PADDED
|
||
// "01-…" form — a literal token compare excluded the phase's own file.
|
||
const phaseDir = path.join(cwd, '.planning', 'phases', '1-unpadded');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '01-UAT.md'),
|
||
'---\nstatus: partial\n---\n\n## Tests\n\n### 1. Test\nexpected: works\nresult: pending\n',
|
||
'utf-8',
|
||
);
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, '01-VERIFICATION.md'),
|
||
'---\nstatus: gaps_found\n---\n# Verification\n',
|
||
'utf-8',
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realUatGaps = result.items.uat_gaps.filter(i => !i.scan_error);
|
||
const realVerificationGaps = result.items.verification_gaps.filter(i => !i.scan_error);
|
||
|
||
assert.equal(realUatGaps.length, 1,
|
||
`own UAT gap in an unpadded-dir phase must still report; got: ${JSON.stringify(realUatGaps)}`);
|
||
assert.equal(realVerificationGaps.length, 1,
|
||
`own VERIFICATION gap in an unpadded-dir phase must still report; got: ${JSON.stringify(realVerificationGaps)}`);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('quick task without any SUMMARY file is still flagged as missing', () => {
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260429-test-bar';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
// No SUMMARY file at all.
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
assert.equal(realQuickTasks.length, 1);
|
||
assert.equal(realQuickTasks[0].status, 'missing');
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
});
|
||
|
||
describe('bug #2836: workflows/help.md one-liner reconciliation', () => {
|
||
test('help.md quick-task one-liner uses ${quick_id}-SUMMARY.md pattern', () => {
|
||
// After #3039, help content moved into help/modes/full.md.
|
||
const helpPath = path.resolve(
|
||
__dirname, '..', 'gsd-core', 'workflows', 'help', 'modes', 'full.md'
|
||
);
|
||
const content = fs.readFileSync(helpPath, 'utf-8');
|
||
|
||
// Locate the documented "Result: Creates ..." quick-task one-liner and
|
||
// assert it references the per-task SUMMARY filename pattern, not bare
|
||
// SUMMARY.md. We parse by line to avoid false positives elsewhere.
|
||
const resultLines = content.split(/\r?\n/).filter(l =>
|
||
l.includes('Result: Creates') && l.includes('.planning/quick/')
|
||
);
|
||
assert.ok(resultLines.length > 0, 'expected a quick-task Result line in help.md');
|
||
for (const line of resultLines) {
|
||
assert.ok(
|
||
/\$\{quick_id\}-SUMMARY\.md|NNN-slug-SUMMARY\.md/.test(line),
|
||
`help.md quick-task Result line must reference per-task SUMMARY filename ` +
|
||
`(e.g. \${quick_id}-SUMMARY.md); got: ${line}`
|
||
);
|
||
}
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
// Folded from tests/bug-950-quick-summary-status-complete.test.cjs — consolidation epic #1969 (B3 #1972)
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
{
|
||
const { describe: __foldDescribe } = require('node:test');
|
||
__foldDescribe("folded:bug-950-quick-summary-status-complete (consolidation epic #1969 B3 #1972)", () => {
|
||
// allow-test-rule: source-text-is-the-product (see #950)
|
||
/**
|
||
* Regression tests for bug #950
|
||
*
|
||
* audit-open chronically flagged genuinely-complete quick tasks as [unknown]
|
||
* because NO shipped summary template carried a `status:` frontmatter field —
|
||
* so status was only emitted when the writing agent improvised it.
|
||
*
|
||
* The fix: add `status: complete` to all four summary templates and enforce it
|
||
* in the executor agent + quick.md workflow. Tests here exercise the scanner
|
||
* directly via auditOpenArtifacts() and also guard template text as a secondary
|
||
* contract check.
|
||
*
|
||
* Primary guard: behavioral audit-scanner tests (tasks read by scanQuickTasks)
|
||
* Secondary guard: template-contract text checks (template text IS the runtime contract)
|
||
* Writer-path guard: contract assertions on quick.md + gsd-executor.md (source-text-is-the-product)
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
const { describe, test, before, after } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
const os = require('node:os');
|
||
|
||
const auditModule = require('../gsd-core/bin/lib/audit.cjs');
|
||
const { auditOpenArtifacts } = auditModule;
|
||
const { cleanup } = require('./helpers.cjs');
|
||
|
||
const TEMPLATES_DIR = path.resolve(__dirname, '..', 'gsd-core', 'templates');
|
||
const QUICK_MD = path.resolve(__dirname, '..', 'gsd-core', 'workflows', 'quick.md');
|
||
const EXECUTOR_MD = path.resolve(__dirname, '..', 'agents', 'gsd-executor.md');
|
||
|
||
function mkTmp() {
|
||
return fs.mkdtempSync(path.join(os.tmpdir(), 'bug-950-'));
|
||
}
|
||
|
||
/**
|
||
* Extract the first YAML frontmatter block from a file's content.
|
||
*
|
||
* Two layouts are handled:
|
||
* - Leading frontmatter: file starts with `---\n…\n---` (summary-minimal/standard/complex.md)
|
||
* - Fenced frontmatter: frontmatter lives inside a ```markdown … ``` fence (summary.md,
|
||
* whose content IS a markdown example showing the template). In that case we extract
|
||
* the `---\n…\n---` block that sits immediately after the opening fence line.
|
||
*
|
||
* Returns the raw text of the YAML block (between the two `---` delimiters, exclusive),
|
||
* or null if no frontmatter could be found.
|
||
*/
|
||
function extractFrontmatter(content) {
|
||
// Case 1: file begins with --- (leading frontmatter)
|
||
if (/^---\r?\n/.test(content)) {
|
||
const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
|
||
return match ? match[1] : null;
|
||
}
|
||
|
||
// Case 2: frontmatter is embedded inside a fenced block (```markdown\n---\n…\n---\n)
|
||
const fenceMatch = content.match(/```(?:markdown|md)?\r?\n(---\r?\n[\s\S]*?\r?\n---)\r?\n/);
|
||
if (fenceMatch) {
|
||
// Strip the outer --- delimiters to get just the YAML body
|
||
const block = fenceMatch[1];
|
||
const inner = block.match(/^---\r?\n([\s\S]*?)\r?\n---$/);
|
||
return inner ? inner[1] : null;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
describe('bug #950: quick-task SUMMARY must carry status: complete', () => {
|
||
// Ensure GSD env vars do not redirect planningDir() away from our fixture.
|
||
let prevProject, prevWorkstream;
|
||
before(() => {
|
||
prevProject = process.env.GSD_PROJECT;
|
||
prevWorkstream = process.env.GSD_WORKSTREAM;
|
||
delete process.env.GSD_PROJECT;
|
||
delete process.env.GSD_WORKSTREAM;
|
||
});
|
||
after(() => {
|
||
if (prevProject !== undefined) process.env.GSD_PROJECT = prevProject;
|
||
if (prevWorkstream !== undefined) process.env.GSD_WORKSTREAM = prevWorkstream;
|
||
});
|
||
|
||
// ── Behavioral: scanner recognizes complete quick tasks ───────────────────
|
||
|
||
test('[PRIMARY] quick task SUMMARY with status: complete is NOT flagged open', () => {
|
||
// Simulates an executor that correctly wrote the SUMMARY with status: complete
|
||
// (as required after the fix). The scanner must report 0 open quick tasks.
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260609-test-status-complete';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(taskDir, `${quickId}-SUMMARY.md`),
|
||
[
|
||
'---',
|
||
'status: complete',
|
||
'date: 2026-06-09',
|
||
'slug: test-status-complete',
|
||
'---',
|
||
'',
|
||
'# Quick Task Summary',
|
||
'',
|
||
'Task completed successfully.',
|
||
].join('\n'),
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
|
||
assert.equal(
|
||
realQuickTasks.length,
|
||
0,
|
||
`quick task SUMMARY with status: complete must NOT appear as open; ` +
|
||
`got: ${JSON.stringify(realQuickTasks)}`
|
||
);
|
||
assert.equal(result.counts.quick_tasks, 0);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('[PRIMARY] quick task SUMMARY without status: field is still flagged [unknown]', () => {
|
||
// Negative case: a SUMMARY that lacks status: still surfaces as [unknown].
|
||
// This proves the scanner still catches real gaps — the fix must be on the writer side.
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260609-test-no-status';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(taskDir, `${quickId}-SUMMARY.md`),
|
||
[
|
||
'---',
|
||
'date: 2026-06-09',
|
||
'slug: test-no-status',
|
||
'---',
|
||
'',
|
||
'# Quick Task Summary',
|
||
'',
|
||
'Task done, but no status field.',
|
||
].join('\n'),
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
|
||
assert.equal(
|
||
realQuickTasks.length,
|
||
1,
|
||
`quick task SUMMARY without status: must appear as open (unknown); ` +
|
||
`got: ${JSON.stringify(realQuickTasks)}`
|
||
);
|
||
assert.equal(realQuickTasks[0].status, 'unknown', 'expected status to be unknown');
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('[PRIMARY] quick task without any SUMMARY is still flagged [missing]', () => {
|
||
// Proves the missing-SUMMARY case still surfaces.
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260609-test-missing-summary';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
// No SUMMARY file at all.
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
|
||
assert.equal(realQuickTasks.length, 1, 'missing SUMMARY must still be flagged');
|
||
assert.equal(realQuickTasks[0].status, 'missing');
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
test('[PRIMARY] SUMMARY with status: COMPLETE (uppercase) is also recognized', () => {
|
||
// Scanner lowercases before comparing — verify case-insensitivity holds.
|
||
const cwd = mkTmp();
|
||
try {
|
||
const quickId = '260609-test-uppercase-complete';
|
||
const taskDir = path.join(cwd, '.planning', 'quick', quickId);
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(taskDir, `${quickId}-SUMMARY.md`),
|
||
'---\nstatus: COMPLETE\n---\n# Summary\nDone.\n',
|
||
'utf-8'
|
||
);
|
||
|
||
const result = auditOpenArtifacts(cwd);
|
||
const realQuickTasks = result.items.quick_tasks.filter(
|
||
i => !i.scan_error && !i._remainder_count
|
||
);
|
||
|
||
assert.equal(
|
||
realQuickTasks.length,
|
||
0,
|
||
`quick task SUMMARY with status: COMPLETE (uppercase) must not appear as open; ` +
|
||
`got: ${JSON.stringify(realQuickTasks)}`
|
||
);
|
||
} finally {
|
||
cleanup(cwd);
|
||
}
|
||
});
|
||
|
||
// ── Secondary: template-contract checks ──────────────────────────────────
|
||
// Assertions are scoped to the actual YAML frontmatter block, not the whole file,
|
||
// so a stray `status: complete` in prose or examples cannot produce a false green.
|
||
|
||
test('[TEMPLATE CONTRACT] summary.md contains status: complete in frontmatter', () => {
|
||
// summary.md is a documentation template — its frontmatter lives inside a
|
||
// ```markdown fence. extractFrontmatter() finds and returns that block.
|
||
const content = fs.readFileSync(path.join(TEMPLATES_DIR, 'summary.md'), 'utf-8');
|
||
const fm = extractFrontmatter(content);
|
||
assert.ok(
|
||
fm !== null,
|
||
'gsd-core/templates/summary.md: could not locate a YAML frontmatter block (leading --- or fenced ```markdown --- block)'
|
||
);
|
||
assert.ok(
|
||
/^status:\s*complete\s*$/m.test(fm),
|
||
`gsd-core/templates/summary.md: \`status: complete\` not found in the frontmatter block.\n` +
|
||
`Frontmatter extracted:\n${fm}`
|
||
);
|
||
});
|
||
|
||
test('[TEMPLATE CONTRACT] summary-minimal.md contains status: complete in frontmatter', () => {
|
||
const content = fs.readFileSync(path.join(TEMPLATES_DIR, 'summary-minimal.md'), 'utf-8');
|
||
const fm = extractFrontmatter(content);
|
||
assert.ok(
|
||
fm !== null,
|
||
'gsd-core/templates/summary-minimal.md: could not locate a leading YAML frontmatter block'
|
||
);
|
||
assert.ok(
|
||
/^status:\s*complete\s*$/m.test(fm),
|
||
`gsd-core/templates/summary-minimal.md: \`status: complete\` not found in the frontmatter block.\n` +
|
||
`Frontmatter extracted:\n${fm}`
|
||
);
|
||
});
|
||
|
||
test('[TEMPLATE CONTRACT] summary-standard.md contains status: complete in frontmatter', () => {
|
||
const content = fs.readFileSync(path.join(TEMPLATES_DIR, 'summary-standard.md'), 'utf-8');
|
||
const fm = extractFrontmatter(content);
|
||
assert.ok(
|
||
fm !== null,
|
||
'gsd-core/templates/summary-standard.md: could not locate a leading YAML frontmatter block'
|
||
);
|
||
assert.ok(
|
||
/^status:\s*complete\s*$/m.test(fm),
|
||
`gsd-core/templates/summary-standard.md: \`status: complete\` not found in the frontmatter block.\n` +
|
||
`Frontmatter extracted:\n${fm}`
|
||
);
|
||
});
|
||
|
||
test('[TEMPLATE CONTRACT] summary-complex.md contains status: complete in frontmatter', () => {
|
||
const content = fs.readFileSync(path.join(TEMPLATES_DIR, 'summary-complex.md'), 'utf-8');
|
||
const fm = extractFrontmatter(content);
|
||
assert.ok(
|
||
fm !== null,
|
||
'gsd-core/templates/summary-complex.md: could not locate a leading YAML frontmatter block'
|
||
);
|
||
assert.ok(
|
||
/^status:\s*complete\s*$/m.test(fm),
|
||
`gsd-core/templates/summary-complex.md: \`status: complete\` not found in the frontmatter block.\n` +
|
||
`Frontmatter extracted:\n${fm}`
|
||
);
|
||
});
|
||
|
||
// ── Writer-path contract checks ───────────────────────────────────────────
|
||
// Guards quick.md and gsd-executor.md so a future edit removing `status: complete`
|
||
// from the SUMMARY-creation instructions would fail the suite before the bug recurs.
|
||
// (source-text-is-the-product: the deployed .md text IS the runtime contract for agents)
|
||
|
||
test('[WRITER-PATH] quick.md constraints require status: complete in SUMMARY frontmatter', () => {
|
||
const content = fs.readFileSync(QUICK_MD, 'utf-8');
|
||
assert.ok(
|
||
/status:\s*complete/.test(content),
|
||
'gsd-core/workflows/quick.md must instruct the executor to write `status: complete` in the SUMMARY frontmatter. ' +
|
||
'The <constraints> block must contain the `status: complete` requirement so a future edit cannot silently drop it.'
|
||
);
|
||
});
|
||
|
||
test('[WRITER-PATH] gsd-executor.md frontmatter spec requires status: complete', () => {
|
||
const content = fs.readFileSync(EXECUTOR_MD, 'utf-8');
|
||
assert.ok(
|
||
/status[\s\S]{0,40}complete/.test(content),
|
||
'agents/gsd-executor.md must document `status: complete` as a required SUMMARY frontmatter field. ' +
|
||
'The Frontmatter section must include `status: complete` so the executor always emits it.'
|
||
);
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
// #3458 follow-up: `audit_acknowledged` suppression seam + the
|
||
// `audit-open acknowledge` CLI writer.
|
||
//
|
||
// BACKGROUND: #3458 made `audit-open` scan archived milestone phase dirs too,
|
||
// so an item still unresolved when a milestone closed now resurfaces at
|
||
// EVERY later close, forever — `[A] Acknowledge all` documented that
|
||
// decision to STATE.md but never suppressed it. This suite verifies the
|
||
// suppression seam: `audit_acknowledged` is VERDICT-PRESERVING (never
|
||
// touches the artifact's own `status:` verdict) and SELF-INVALIDATING (a
|
||
// stale acknowledgment resurfaces automatically the moment the artifact's
|
||
// current state stops matching the marker's recorded snapshot).
|
||
// ────────────────────────────────────────────────────────────────────────
|
||
{
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
const { splitLines } = require('../gsd-core/bin/lib/text-lines.cjs');
|
||
|
||
function readJson(result) {
|
||
assert.ok(result.success, `command must succeed. stdout: ${result.output}\nstderr: ${result.error}`);
|
||
return JSON.parse(result.output);
|
||
}
|
||
|
||
function ack(tmpDir, args) {
|
||
return runGsdTools(['audit-open', 'acknowledge', ...args, '--json'], tmpDir);
|
||
}
|
||
|
||
function audit(tmpDir) {
|
||
return readJson(runGsdTools(['audit-open', '--json'], tmpDir));
|
||
}
|
||
|
||
describe('audit-open acknowledge — suppression seam (#3458 follow-up)', () => {
|
||
let tmpDir;
|
||
|
||
beforeEach(() => { tmpDir = createTempProject('gsd-3458-ack-'); });
|
||
afterEach(() => { cleanup(tmpDir); });
|
||
|
||
function planningPath(...segs) {
|
||
return path.join(tmpDir, '.planning', ...segs);
|
||
}
|
||
|
||
// ── per-category suppression + verdict preservation ───────────────────
|
||
|
||
test('debug_sessions: acknowledged item drops out of counts/has_open_items; status: field unchanged', () => {
|
||
const debugDir = planningPath('debug');
|
||
fs.mkdirSync(debugDir, { recursive: true });
|
||
const filePath = path.join(debugDir, 'investigate.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: open\n---\n## Current Focus\ndigging\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.debug_sessions, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'debug_sessions', '--slug', 'investigate', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.debug_sessions, 0);
|
||
assert.equal(after.acknowledged.debug_sessions, 1);
|
||
assert.equal(after.has_open_items, false);
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /^status: open$/m, 'verdict-preserving: status: must be unchanged');
|
||
});
|
||
|
||
test('quick_tasks: acknowledged item drops out of counts; status: field unchanged', () => {
|
||
const taskDir = planningPath('quick', '20260810-fixthing');
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
const filePath = path.join(taskDir, '20260810-fixthing-SUMMARY.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: needs_review\n---\nbody\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.quick_tasks, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'quick_tasks', '--dir', '20260810-fixthing', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.quick_tasks, 0);
|
||
assert.equal(after.acknowledged.quick_tasks, 1);
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /^status: needs_review$/m, 'verdict-preserving: status: must be unchanged');
|
||
});
|
||
|
||
test('quick_tasks: task with NO SUMMARY.md at all can still be acknowledged (writer creates the marker file)', () => {
|
||
const taskDir = planningPath('quick', '20260811-nosummary');
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
|
||
assert.equal(audit(tmpDir).counts.quick_tasks, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'quick_tasks', '--dir', '20260811-nosummary', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.quick_tasks, 0);
|
||
assert.equal(after.acknowledged.quick_tasks, 1);
|
||
});
|
||
|
||
test('threads: acknowledged item drops out of counts; status: field unchanged', () => {
|
||
const threadsDir = planningPath('threads');
|
||
fs.mkdirSync(threadsDir, { recursive: true });
|
||
const filePath = path.join(threadsDir, 'design-debate.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: open\n---\n# Thread: design debate\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.threads, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'threads', '--slug', 'design-debate', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.threads, 0);
|
||
assert.equal(after.acknowledged.threads, 1);
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /^status: open$/m, 'verdict-preserving: status: must be unchanged');
|
||
});
|
||
|
||
test('seeds: acknowledged item drops out of counts; status: field unchanged', () => {
|
||
const seedsDir = planningPath('seeds');
|
||
fs.mkdirSync(seedsDir, { recursive: true });
|
||
const filePath = path.join(seedsDir, 'SEED-idea.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: dormant\n---\n# An idea\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.seeds, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'seeds', '--seed-id', 'SEED-idea', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.seeds, 0);
|
||
assert.equal(after.acknowledged.seeds, 1);
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /^status: dormant$/m, 'verdict-preserving: status: must be unchanged');
|
||
});
|
||
|
||
test('todos: acknowledged item drops out of counts (presence-only — no snapshot field)', () => {
|
||
const pendingDir = planningPath('todos', 'pending');
|
||
fs.mkdirSync(pendingDir, { recursive: true });
|
||
const filePath = path.join(pendingDir, 'fix-thing.md');
|
||
fs.writeFileSync(filePath, '---\npriority: low\narea: docs\n---\nFix the thing\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.todos, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'todos', '--filename', 'fix-thing.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.todos, 0);
|
||
assert.equal(after.acknowledged.todos, 1);
|
||
});
|
||
|
||
test('uat_gaps: acknowledged item drops out of counts; status: field unchanged (CLI writer round-trip)', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-UAT.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# UAT\n\n## Gaps\n\n- truth: "something broke"\n status: open\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.uat_gaps, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'uat_gaps', '--phase', '01', '--file', '01-UAT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.uat_gaps, 0);
|
||
assert.equal(after.acknowledged.uat_gaps, 1);
|
||
assert.equal(after.has_open_items, false);
|
||
assert.match(
|
||
fs.readFileSync(filePath, 'utf-8'), /^status: gaps_found$/m,
|
||
'CLI writer round-trip: the artifact\'s own status: must be UNCHANGED after acknowledge (verdict-preserving)',
|
||
);
|
||
});
|
||
|
||
test('verification_gaps: acknowledged item drops out of counts; status: field unchanged', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-VERIFICATION.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# Verification\n\nGaps found.\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.verification_gaps, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'verification_gaps', '--phase', '01', '--file', '01-VERIFICATION.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.verification_gaps, 0);
|
||
assert.equal(after.acknowledged.verification_gaps, 1);
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /^status: gaps_found$/m, 'verdict-preserving: status: must be unchanged');
|
||
});
|
||
|
||
test('context_questions: acknowledged item drops out of counts; question_count snapshot recorded', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-CONTEXT.md');
|
||
fs.writeFileSync(filePath, '# Context\n\n## Open Questions\n\n- Which backend?\n- What about auth?\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.context_questions, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'context_questions', '--phase', '01', '--file', '01-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.context_questions, 0);
|
||
assert.equal(after.acknowledged.context_questions, 1);
|
||
// WARNING 2 (#3458 follow-up review): the marker snapshots a content
|
||
// digest of the FULL question set, not a bare count — a count-only
|
||
// snapshot cannot see a same-count REPLACEMENT of every question (see
|
||
// the WARNING-2 disproof tests below).
|
||
assert.match(fs.readFileSync(filePath, 'utf-8'), /questions_digest: [0-9a-f]{64}/, 'marker records the questions_digest snapshot');
|
||
});
|
||
|
||
test('deferred_items: acknowledged entry drops out of counts; entry text otherwise unchanged', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
fs.writeFileSync(filePath, '## Deferred Items\n\n- an out of scope thing\n severity: low\n');
|
||
|
||
assert.equal(audit(tmpDir).counts.deferred_items, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'an out of scope thing severity: low', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.deferred_items, 0);
|
||
assert.equal(after.acknowledged.deferred_items, 1);
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
assert.match(content, /an out of scope thing/, 'entry text is preserved');
|
||
assert.match(content, /status: acknowledged/, 'entry now carries status: acknowledged');
|
||
assert.match(content, /severity: low/, 'sibling field is preserved');
|
||
});
|
||
|
||
// ── SELF-INVALIDATION: edit the artifact after acknowledging → resurfaces ──
|
||
|
||
test('SELF-INVALIDATION debug_sessions: status changes after acknowledge → item resurfaces', () => {
|
||
const debugDir = planningPath('debug');
|
||
fs.mkdirSync(debugDir, { recursive: true });
|
||
const filePath = path.join(debugDir, 'investigate.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: open\n---\n## Current Focus\ndigging\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'debug_sessions', '--slug', 'investigate', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.debug_sessions, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: open', 'status: in_progress');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.debug_sessions, 1, 'AFTER edit: resurfaces — stale acknowledgment no longer applies');
|
||
});
|
||
|
||
test('SELF-INVALIDATION quick_tasks: status changes after acknowledge → item resurfaces', () => {
|
||
const taskDir = planningPath('quick', '20260810-fixthing');
|
||
fs.mkdirSync(taskDir, { recursive: true });
|
||
const filePath = path.join(taskDir, '20260810-fixthing-SUMMARY.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: needs_review\n---\nbody\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'quick_tasks', '--dir', '20260810-fixthing', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.quick_tasks, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: needs_review', 'status: in_progress');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.quick_tasks, 1, 'AFTER edit: resurfaces');
|
||
});
|
||
|
||
test('SELF-INVALIDATION threads: status changes after acknowledge → item resurfaces', () => {
|
||
const threadsDir = planningPath('threads');
|
||
fs.mkdirSync(threadsDir, { recursive: true });
|
||
const filePath = path.join(threadsDir, 'design-debate.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: open\n---\n# Thread: design debate\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'threads', '--slug', 'design-debate', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.threads, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: open', 'status: in_progress');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.threads, 1, 'AFTER edit: resurfaces (still open, but a DIFFERENT open status than the snapshot)');
|
||
});
|
||
|
||
test('SELF-INVALIDATION seeds: status changes after acknowledge → item resurfaces', () => {
|
||
const seedsDir = planningPath('seeds');
|
||
fs.mkdirSync(seedsDir, { recursive: true });
|
||
const filePath = path.join(seedsDir, 'SEED-idea.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: dormant\n---\n# An idea\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'seeds', '--seed-id', 'SEED-idea', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.seeds, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: dormant', 'status: active');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.seeds, 1, 'AFTER edit: resurfaces');
|
||
});
|
||
|
||
test('SELF-INVALIDATION uat_gaps: status changes after acknowledge → item resurfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-UAT.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# UAT\n\n## Gaps\n\n- truth: "something broke"\n status: open\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'uat_gaps', '--phase', '01', '--file', '01-UAT.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.uat_gaps, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: gaps_found', 'status: human_needed');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.uat_gaps, 1, 'AFTER edit: resurfaces');
|
||
});
|
||
|
||
test('SELF-INVALIDATION verification_gaps: status changes after acknowledge → item resurfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-VERIFICATION.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# Verification\n\nGaps found.\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'verification_gaps', '--phase', '01', '--file', '01-VERIFICATION.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.verification_gaps, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: gaps_found', 'status: human_needed');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.verification_gaps, 1, 'AFTER edit: resurfaces');
|
||
});
|
||
|
||
test('SELF-INVALIDATION context_questions: question_count changes after acknowledge → item resurfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-CONTEXT.md');
|
||
fs.writeFileSync(filePath, '# Context\n\n## Open Questions\n\n- Which backend?\n- What about auth?\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'context_questions', '--phase', '01', '--file', '01-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.context_questions, 0, 'BEFORE edit: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8') + '- What about the third thing?\n';
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.context_questions, 1, 'AFTER a new open question is added: resurfaces');
|
||
});
|
||
|
||
test('SELF-INVALIDATION deferred_items: reopening the entry (status changed away from acknowledged) → item resurfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
fs.writeFileSync(filePath, '## Deferred Items\n\n- an out of scope thing\n severity: low\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'an out of scope thing severity: low', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.deferred_items, 0, 'BEFORE reopen: suppressed');
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8').replace('status: acknowledged', 'status: reopened');
|
||
fs.writeFileSync(filePath, content);
|
||
|
||
assert.equal(audit(tmpDir).counts.deferred_items, 1, 'AFTER reopen: resurfaces');
|
||
});
|
||
|
||
// ── malformed marker never suppresses ──────────────────────────────────
|
||
|
||
test('malformed audit_acknowledged (not a map) does NOT suppress — item still surfaces', () => {
|
||
const debugDir = planningPath('debug');
|
||
fs.mkdirSync(debugDir, { recursive: true });
|
||
const filePath = path.join(debugDir, 'investigate.md');
|
||
// Hand-authored, deliberately malformed: audit_acknowledged is a bare
|
||
// scalar, not a map — must be treated as ABSENT, never suppress.
|
||
fs.writeFileSync(filePath, '---\nstatus: open\naudit_acknowledged: not-a-map\n---\nstill open\n');
|
||
|
||
const parsed = audit(tmpDir);
|
||
assert.equal(parsed.counts.debug_sessions, 1, 'a malformed marker must never suppress');
|
||
assert.equal(parsed.acknowledged.debug_sessions, 0);
|
||
});
|
||
|
||
test('malformed audit_acknowledged (missing milestone/at) does NOT suppress — item still surfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-UAT.md');
|
||
fs.writeFileSync(
|
||
filePath,
|
||
'---\nstatus: gaps_found\naudit_acknowledged:\n status: gaps_found\n---\n# UAT\n\n## Gaps\n\n- truth: "x"\n status: open\n',
|
||
);
|
||
|
||
const parsed = audit(tmpDir);
|
||
assert.equal(parsed.counts.uat_gaps, 1, 'a marker missing milestone/at must never suppress');
|
||
});
|
||
|
||
// ── deferred_items status matrix ───────────────────────────────────────
|
||
|
||
test('deferred_items status matrix: acknowledged suppresses, resolved still suppresses, no status still surfaces', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
fs.writeFileSync(
|
||
filePath,
|
||
[
|
||
'## Deferred Items',
|
||
'',
|
||
'- an acknowledged item',
|
||
' status: acknowledged',
|
||
'- a resolved item',
|
||
' status: resolved',
|
||
'- a plain open item with no status field',
|
||
'',
|
||
].join('\n'),
|
||
);
|
||
|
||
const parsed = audit(tmpDir);
|
||
assert.equal(parsed.counts.deferred_items, 1, 'only the no-status entry is open');
|
||
assert.equal(parsed.acknowledged.deferred_items, 1, 'the acknowledged entry is tallied, not silenced');
|
||
assert.deepEqual(
|
||
parsed.items.deferred_items.map((i) => i.text),
|
||
['a plain open item with no status field'],
|
||
);
|
||
});
|
||
|
||
// ── BLOCKER 1 (#3458 follow-up review): deferred_items writer must be
|
||
// section-anchored, never write into the wrong span, and refuse rather
|
||
// than guess on every shape it cannot safely handle ────────────────────
|
||
|
||
test('BLOCKER 1: an identical bullet OUTSIDE `## Deferred Items` is never targeted — mixed-section fixture', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
// The SAME bullet text appears once under an unrelated `# Notes`
|
||
// section and once under `## Deferred Items`. Before the fix, the
|
||
// unanchored regex matched the FIRST occurrence anywhere in the file —
|
||
// i.e. the one under `# Notes` — not the one `matches`/`ambiguous`
|
||
// were computed over.
|
||
fs.writeFileSync(
|
||
filePath,
|
||
[
|
||
'# Notes',
|
||
'',
|
||
'- Fix the parser',
|
||
'',
|
||
'## Deferred Items',
|
||
'',
|
||
'- Fix the parser',
|
||
'',
|
||
].join('\n'),
|
||
);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'Fix the parser', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
const notesSection = content.slice(content.indexOf('# Notes'), content.indexOf('## Deferred Items'));
|
||
const deferredSection = content.slice(content.indexOf('## Deferred Items'));
|
||
assert.doesNotMatch(notesSection, /status: acknowledged/, 'the UNRELATED # Notes bullet must never be touched');
|
||
assert.match(deferredSection, /status: acknowledged/, 'the actual Deferred Items entry must carry the marker');
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.deferred_items, 0, 're-audit: the correct entry is suppressed');
|
||
assert.equal(after.acknowledged.deferred_items, 1);
|
||
});
|
||
|
||
test('BLOCKER 1: --text matching 2+ deferred entries is refused as ambiguous, nothing written', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
const before = ['## Deferred Items', '', '- duplicated text', '- duplicated text', ''].join('\n');
|
||
fs.writeFileSync(filePath, before);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'duplicated text', '--milestone', 'v1.0']);
|
||
assert.equal(result.success, false, 'ambiguous --text must be refused');
|
||
assert.match(result.error, /matches more than one/i);
|
||
assert.equal(fs.readFileSync(filePath, 'utf-8'), before, 'file must be byte-identical — nothing written on refusal');
|
||
});
|
||
|
||
test('BLOCKER 1: --text matching no deferred entry is refused as not_found', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
fs.writeFileSync(filePath, '## Deferred Items\n\n- a real entry\n');
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'no such entry', '--milestone', 'v1.0']);
|
||
assert.equal(result.success, false, 'unmatched --text must be refused');
|
||
assert.match(result.error, /no deferred item matched/i);
|
||
});
|
||
|
||
test('BLOCKER 1: heading-delimited (#3457) deferred-items shape is refused as unsupported_heading_shape, not guessed at', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
const before = ['## Deferred Items', '', '### Something out of scope', '', 'Some detail line.', ''].join('\n');
|
||
fs.writeFileSync(filePath, before);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'Something out of scope', '--milestone', 'v1.0']);
|
||
assert.equal(result.success, false, 'heading-delimited shape must be refused');
|
||
assert.match(result.error, /heading-delimited/i);
|
||
assert.equal(fs.readFileSync(filePath, 'utf-8'), before, 'file must be byte-identical — nothing written on refusal');
|
||
});
|
||
|
||
// ── F1 (#3458 follow-up review, HIGH): the writer must splice by the
|
||
// SELECTED entry's own carried span, never re-find it by searching —
|
||
// otherwise a byte-identical substring living inside an EARLIER entry
|
||
// (a continuation/quoted line) can steal the write ─────────────────────
|
||
|
||
test('F1: a target entry text appearing as a continuation line INSIDE an earlier entry is never targeted — the earlier (CRITICAL) entry is untouched', () => {
|
||
const phaseDir = planningPath('phases', '03-x');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
const before = [
|
||
'## Deferred Items',
|
||
'',
|
||
'- CRITICAL unfixed auth bypass',
|
||
' see also: - minor typo',
|
||
'- minor typo',
|
||
'',
|
||
].join('\n');
|
||
fs.writeFileSync(filePath, before);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '03', '--file', 'deferred-items.md', '--text', 'minor typo', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
// Derive the CRITICAL entry's block by LINES, not by `content.indexOf('- minor typo')`
|
||
// on the raw string — that substring also occurs INSIDE the CRITICAL entry's own
|
||
// continuation line (" see also: - minor typo"), so an indexOf-based slice truncates
|
||
// before the continuation line is fully captured. Walk lines from the CRITICAL bullet
|
||
// up to (not including) the next TOP-LEVEL bullet (a line starting with "- ", no
|
||
// leading indentation) to get the entry's own span, continuation lines included.
|
||
const lines = splitLines(content);
|
||
const criticalIdx = lines.findIndex((l) => l.startsWith('- CRITICAL'));
|
||
let criticalEndIdx = lines.length;
|
||
for (let i = criticalIdx + 1; i < lines.length; i++) {
|
||
if (lines[i].startsWith('- ')) { criticalEndIdx = i; break; }
|
||
}
|
||
const criticalBlock = lines.slice(criticalIdx, criticalEndIdx).join('\n');
|
||
assert.doesNotMatch(criticalBlock, /status: acknowledged/, 'the CRITICAL entry (and its continuation line) must NEVER be touched');
|
||
assert.match(criticalBlock, /see also: - minor typo/, 'the CRITICAL entry continuation line is preserved verbatim');
|
||
// Measured: the write seam's `_normalizeMd` (src/shell-command-projection.cts:837)
|
||
// inserts a blank line before a list item whose predecessor is a non-blank, non-list
|
||
// line — so a blank line appears between the CRITICAL continuation line and the
|
||
// "- minor typo" bullet after this write. That is repo-wide `.md`-write normalization
|
||
// (50 callers through the single write seam), not something specific to this feature.
|
||
assert.match(content, /- minor typo\n {2}status: acknowledged/, 'the standalone "minor typo" entry (its OWN span) now carries the marker');
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.deferred_items, 1, 're-audit: the CRITICAL entry is still open');
|
||
assert.equal(after.acknowledged.deferred_items, 1, 're-audit: only the typo entry is acknowledged');
|
||
assert.deepEqual(
|
||
after.items.deferred_items.filter((i) => !i.scan_error).map((i) => i.text),
|
||
['CRITICAL unfixed auth bypass see also: - minor typo'],
|
||
'the still-open item must be the CRITICAL one, not suppressed',
|
||
);
|
||
});
|
||
|
||
test('F1 (weaker/prose variant): the target text also appears as a decoy substring INLINE inside an earlier entry\'s prose — the decoy prose must never be corrupted, and the one real matching entry is acknowledged (pre-fix: the decoy prose line was split mid-sentence, the real entry was never touched, and the CLI still exited 0)', () => {
|
||
const phaseDir = planningPath('phases', '03-x');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
const before = [
|
||
'## Deferred Items',
|
||
'',
|
||
'- Note: reference - minor typo elsewhere, ignore',
|
||
'- minor typo',
|
||
'',
|
||
].join('\n');
|
||
fs.writeFileSync(filePath, before);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '03', '--file', 'deferred-items.md', '--text', 'minor typo', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed — the real "minor typo" entry unambiguously matches. stderr: ${result.error}`);
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
assert.match(
|
||
content,
|
||
/- Note: reference - minor typo elsewhere, ignore\n/,
|
||
'the decoy prose line must be preserved VERBATIM, never split mid-sentence by an inserted status: field',
|
||
);
|
||
assert.match(content, /- minor typo\n {2}status: acknowledged/, 'the real, standalone "minor typo" entry (its OWN carried span) is the one acknowledged');
|
||
|
||
const after = audit(tmpDir);
|
||
// The decoy `- Note: reference - minor typo elsewhere, ignore` line is ITSELF a
|
||
// separate, un-acknowledged deferred entry — it was never targeted or written to,
|
||
// so it remains open. Only the real "minor typo" entry was suppressed.
|
||
assert.equal(after.counts.deferred_items, 1, 're-audit: the decoy Note entry remains open — it was never acknowledged');
|
||
assert.equal(after.acknowledged.deferred_items, 1, 're-audit: only the real "minor typo" entry is acknowledged');
|
||
assert.deepEqual(
|
||
after.items.deferred_items.filter((i) => !i.scan_error).map((i) => i.text),
|
||
['Note: reference - minor typo elsewhere, ignore'],
|
||
'the one remaining open item is the decoy Note entry — proving the REAL entry (not the decoy) was the one suppressed',
|
||
);
|
||
});
|
||
|
||
test('F1: --text matching only a SUBSTRING of a prose entry (no entry\'s OWN text equals it) is refused as not_found, not silently corrupted', () => {
|
||
const phaseDir = planningPath('phases', '03-x');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
const before = [
|
||
'## Deferred Items',
|
||
'',
|
||
'- Some unrelated note mentioning minor typo inline as commentary',
|
||
'',
|
||
].join('\n');
|
||
fs.writeFileSync(filePath, before);
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '03', '--file', 'deferred-items.md', '--text', 'minor typo', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.equal(result.success, false, 'a --text that only matches a SUBSTRING of an entry (not the whole entry) must be refused, never silently split/corrupted');
|
||
assert.match(result.error, /no deferred item matched/i);
|
||
assert.equal(fs.readFileSync(filePath, 'utf-8'), before, 'file must be byte-identical — nothing written on refusal');
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.deferred_items, 1, 'the prose entry remains open and intact — not silently acknowledged/corrupted');
|
||
});
|
||
|
||
// ── WARNING 1 (#3458 follow-up review): every `.md` write normalizes to
|
||
// LF — a CRLF deferred-items.md is normalized, not byte-preserved,
|
||
// matching every other `.md` writer in this codebase ─────────────────
|
||
|
||
test('WARNING 1: acknowledging an entry in a CRLF deferred-items.md normalizes the whole file to LF (no dead CRLF preservation)', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, 'deferred-items.md');
|
||
fs.writeFileSync(filePath, '## Deferred Items\r\n\r\n- a crlf entry\r\n severity: low\r\n');
|
||
|
||
const result = ack(tmpDir, ['--category', 'deferred_items', '--phase', '01', '--file', 'deferred-items.md', '--text', 'a crlf entry severity: low', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
assert.ok(!content.includes('\r'), 'the whole file normalizes to LF on any .md write — no stray \\r bytes');
|
||
assert.match(content, /status: acknowledged/, 'the entry still carries the marker after normalization');
|
||
assert.match(content, /a crlf entry/, 'entry text is preserved');
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.deferred_items, 0);
|
||
assert.equal(after.acknowledged.deferred_items, 1);
|
||
});
|
||
|
||
// ── BLOCKER 2 (#3458 follow-up review): todos beyond the display cap
|
||
// must not be permanently hidden by acknowledging the displayed 5 ─────
|
||
|
||
test('BLOCKER 2: acknowledging the 5 displayed todos surfaces the remaining 2, not zero — filter-before-cap', () => {
|
||
const pendingDir = planningPath('todos', 'pending');
|
||
fs.mkdirSync(pendingDir, { recursive: true });
|
||
for (let i = 1; i <= 7; i++) {
|
||
fs.writeFileSync(path.join(pendingDir, `t${i}.md`), `---\npriority: low\narea: misc\n---\ntodo ${i}\n`);
|
||
}
|
||
|
||
const before = audit(tmpDir);
|
||
assert.equal(before.counts.todos, 5, 'display cap: 5 of 7 shown in one scan');
|
||
assert.equal(before.has_open_items, true);
|
||
|
||
const shown = before.items.todos.filter((i) => !i.scan_error && !i._remainder_count).map((i) => i.filename);
|
||
assert.equal(shown.length, 5);
|
||
|
||
for (const filename of shown) {
|
||
const result = ack(tmpDir, ['--category', 'todos', '--filename', filename, '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed for ${filename}. stderr: ${result.error}`);
|
||
}
|
||
|
||
const after = audit(tmpDir);
|
||
// Pre-fix this was 0 (the 2 unshown files were permanently invisible —
|
||
// `mdFiles.length` drove both the cap and the remainder count, so once
|
||
// the raw 7 dropped to the still-raw-7-minus-nothing count computation
|
||
// never noticed 2 files had never been shown at all).
|
||
assert.equal(after.counts.todos, 2, 'the 2 never-displayed todos must still surface');
|
||
assert.equal(after.has_open_items, true, 'must not report clean while 2 todos remain unacknowledged');
|
||
assert.equal(after.acknowledged.todos, 5);
|
||
});
|
||
|
||
// ── WARNING 2 (#3458 follow-up review): the snapshot must identify
|
||
// CONTENT, not just its size — a same-count/same-status change must
|
||
// still resurface ───────────────────────────────────────────────────
|
||
|
||
test('WARNING-2 disproof: replacing every acknowledged open_question with a NEW one (same count) resurfaces the item', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-CONTEXT.md');
|
||
fs.writeFileSync(filePath, '---\nopen_questions:\n - "Which backend?"\n - "What about auth?"\n---\n# Context\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'context_questions', '--phase', '01', '--file', '01-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
assert.equal(audit(tmpDir).counts.context_questions, 0, 'BEFORE replacement: suppressed');
|
||
|
||
// Same COUNT (2), completely different TEXT.
|
||
fs.writeFileSync(filePath, '---\nopen_questions:\n - "BRAND NEW BLOCKER: is data loss possible?"\n - "ANOTHER NEW BLOCKER: auth bypass?"\n---\n# Context\n');
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.context_questions, 1, 'AFTER replacement: must RESURFACE — a count-only snapshot cannot see this');
|
||
assert.deepEqual(
|
||
after.items.context_questions.filter((i) => !i.scan_error).map((i) => i.questions),
|
||
[['BRAND NEW BLOCKER: is data loss possible?', 'ANOTHER NEW BLOCKER: auth bypass?']],
|
||
);
|
||
});
|
||
|
||
// ── F2 (#3458 follow-up review): the digest must see the WHOLE question
|
||
// set, not the first-3-display-truncated slice `deriveOpenQuestions` used
|
||
// to hash — a 4th+ question was invisible to the snapshot ─────────────
|
||
|
||
test('F2: a 4th open question added after acknowledging a 3-question body-section set RESURFACES the item (digest was blind past position 3)', () => {
|
||
const phaseDir = planningPath('phases', '02-beta');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '02-CONTEXT.md');
|
||
fs.writeFileSync(
|
||
filePath,
|
||
'# Context\n\n## Open Questions\n\n- Q1?\n- Q2?\n- Q3?\n- Q4?\n',
|
||
);
|
||
|
||
const before = audit(tmpDir);
|
||
const beforeItem = before.items.context_questions.find((i) => !i.scan_error && i.file === '02-CONTEXT.md');
|
||
assert.equal(beforeItem.question_count, 4, 'question_count must reflect all 4 questions, not the display cap');
|
||
|
||
const result = ack(tmpDir, ['--category', 'context_questions', '--phase', '02', '--file', '02-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
assert.equal(audit(tmpDir).items.context_questions.filter((i) => !i.scan_error && i.file === '02-CONTEXT.md').length, 0, 'BEFORE mutation: suppressed');
|
||
|
||
// Q1–Q3 UNCHANGED (still the first 3 lines — a pre-fix digest hashing
|
||
// only `slice(0, 3)` would see NO difference at all); Q4 replaced with
|
||
// two brand-new unanswered blockers.
|
||
fs.writeFileSync(
|
||
filePath,
|
||
'# Context\n\n## Open Questions\n\n- Q1?\n- Q2?\n- Q3?\n- Brand new unanswered blocker A?\n- Brand new unanswered blocker B?\n',
|
||
);
|
||
|
||
const after = audit(tmpDir);
|
||
const afterItem = after.items.context_questions.find((i) => !i.scan_error && i.file === '02-CONTEXT.md');
|
||
assert.ok(afterItem, 'AFTER replacing Q4 with new blockers: the item must RESURFACE — a slice(0,3) digest cannot see past position 3');
|
||
assert.equal(afterItem.question_count, 5);
|
||
});
|
||
|
||
// ── SWEEP finding (#3458 follow-up review): the digest's element-join
|
||
// must be unambiguous — two DIFFERENT question sets must never encode to
|
||
// the same joined string and collide on the same digest ───────────────
|
||
|
||
test('SWEEP: two different open-question sets that collide under a naive separator-join must record DIFFERENT digests', () => {
|
||
const phase1Dir = planningPath('phases', '03-one');
|
||
const phase2Dir = planningPath('phases', '04-two');
|
||
fs.mkdirSync(phase1Dir, { recursive: true });
|
||
fs.mkdirSync(phase2Dir, { recursive: true });
|
||
const file1 = path.join(phase1Dir, '03-CONTEXT.md');
|
||
const file2 = path.join(phase2Dir, '04-CONTEXT.md');
|
||
|
||
// Both sets embed a literal NUL codepoint (via the YAML `\x00`
|
||
// double-quoted hex escape) at the exact position needed to make the
|
||
// TWO DIFFERENT arrays below encode to the byte-identical string under
|
||
// ANY single-character-separator join (a plain space join, OR the
|
||
// separator this seam actually shipped with) — the general proof that
|
||
// NO fixed separator closes this class, only a length-prefixed,
|
||
// self-delimiting encoding does.
|
||
// Set 1: ["foo\0bar", "baz"] → "foo\0bar" + SEP + "baz"
|
||
// Set 2: ["foo", "bar\0baz"] → "foo" + SEP + "bar\0baz"
|
||
// For SEP = "\0" both concatenate to the identical "foo\0bar\0baz".
|
||
fs.writeFileSync(file1, '---\nopen_questions:\n - "foo\\x00bar"\n - "baz"\n---\n# Context\n');
|
||
fs.writeFileSync(file2, '---\nopen_questions:\n - "foo"\n - "bar\\x00baz"\n---\n# Context\n');
|
||
|
||
const r1 = ack(tmpDir, ['--category', 'context_questions', '--phase', '03', '--file', '03-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
const r2 = ack(tmpDir, ['--category', 'context_questions', '--phase', '04', '--file', '04-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(r1.success, `stderr: ${r1.error}`);
|
||
assert.ok(r2.success, `stderr: ${r2.error}`);
|
||
|
||
const digest1 = fs.readFileSync(file1, 'utf-8').match(/questions_digest:\s*([0-9a-f]{64})/)[1];
|
||
const digest2 = fs.readFileSync(file2, 'utf-8').match(/questions_digest:\s*([0-9a-f]{64})/)[1];
|
||
assert.notEqual(digest1, digest2, 'two DIFFERENT question sets must never record the same digest, even when they collide under a naive separator-join');
|
||
});
|
||
|
||
test('WARNING-2 disproof: adding more pending scenarios to an acknowledged UAT gap (status unchanged) resurfaces the item', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-UAT.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# UAT\n\n## Scenarios\n\n1. result: pending\n');
|
||
|
||
assert.ok(ack(tmpDir, ['--category', 'uat_gaps', '--phase', '01', '--file', '01-UAT.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
let after = audit(tmpDir);
|
||
assert.equal(after.counts.uat_gaps, 0, 'BEFORE: 1 pending scenario, suppressed');
|
||
|
||
// status: stays `gaps_found` — only the scenario count moves, 1 → 6.
|
||
fs.writeFileSync(
|
||
filePath,
|
||
'---\nstatus: gaps_found\n---\n# UAT\n\n## Scenarios\n\n1. result: pending\n2. result: pending\n3. result: pending\n4. result: pending\n5. result: pending\n6. result: pending\n',
|
||
);
|
||
|
||
after = audit(tmpDir);
|
||
assert.equal(after.counts.uat_gaps, 1, 'AFTER: same status, MORE pending scenarios — must RESURFACE');
|
||
const item = after.items.uat_gaps.find((i) => !i.scan_error);
|
||
assert.equal(item.open_scenario_count, 6);
|
||
});
|
||
|
||
// ── WARNING 3 (#3458 follow-up review): the human report must carry the
|
||
// same "clean vs silenced" signal --json already did ──────────────────
|
||
|
||
test('WARNING 3: human-readable report shows the acknowledged tally, per-category and in the all-clear footer', () => {
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-UAT.md');
|
||
fs.writeFileSync(filePath, '---\nstatus: gaps_found\n---\n# UAT\n\n## Gaps\n\n- truth: "x"\n status: open\n');
|
||
assert.ok(ack(tmpDir, ['--category', 'uat_gaps', '--phase', '01', '--file', '01-UAT.md', '--milestone', 'v1.0', '--at', '2026-08-15']).success);
|
||
|
||
// All-clear case: the only item left is a previously-acknowledged one.
|
||
const clearReport = runGsdTools(['audit-open'], tmpDir);
|
||
assert.ok(clearReport.success, `stderr: ${clearReport.error}`);
|
||
assert.match(clearReport.output, /1 previously acknowledged item/i, 'all-clear footer must disclose the suppressed item');
|
||
|
||
// Now add a genuinely NEW open item so has_open_items is true, and
|
||
// confirm the per-category line also discloses the acknowledged one
|
||
// still sitting alongside it.
|
||
const debugDir = planningPath('debug');
|
||
fs.mkdirSync(debugDir, { recursive: true });
|
||
fs.writeFileSync(path.join(debugDir, 'investigate.md'), '---\nstatus: open\n---\n## Current Focus\ndigging\n');
|
||
|
||
const openReport = runGsdTools(['audit-open'], tmpDir);
|
||
assert.ok(openReport.success, `stderr: ${openReport.error}`);
|
||
assert.match(openReport.output, /previously acknowledged item/i, 'footer must still disclose the acknowledged item while other items are open');
|
||
});
|
||
|
||
// ── writer refuses a path outside the project ──────────────────────────
|
||
|
||
test('writer refuses to acknowledge a path that escapes the project (path traversal)', () => {
|
||
const result = ack(tmpDir, ['--category', 'debug_sessions', '--slug', '../../../../etc/passwd', '--milestone', 'v1.0']);
|
||
assert.equal(result.success, false, 'a traversal-shaped --slug must be refused, not written');
|
||
});
|
||
|
||
test('writer refuses to acknowledge a category with a required flag missing', () => {
|
||
const result = ack(tmpDir, ['--category', 'uat_gaps', '--milestone', 'v1.0']); // no --phase/--file
|
||
assert.equal(result.success, false, 'missing --phase/--file must be refused');
|
||
});
|
||
|
||
// ── mixed-frame fix (security review, #3078-CR follow-up): the writer's
|
||
// snapshot value and the scanners' recomputed value must share ONE
|
||
// frame (both normalized) even though the writer's SPLICE stays raw. A
|
||
// lone-CR artifact discriminates this: normalizing shifts every byte
|
||
// offset, so if the splice used normalized text it would corrupt the
|
||
// file, and if the snapshot used raw text it would never match the
|
||
// scanner's normalized recomputation — acknowledge would silently never
|
||
// suppress. An LF control proves the round trip isn't accidentally
|
||
// broken for the common case while fixing the CR case. ──────────────
|
||
|
||
test('mixed-frame fix: context_questions acknowledge on a lone-CR artifact actually suppresses the item', () => {
|
||
// A lone-CR CONTEXT.md is the clean discriminator: `deriveOpenQuestions`
|
||
// splits the `## Open Questions` body on `\n` — raw lone-CR content has
|
||
// NO `\n` at all, so pre-fix the writer's raw-content digest is
|
||
// computed over a ZERO-question set (sha256 of ''), which can never
|
||
// equal what the scanner (reading normalized content) recomputes — the
|
||
// acknowledge is a silent no-op. This file carries no frontmatter
|
||
// fence, so it is not entangled with the separate, pre-existing
|
||
// splice-vs-lone-CR-fence limitation a UAT/VERIFICATION file with an
|
||
// EXISTING lone-CR frontmatter block would hit.
|
||
const phaseDir = planningPath('phases', '01-alpha');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '01-CONTEXT.md');
|
||
fs.writeFileSync(filePath, '# Context\r\r## Open Questions\r\r- Which backend?\r- What about auth?\r');
|
||
|
||
const before = audit(tmpDir);
|
||
assert.equal(before.counts.context_questions, 1, 'lone-CR CONTEXT file must be parsed as having open questions before acknowledge');
|
||
|
||
const result = ack(tmpDir, ['--category', 'context_questions', '--phase', '01', '--file', '01-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
assert.notEqual(
|
||
JSON.parse(result.output).questions_digest,
|
||
'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
|
||
'the recorded digest must reflect the REAL 2-question set, not sha256 of an empty set (the pre-fix raw-content bug)',
|
||
);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.context_questions, 0, 'lone-CR context_questions item must be SUPPRESSED, not resurface as a silent no-op');
|
||
assert.equal(after.acknowledged.context_questions, 1);
|
||
assert.deepEqual(
|
||
(after.items.context_questions || []).filter((i) => !i.scan_error).map((i) => i.file),
|
||
[],
|
||
'the specific acknowledged file must be gone from the open items, by identity — not just a smaller count',
|
||
);
|
||
});
|
||
|
||
test('mixed-frame fix control: context_questions acknowledge on an LF artifact still suppresses the item (round trip not broken by the CR fix)', () => {
|
||
const phaseDir = planningPath('phases', '02-beta');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '02-CONTEXT.md');
|
||
fs.writeFileSync(filePath, '# Context\n\n## Open Questions\n\n- Which backend?\n- What about auth?\n');
|
||
|
||
const before = audit(tmpDir);
|
||
assert.equal(before.counts.context_questions, 1);
|
||
|
||
const result = ack(tmpDir, ['--category', 'context_questions', '--phase', '02', '--file', '02-CONTEXT.md', '--milestone', 'v1.0', '--at', '2026-08-15']);
|
||
assert.ok(result.success, `acknowledge must succeed. stderr: ${result.error}`);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.context_questions, 0, 'LF context_questions item must still be suppressed after the fix');
|
||
assert.equal(after.acknowledged.context_questions, 1);
|
||
assert.deepEqual(
|
||
(after.items.context_questions || []).filter((i) => !i.scan_error).map((i) => i.file),
|
||
[],
|
||
'the specific acknowledged file must be gone from the open items, by identity',
|
||
);
|
||
assert.ok(!fs.readFileSync(filePath, 'utf-8').includes('\r'), 'LF file stays LF — the fix must not introduce CR bytes on the common path');
|
||
});
|
||
|
||
test('mixed-frame fix compatibility: a HAND-AUTHORED pre-existing LF acknowledgment marker (never touched by this change\'s writer) is still recognised', () => {
|
||
const phaseDir = planningPath('phases', '03-gamma');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
const filePath = path.join(phaseDir, '03-UAT.md');
|
||
// The marker's `gap_snapshot` value is computed BY HAND here, per
|
||
// `deriveUatGapSnapshotValue`'s documented shape
|
||
// (`${status}::scenarios=${openScenarioCount}`) — NOT produced by
|
||
// calling the writer — so this exercises the scanner's READ side in
|
||
// isolation against a marker that predates this change entirely. This
|
||
// content has zero `result: pending`/`[pending]` matches, so the open
|
||
// scenario count is 0.
|
||
fs.writeFileSync(
|
||
filePath,
|
||
'---\nstatus: gaps_found\naudit_acknowledged:\n milestone: v1.0\n at: "2026-08-15"\n gap_snapshot: "gaps_found::scenarios=0"\n---\n# UAT\n\n## Gaps\n\n- truth: "something broke"\n status: open\n',
|
||
);
|
||
|
||
const after = audit(tmpDir);
|
||
assert.equal(after.counts.uat_gaps, 0, 'a pre-existing LF acknowledgment marker must still suppress the item after the mixed-frame fix');
|
||
assert.equal(after.acknowledged.uat_gaps, 1);
|
||
});
|
||
});
|
||
}
|