@planu/cli 5.3.52 → 5.3.56

package/CHANGELOG.md

@@ -1,3 +1,100 @@
+## [5.3.56] - 2026-08-25
+
+### Bug Fixes
+- fix(tests): anchor the revert-proof fixture to a pushed pre-guard tag
+- fix(release): name the failing command and its real termination cause
+- fix(release): name the blocking effect and fail closed on a broken tag lookup
+- fix(release): re-anchor a superseded recovery ledger instead of dead-ending
+- fix(worktree): reclaim content-equivalent worktrees and read the canonical branch
+
+### Chores
+- chore(planu): close SPEC-1626
+- chore(planu): close SPEC-1630
+- chore(planu): close SPEC-1625
+- chore(planu): close SPEC-1624, file SPEC-1629 transition-log rotation
+- chore(planu): file SPEC-1625 and SPEC-1626 release-pipeline dogfood bugs
+
+
+## [5.3.55] - 2026-08-25
+
+### Bug Fixes
+- fix(update-status): classify git-status degradation in spec artifact guard
+- fix(worktree): drop only proper ancestors when eliminating base candidates
+- fix(challenge): stop telling users to record accepted-risk evidence
+- fix(worktree): validate worktree base against the canonical branch
+- fix(gates): surface schema blockers in dod-gate rejections
+- fix(contradiction-checker): close Path B on the criterion, not the scope
+- fix(cli): add package-handoff command and honest EISDIR blocker
+- fix(contradiction-checker): require predicate-position action assertion
+- fix(spec-format): anchor single-line GIVEN/WHEN/THEN criterion regex
+- fix(reconciliation): refresh stored title on the forward reconcile route
+- fix(challenge-spec): stop reading a negated word as risk acceptance
+- fix(cli): forward SDD evidence flags from spec status to the canonical mapping
+- fix(update-status): refresh stored title from rewritten frontmatter
+- fix(challenge): close resolution bullets on blank line
+- fix(challenge): match resolution evidence against finding text
+- fix(challenge): scope networkApi to a proximity-guarded bare API token
+- fix(storage): stream transition-log reads to survive oversized lines
+- fix(challenge): stop affirming capabilities from finding-field narration
+- fix(update-status): discard a spec whose artifact is absent
+- fix(validate): report unresolvable test links as unverifiable, not missing
+- fix(update-status): drop the narrative JSDoc from the spec-artifact gate
+- fix(update-status): refuse implementing transition on uncommitted spec.md
+- fix(update-status): name the challenge-resolution ingress in gate blockers
+
+### Refactoring
+- refactor(contradiction-checker): drop rationale comments in favor of names
+
+### Chores
+- chore(planu): file SPEC-1624, clear integrated worktrees
+- chore(planu): refresh session context
+- chore(planu): refresh session context and release ledger
+
+
+## [5.3.54] - 2026-08-25
+
+### Bug Fixes
+- fix(worktree): drop only proper ancestors when eliminating base candidates
+- fix(challenge): stop telling users to record accepted-risk evidence
+- fix(worktree): validate worktree base against the canonical branch
+- fix(gates): surface schema blockers in dod-gate rejections
+- fix(contradiction-checker): close Path B on the criterion, not the scope
+- fix(cli): add package-handoff command and honest EISDIR blocker
+- fix(contradiction-checker): require predicate-position action assertion
+- fix(spec-format): anchor single-line GIVEN/WHEN/THEN criterion regex
+- fix(reconciliation): refresh stored title on the forward reconcile route
+- fix(challenge-spec): stop reading a negated word as risk acceptance
+- fix(cli): forward SDD evidence flags from spec status to the canonical mapping
+- fix(update-status): refresh stored title from rewritten frontmatter
+- fix(challenge): close resolution bullets on blank line
+- fix(challenge): match resolution evidence against finding text
+- fix(challenge): scope networkApi to a proximity-guarded bare API token
+- fix(storage): stream transition-log reads to survive oversized lines
+- fix(challenge): stop affirming capabilities from finding-field narration
+- fix(update-status): discard a spec whose artifact is absent
+- fix(validate): report unresolvable test links as unverifiable, not missing
+- fix(update-status): drop the narrative JSDoc from the spec-artifact gate
+- fix(update-status): refuse implementing transition on uncommitted spec.md
+- fix(update-status): name the challenge-resolution ingress in gate blockers
+
+### Refactoring
+- refactor(contradiction-checker): drop rationale comments in favor of names
+
+### Chores
+- chore(planu): file SPEC-1624, clear integrated worktrees
+- chore(planu): refresh session context
+- chore(planu): refresh session context and release ledger
+
+
+## [5.3.53] - 2026-08-25
+
+### Bug Fixes
+- fix(update-status): name the challenge-resolution ingress in gate blockers
+
+### Chores
+- chore(planu): refresh session context and release ledger
+
+
 ## [5.3.52] - 2026-08-25
 
 ### Bug Fixes

package/dist/cli/commands/package-handoff.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from '../../types/cli.js';
+export declare const packageHandoffCommand: CliCommand;
+//# sourceMappingURL=package-handoff.d.ts.map

package/dist/cli/commands/package-handoff.js

@@ -0,0 +1,43 @@
+// cli/commands/package-handoff.ts — planu package-handoff <specId> (SPEC-1621)
+import { parseArgs } from 'node:util';
+import { resolve } from 'node:path';
+import { handlePackageHandoff } from '../../tools/package-handoff.js';
+import { formatToolResult } from '../formatter.js';
+import { detectProjectId } from '../project-detector.js';
+import { red } from '../colors.js';
+export const packageHandoffCommand = {
+    name: 'package-handoff',
+    description: 'Generate the operational handoff package artifact for a spec',
+    usage: 'planu package-handoff <specId> [--project-path .] [--project-id ID]',
+    async run(args, flags) {
+        const { values, positionals } = parseArgs({
+            args,
+            options: {
+                'project-id': { type: 'string' },
+                'project-path': { type: 'string' },
+            },
+            strict: false,
+            allowPositionals: true,
+        });
+        const specId = positionals[0];
+        if (!specId) {
+            process.stderr.write(`${red('Error:')} Spec ID is required.\nUsage: ${packageHandoffCommand.usage}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const projectPath = values['project-path'];
+        const projectId = values['project-id'] ??
+            detectProjectId(projectPath ? resolve(projectPath) : undefined);
+        const result = await handlePackageHandoff({ projectId, specId });
+        if (result.isError) {
+            process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const output = formatToolResult(result, flags);
+        if (output) {
+            process.stdout.write(output + '\n');
+        }
+    },
+};
+//# sourceMappingURL=package-handoff.js.map

package/dist/cli/commands/spec.js

@@ -16,6 +16,7 @@ import { handleValidate } from '../../tools/validate.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { bold, cyan, green, red, dim } from '../colors.js';
+import { SINGLE_STATUS_PARSE_OPTIONS, buildSingleStatusInput } from './status.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -208,15 +209,12 @@ async function runShow(args, flags) {
 // ---------------------------------------------------------------------------
 // Subcommand: spec status
 // ---------------------------------------------------------------------------
-// eslint-disable-next-line complexity -- batch done requires an explicit pre-resolution fail-closed branch
 async function runStatus(args, flags) {
     const { positionals, values } = parseArgs({
         args,
         options: {
-            'project-id': { type: 'string' },
-            notes: { type: 'string', short: 'n' },
+            ...SINGLE_STATUS_PARSE_OPTIONS,
             batch: { type: 'boolean' },
-            set: { type: 'string', short: 's' },
             'implementation-review-digest': { type: 'string' },
         },
         strict: false,
@@ -257,10 +255,7 @@ async function runStatus(args, flags) {
         return;
     }
     const result = await handleUpdateStatus({
-        specId,
-        projectId,
-        status: status,
-        reviewNotes: values.notes ?? undefined,
+        ...buildSingleStatusInput(values, specId, projectId, status),
         implementationReviewDigest: values['implementation-review-digest'] ?? undefined,
     });
     if (result.isError) {

package/dist/cli/commands/status.d.ts

@@ -1,3 +1,54 @@
-import type { CliCommand } from '../../types/cli.js';
+import type { CliCommand, StatusCommandValues } from '../../types/cli.js';
+import type { UpdateStatusInput } from '../../types/spec/inputs.js';
 export declare const statusCommand: CliCommand;
+export declare const SINGLE_STATUS_PARSE_OPTIONS: {
+    readonly set: {
+        readonly type: 'string';
+        readonly short: 's';
+    };
+    readonly 'project-id': {
+        readonly type: 'string';
+    };
+    readonly 'project-path': {
+        readonly type: 'string';
+    };
+    readonly notes: {
+        readonly type: 'string';
+        readonly short: 'n';
+    };
+    readonly 'model-id': {
+        readonly type: 'string';
+    };
+    readonly 'model-tier-used': {
+        readonly type: 'string';
+    };
+    readonly 'context-hash': {
+        readonly type: 'string';
+    };
+    readonly 'handoff-path': {
+        readonly type: 'string';
+    };
+    readonly 'handoff-artifact-id': {
+        readonly type: 'string';
+    };
+    readonly 'reviewed-by': {
+        readonly type: 'string';
+    };
+    readonly 'arbitrated-by': {
+        readonly type: 'string';
+    };
+    readonly reason: {
+        readonly type: 'string';
+    };
+    readonly force: {
+        readonly type: 'boolean';
+    };
+    readonly 'force-status': {
+        readonly type: 'boolean';
+    };
+    readonly 'force-status-reason': {
+        readonly type: 'string';
+    };
+};
+export declare function buildSingleStatusInput(values: StatusCommandValues, specId: string, projectId: string, status: string): UpdateStatusInput;
 //# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/status.js

@@ -37,26 +37,47 @@ export const statusCommand = {
         await runSingleStatus(specId, values, status, flags);
     },
 };
+export const SINGLE_STATUS_PARSE_OPTIONS = {
+    set: { type: 'string', short: 's' },
+    'project-id': { type: 'string' },
+    'project-path': { type: 'string' },
+    notes: { type: 'string', short: 'n' },
+    'model-id': { type: 'string' },
+    'model-tier-used': { type: 'string' },
+    'context-hash': { type: 'string' },
+    'handoff-path': { type: 'string' },
+    'handoff-artifact-id': { type: 'string' },
+    'reviewed-by': { type: 'string' },
+    'arbitrated-by': { type: 'string' },
+    reason: { type: 'string' },
+    force: { type: 'boolean' },
+    'force-status': { type: 'boolean' },
+    'force-status-reason': { type: 'string' },
+};
+export function buildSingleStatusInput(values, specId, projectId, status) {
+    return {
+        specId,
+        projectId,
+        projectPath: values['project-path'] ? resolve(values['project-path']) : undefined,
+        status: status,
+        reviewNotes: values.notes,
+        modelId: values['model-id'],
+        modelTierUsed: values['model-tier-used'],
+        contextHash: values['context-hash'],
+        handoffPath: values['handoff-path'],
+        handoffArtifactId: values['handoff-artifact-id'],
+        reviewedBy: values['reviewed-by'],
+        arbitratedBy: values['arbitrated-by'],
+        reason: values.reason,
+        force: values.force === true ? true : undefined,
+        forceStatus: values['force-status'] === true ? true : undefined,
+        forceStatusReason: values['force-status-reason'],
+    };
+}
 function parseStatusArgs(args) {
     const parsed = parseArgs({
         args,
-        options: {
-            set: { type: 'string', short: 's' },
-            'project-id': { type: 'string' },
-            'project-path': { type: 'string' },
-            notes: { type: 'string', short: 'n' },
-            'model-id': { type: 'string' },
-            'model-tier-used': { type: 'string' },
-            'context-hash': { type: 'string' },
-            'handoff-path': { type: 'string' },
-            'handoff-artifact-id': { type: 'string' },
-            'reviewed-by': { type: 'string' },
-            'arbitrated-by': { type: 'string' },
-            reason: { type: 'string' },
-            force: { type: 'boolean' },
-            'force-status': { type: 'boolean' },
-            'force-status-reason': { type: 'string' },
-        },
+        options: SINGLE_STATUS_PARSE_OPTIONS,
         strict: false,
         allowPositionals: true,
     });
@@ -94,24 +115,7 @@ async function runBatchStatus(specIds, values, status, flags) {
     writeToolResult(result, flags, false);
 }
 async function runSingleStatus(specId, values, status, flags) {
-    const result = await handleUpdateStatus({
-        specId,
-        projectId: values['project-id'] ?? detectProjectId(),
-        projectPath: values['project-path'],
-        status: status,
-        reviewNotes: values.notes,
-        modelId: values['model-id'],
-        modelTierUsed: values['model-tier-used'],
-        contextHash: values['context-hash'],
-        handoffPath: values['handoff-path'],
-        handoffArtifactId: values['handoff-artifact-id'],
-        reviewedBy: values['reviewed-by'],
-        arbitratedBy: values['arbitrated-by'],
-        reason: values.reason,
-        force: values.force === true ? true : undefined,
-        forceStatus: values['force-status'] === true ? true : undefined,
-        forceStatusReason: values['force-status-reason'],
-    });
+    const result = await handleUpdateStatus(buildSingleStatusInput(values, specId, values['project-id'] ?? detectProjectId(), status));
     writeToolResult(result, flags, true);
 }
 function writeToolResult(result, flags, includeSuccessPrefix) {

package/dist/cli/router.js

@@ -4,7 +4,7 @@ import { PLANU_VERSION } from '../config/version.js';
 import { red, bold, cyan, dim } from './colors.js';
 // Lazy-load commands to avoid importing tool handlers when not needed
 async function loadCommands() {
-    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = await Promise.all([
+    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { packageHandoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = await Promise.all([
         import('./commands/init.js'),
         import('./commands/create.js'),
         import('./commands/list.js'),
@@ -15,6 +15,7 @@ async function loadCommands() {
         import('./commands/audit.js'),
         import('./commands/serve.js'),
         import('./commands/handoff.js'),
+        import('./commands/package-handoff.js'),
         import('./commands/watch.js'),
         import('./commands/install.js'),
         import('./commands/doctor.js'),
@@ -38,6 +39,7 @@ async function loadCommands() {
         auditCommand,
         serveCommand,
         handoffCommand,
+        packageHandoffCommand,
         watchCommand,
         installCommand,
         doctorCommand,
@@ -64,8 +66,9 @@ function printHelp(commands) {
         '',
         cyan('Commands:'),
     ];
+    const nameColumnWidth = Math.max(...[...commands.values()].map((cmd) => cmd.name.length));
     for (const cmd of commands.values()) {
-        lines.push(`  ${cmd.name.padEnd(14)} ${dim(cmd.description)}`);
+        lines.push(`  ${cmd.name.padEnd(nameColumnWidth)} ${dim(cmd.description)}`);
     }
     lines.push('');
     lines.push(cyan('Global options:'));

package/dist/engine/git/canonical-branch.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCanonicalBranch(cwd: string): string;
+//# sourceMappingURL=canonical-branch.d.ts.map

package/dist/engine/git/canonical-branch.js

@@ -0,0 +1,31 @@
+import { execSync } from 'node:child_process';
+function runCmd(cmd, cwd) {
+    try {
+        const output = execSync(cmd, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return { output, exitCode: 0 };
+    }
+    catch (err) {
+        const error = err;
+        return {
+            output: (error.stdout ?? '') + (error.stderr ?? ''),
+            exitCode: error.status ?? 1,
+        };
+    }
+}
+export function resolveCanonicalBranch(cwd) {
+    const originHead = runCmd('git symbolic-ref --short refs/remotes/origin/HEAD', cwd);
+    if (originHead.exitCode === 0) {
+        const branch = originHead.output.replace(/^origin\//, '');
+        const verified = runCmd(`git rev-parse --verify ${branch}`, cwd);
+        if (verified.exitCode === 0) {
+            return branch;
+        }
+    }
+    const survivors = ['main', 'master', 'develop'].filter((branch) => runCmd(`git rev-parse --verify ${branch}`, cwd).exitCode === 0);
+    return survivors.length === 1 ? (survivors[0] ?? '') : '';
+}
+//# sourceMappingURL=canonical-branch.js.map

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -119,6 +119,7 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
                 pass: "pass";
             }>;
             evidence: z.ZodArray<z.ZodString>;
+            unverifiable: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     minimalityReport: z.ZodOptional<z.ZodObject<{
@@ -276,6 +277,7 @@ export declare const ARTIFACT_SCHEMAS: {
                     pass: "pass";
                 }>;
                 evidence: z.ZodArray<z.ZodString>;
+                unverifiable: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         minimalityReport: z.ZodOptional<z.ZodObject<{

package/dist/engine/handoff-artifacts/schemas.js

@@ -89,6 +89,7 @@ export const ValidationReportV1Schema = z.object({
             title: z.string(),
             verdict: z.enum(['pass', 'fail', 'missing']),
             evidence: z.array(z.string()),
+            unverifiable: z.literal(true).optional(),
         })),
     })
         .optional(),

package/dist/engine/human-summary.js

@@ -46,7 +46,7 @@ export function buildCheckReadinessSummary(score, blockerCount) {
 export function buildChallengeSpecSummary(blockingScenarios, gateStatus, advisoryCount) {
     const list = describeBlockingScenarios(blockingScenarios);
     if (gateStatus === 'blocked-critical') {
-        return `BLOCKED — ${String(blockingScenarios.length)} unresolved critical finding(s) must be resolved before this passes the challenge gate: ${list}. Record mitigation or accepted-risk evidence, then run challenge_spec again.`;
+        return `BLOCKED — ${String(blockingScenarios.length)} unresolved critical finding(s) must be resolved before this passes the challenge gate: ${list}. Record resolution evidence, then run challenge_spec again.`;
     }
     if (gateStatus === 'blocked-evidence' || gateStatus === 'refresh-required') {
         if (gateStatus === 'refresh-required') {

package/dist/engine/lifecycle-reconciliation.js

@@ -72,6 +72,9 @@ async function completeForwardReconciliation(args) {
         if (syncResult.warning) {
             throw new Error(`portable spec sync failed: ${syncResult.warning.reason}`);
         }
+        if (syncResult.title) {
+            await specStore.updateSpec(args.projectId, args.spec.id, { title: syncResult.title });
+        }
         next = { ...next, transitionId: args.transitionId, phase: 'spec-synced', auditPending: true };
         await args.persistReceipt(args.receiptPath, next);
     }

package/dist/engine/scope-boundaries/contradiction-checker.js

@@ -101,6 +101,26 @@ function splitClauses(text) {
         .filter(Boolean);
 }
 const AFFIRMATIVE_ACTION_VERBS = /\b(?:build(?:s|ing)?|chang(?:e|es|ing)|modif(?:y|ies|ying)|alter(?:s|ing)?|add(?:s|ing)?|introduc(?:e|es|ing)|implement(?:s|ing)?|enabl(?:e|es|ing)|expos(?:e|es|ing|ed)|mutat(?:e|es|ing)|rewrit(?:e|es|ing|ten)|remov(?:e|es|ing|ed)|relax(?:es|ing|ed)?|forc(?:e|es|ing)|suppress(?:es|ing|ed)?|weaken(?:s|ing|ed)?|degrad(?:e|es|ing|ed)|loosen(?:s|ing|ed)?|undermin(?:e|es|ing|ed)|bypass(?:es|ing|ed)?|disabl(?:e|es|ing|ed)|circumvent(?:s|ing|ed)?)\b/;
+const DETERMINERS_AND_PREPOSITIONS_HEADING_A_NOUN_PHRASE = new Set([
+    'a',
+    'an',
+    'the',
+    'this',
+    'these',
+    'those',
+    'in',
+    'on',
+    'at',
+    'of',
+    'into',
+    'onto',
+    'within',
+    'per',
+]);
+const QUOTED_OR_BACKTICKED_SPAN_RE = /`[^`\n]+`|"[^"\n]+"|'[^'\n]+'/g;
+function stripQuotedSpans(text) {
+    return text.replace(QUOTED_OR_BACKTICKED_SPAN_RE, ' ');
+}
 function assertsForbiddenAction(text) {
     return AFFIRMATIVE_ACTION_VERBS.test(normalize(text));
 }
@@ -157,7 +177,7 @@ function clauseMentionsScope(clause, outOfScopeItem) {
  */
 const ACTION_SCOPE_WINDOW = 4;
 function assertsActionNearScope(clause, outOfScopeItem) {
-    const tokens = normalize(clause).split(' ');
+    const tokens = normalize(stripQuotedSpans(clause)).split(' ');
     const scopeKeywords = keywords(outOfScopeItem);
     const mentionCandidates = scopeKeywords.length > 0 ? scopeKeywords : [normalize(outOfScopeItem)];
     for (let i = 0; i < tokens.length; i++) {
@@ -165,6 +185,11 @@ function assertsActionNearScope(clause, outOfScopeItem) {
         if (!AFFIRMATIVE_ACTION_VERBS.test(token)) {
             continue;
         }
+        const preceder = i > 0 ? tokens[i - 1] : undefined;
+        if (preceder !== undefined &&
+            DETERMINERS_AND_PREPOSITIONS_HEADING_A_NOUN_PHRASE.has(preceder)) {
+            continue;
+        }
         const before = tokens.slice(Math.max(0, i - 6), i).join(' ');
         if (endsWithNegation(before)) {
             continue;
@@ -201,10 +226,9 @@ function contradicts(criterionText, outOfScopeItem) {
     }
     const scopeAssertsForbiddenAction = assertsForbiddenAction(outOfScopeItem);
     return clauses.some((clause) => clauseMatchesScope(clause, outOfScopeItem) &&
-        (!scopeAssertsForbiddenAction ||
-            (hasConditionalException
-                ? assertsForbiddenAction(clause)
-                : assertsActionNearScope(clause, outOfScopeItem))));
+        (hasConditionalException && scopeAssertsForbiddenAction
+            ? assertsForbiddenAction(clause)
+            : assertsActionNearScope(clause, outOfScopeItem)));
 }
 /**
  * Check acceptance criteria against the spec's outOfScope declarations.

package/dist/engine/sdd-model-routing.js

@@ -121,8 +121,13 @@ async function contextCanBeReconstructed(params) {
                 blockers.push('handoffPath exists but is too small to be an operational package.');
             }
         }
-        catch {
-            blockers.push('handoffPath is missing or unreadable.');
+        catch (error) {
+            if (error.code === 'EISDIR') {
+                blockers.push('handoffPath is a directory, not the handoff package file.');
+            }
+            else {
+                blockers.push('handoffPath is missing or unreadable.');
+            }
         }
     }
     else if (!params.handoffArtifactId) {

package/dist/engine/spec-format/lean-spec-generator.js

@@ -166,7 +166,7 @@ function extractCheckboxCriteria(description) {
 function extractGivenWhenThenCriteria(description) {
     const criteria = [];
     // Single-line: GIVEN ... WHEN ... THEN ...
-    const singleLineRegex = /GIVEN\s+.+\s+WHEN\s+.+\s+THEN\s+(.+)/gi;
+    const singleLineRegex = /^[ \t]*(?:[-*>]\s*)?GIVEN\s+.+\s+WHEN\s+.+\s+THEN\s+(.+)$/gim;
     let match = singleLineRegex.exec(description);
     while (match) {
         const thenText = match[1]?.trim() ?? '';

package/dist/engine/staleness/stale-implementing.js

@@ -2,10 +2,11 @@
 //
 // Finds specs in 'implementing' status that have been there for >N days and have
 // no progress.md file. These are candidates for "done but untransitioned".
-import { readFile, access, readdir } from 'node:fs/promises';
+import { access, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { constants } from 'node:fs';
-import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+import { readTransitionLog } from '../../storage/transition-log.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -19,69 +20,29 @@ async function fileExists(p) {
     }
 }
 async function getLastTransitionForSpec(projectId, specId) {
-    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
-    try {
-        const raw = await readFile(logPath, 'utf-8');
-        const lines = raw.trim().split('\n').filter(Boolean);
-        let lastAt = null;
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                if (typeof entry === 'object' &&
-                    entry !== null &&
-                    'specId' in entry &&
-                    entry.specId === specId) {
-                    const at = entry.timestamp;
-                    if (typeof at === 'string') {
-                        lastAt = at;
-                    }
-                }
-            }
-            catch {
-                // Skip malformed lines
-            }
+    const entries = await readTransitionLog(projectId, specId);
+    let lastAt = null;
+    for (const entry of entries) {
+        if (typeof entry.timestamp === 'string') {
+            lastAt = entry.timestamp;
         }
-        return lastAt;
-    }
-    catch {
-        return null;
     }
+    return lastAt;
 }
 async function getDaysInImplementing(projectId, specId) {
-    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
-    try {
-        const raw = await readFile(logPath, 'utf-8');
-        const lines = raw.trim().split('\n').filter(Boolean);
-        let implementingAt = null;
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                if (typeof entry === 'object' &&
-                    entry !== null &&
-                    'specId' in entry &&
-                    'to' in entry &&
-                    entry.specId === specId &&
-                    entry.to === 'implementing') {
-                    const at = entry.timestamp;
-                    if (typeof at === 'string') {
-                        implementingAt = at;
-                    }
-                }
-            }
-            catch {
-                // Skip
-            }
-        }
-        if (implementingAt) {
-            const then = new Date(implementingAt).getTime();
-            const now = Date.now();
-            return Math.floor((now - then) / (1000 * 60 * 60 * 24));
+    const entries = await readTransitionLog(projectId, specId);
+    let implementingAt = null;
+    for (const entry of entries) {
+        if (entry.to === 'implementing' && typeof entry.timestamp === 'string') {
+            implementingAt = entry.timestamp;
         }
     }
-    catch {
-        // Fall through
+    if (!implementingAt) {
+        return -1;
     }
-    return -1;
+    const then = new Date(implementingAt).getTime();
+    const now = Date.now();
+    return Math.floor((now - then) / (1000 * 60 * 60 * 24));
 }
 // ---------------------------------------------------------------------------
 // Public API

package/dist/engine/text-signal-boundaries.js

@@ -26,6 +26,7 @@ const QUALIFIED_EVIDENCE_SUBJECT_RE = /^\s*(?:[-*+>]\s+|\d+[.)]\s+)?(?:(?:given|
 const CONTRACT_ANALYSIS_SUBJECT_RE = /^\s*(?:[-*+>]\s+|\d+[.)]\s+)?(?:(?:given|when|then|and)\s+)?(?:(?:the|this|that|a|an|any|each|our|existing|current)\s+)?(?:[\p{L}\p{N}_-]+\s+){0,2}contract\s+(?:evidence|inference|requirements?)\b/iu;
 const CONTRACT_ANALYSIS_PREDICATE_RE = /\b(?:(?:is|are)\s+(?:inferred|expected|selected|classified|matched|detected|discussed|reported|recorded)|expects?|records?|describes?)\b|\b(?:detector|classifier|matcher)\s+evidence\b|\b(?:positive[ -]?control|expected\s+absence|meta-analysis(?:-only)?)\b/iu;
 const META_ANALYSIS_TOOL_OUTPUT_RE = /\b(?:challenge[_\s]spec|challenge\s+tool)\b[^.!?\n]{0,120}?\bcall\b[^.!?\n]{0,120}?\b(?:emitted|returned|produced|reported|surfaced)\b[^.!?\n]{0,120}?\bscenarios?\b/iu;
+const CHALLENGE_FINDING_FIELD_RE = /\b(?:requiredHandling|currentHandling|dataConsistency|userExperience|relevanceScore)\b/u;
 function stripExcludedMarkdownSections(text) {
     const lines = text.split('\n');
     const kept = [];
@@ -73,7 +74,8 @@ export function stripMetaAnalysisText(text) {
         !EXPECTED_META_ANALYSIS_RE.test(clause) &&
         !QUALIFIED_EVIDENCE_SUBJECT_RE.test(clause) &&
         !(CONTRACT_ANALYSIS_SUBJECT_RE.test(clause) && CONTRACT_ANALYSIS_PREDICATE_RE.test(clause)) &&
-        !META_ANALYSIS_TOOL_OUTPUT_RE.test(clause))
+        !META_ANALYSIS_TOOL_OUTPUT_RE.test(clause) &&
+        !CHALLENGE_FINDING_FIELD_RE.test(clause))
         .join('\n');
 }
 function clauseBefore(text, index) {