@planu/cli 5.3.52 → 5.3.55

package/dist/engine/validator/spec-compliance-runner.js

@@ -499,33 +499,40 @@ export async function runSpecCompliance(spec, projectPath, signal, canonicalProj
         }
         const evidence = [];
         const commandRow = resolveExactCommandRow(exactCommandRows, scenario);
-        const verdicts = scenario.tests.map((source) => {
+        const linkResults = scenario.tests.map((source) => {
             if (!isExecutableTestLink(source)) {
                 const error = commandLinkErrors.get(source);
                 if (error) {
                     evidence.push(`${source.path || '(missing path)'}: ${error}`);
-                    return 'missing';
+                    return { verdict: 'missing', unverifiable: true };
                 }
                 const verdict = commandEvidenceCoversPath(commandRow, source.path) ? 'pass' : 'missing';
                 evidence.push(`${source.path}: ${verdict === 'pass' ? 'passed by current command evidence' : 'missing current command evidence'}`);
-                return verdict;
+                return { verdict, unverifiable: false };
             }
             const link = resolvedBySource.get(source);
             if (!link || link.error) {
                 evidence.push(`${source.path || '(missing path)'}: ${link?.error ?? 'malformed test link'}`);
-                return 'missing';
+                return { verdict: 'missing', unverifiable: true };
             }
             const adapter = statusByGroup.get(groupKey(link));
             const verdict = adapter?.statuses.get(link.path) ?? 'missing';
             evidence.push(`${link.path}: ${verdict === 'pass' ? 'passed' : verdict === 'fail' ? 'failed' : `not found in ${adapter?.detail ?? 'runner output'}`}`);
-            return verdict;
+            return { verdict, unverifiable: false };
         });
+        const verdicts = linkResults.map((entry) => entry.verdict);
+        const unverifiable = linkResults.some((entry) => entry.unverifiable);
         const verdict = verdicts.every((item) => item === 'pass')
             ? 'pass'
             : verdicts.some((item) => item === 'missing')
                 ? 'missing'
                 : 'fail';
-        return { title: scenario.title, verdict, evidence };
+        return {
+            title: scenario.title,
+            verdict,
+            evidence,
+            ...(unverifiable ? { unverifiable: true } : {}),
+        };
     });
     const passCount = perScenario.filter((scenario) => scenario.verdict === 'pass').length;
     return {

package/dist/engine/validator/validation-report-writer.js

@@ -155,6 +155,7 @@ function toValidationReportCompliance(result) {
             title: scenario.title,
             verdict: scenario.verdict,
             evidence: scenario.evidence,
+            ...(scenario.unverifiable && { unverifiable: scenario.unverifiable }),
         })),
     };
 }

package/dist/engine/workflow-validator/worktree-protocol.js

@@ -1,7 +1,8 @@
 // engine/workflow-validator/worktree-protocol.ts — SPEC-053
 // Worktree base validation and integration readiness checks.
 import { execSync } from 'node:child_process';
-// === Helpers ===
+import { resolveCanonicalBranch } from '../git/canonical-branch.js';
+const INTEGRATION_BRANCHES = ['main', 'master', 'develop'];
 function runCmd(cmd, cwd) {
     try {
         const output = execSync(cmd, {
@@ -19,57 +20,65 @@ function runCmd(cmd, cwd) {
         };
     }
 }
-function getWorktreeBranchBase(worktreePath) {
-    const result = runCmd('git rev-parse --abbrev-ref HEAD', worktreePath);
-    if (result.exitCode !== 0) {
-        return '';
+function getWorktreeBaseCandidates(worktreePath) {
+    const headResult = runCmd('git rev-parse --abbrev-ref HEAD', worktreePath);
+    if (headResult.exitCode !== 0) {
+        return [];
     }
-    // Get the merge-base of the current branch with develop
-    const developResult = runCmd('git rev-parse develop', worktreePath);
-    if (developResult.exitCode !== 0) {
-        return 'main'; // develop doesn't exist — likely based from main
-    }
-    const mergeBaseResult = runCmd(`git merge-base HEAD ${developResult.output}`, worktreePath);
-    if (mergeBaseResult.exitCode !== 0) {
-        return '';
-    }
-    // Check if merge-base equals develop HEAD (branch was from develop)
-    if (mergeBaseResult.output === developResult.output) {
-        return 'develop';
-    }
-    // Check if merge-base equals main HEAD
-    const mainResult = runCmd('git rev-parse main', worktreePath);
-    if (mainResult.exitCode === 0 && mergeBaseResult.output === mainResult.output) {
-        return 'main';
-    }
-    return 'develop'; // assume develop as default
+    const containedInHead = INTEGRATION_BRANCHES.filter((branch) => {
+        const branchResult = runCmd(`git rev-parse --verify ${branch}`, worktreePath);
+        if (branchResult.exitCode !== 0) {
+            return false;
+        }
+        const mergeBaseResult = runCmd(`git merge-base HEAD ${branch}`, worktreePath);
+        return mergeBaseResult.exitCode === 0 && mergeBaseResult.output === branchResult.output;
+    });
+    return containedInHead.filter((branch) => !containedInHead.some((other) => other !== branch &&
+        runCmd(`git merge-base --is-ancestor ${branch} ${other}`, worktreePath).exitCode === 0 &&
+        runCmd(`git merge-base --is-ancestor ${other} ${branch}`, worktreePath).exitCode !== 0));
 }
-// === C13: Validate worktree was created from develop ===
 export function validateWorktreeBase(worktreePath) {
-    const baseBranch = getWorktreeBranchBase(worktreePath);
-    if (!baseBranch) {
+    const candidates = getWorktreeBaseCandidates(worktreePath);
+    const canonical = resolveCanonicalBranch(worktreePath);
+    const candidateList = candidates.join(', ');
+    if (candidates.length === 0) {
         return {
             valid: false,
             baseBranch: 'unknown',
             message: 'Could not determine the base branch of this worktree.',
-            suggestion: 'Ensure git is initialized and both develop and main branches exist.',
+            suggestion: 'Ensure git is initialized and an integration branch (main, master, or develop) exists.',
+        };
+    }
+    if (canonical && !candidates.includes(canonical)) {
+        return {
+            valid: false,
+            baseBranch: candidateList,
+            message: `Worktree was created from '${candidateList}' instead of the canonical branch '${canonical}'.`,
+            suggestion: `Always create worktrees from ${canonical}: git worktree add .claude/worktrees/agent-XXX ${canonical}`,
+        };
+    }
+    if (candidates.length >= 2) {
+        return {
+            valid: true,
+            baseBranch: candidateList,
+            message: `Worktree base is ambiguous between ${candidateList}; HEAD contains both.`,
         };
     }
-    if (baseBranch === 'develop') {
+    const onlyCandidate = candidates[0] ?? '';
+    if (!canonical) {
         return {
             valid: true,
-            baseBranch: 'develop',
-            message: 'Worktree is correctly based on develop.',
+            baseBranch: onlyCandidate,
+            message: `Worktree is based on '${onlyCandidate}', but the canonical branch could not be determined so the base was not verified.`,
+            suggestion: 'Run git remote set-head origin -a to record the canonical branch.',
         };
     }
     return {
-        valid: false,
-        baseBranch,
-        message: `Worktree was created from '${baseBranch}' instead of 'develop'.`,
-        suggestion: 'Always create worktrees from develop: git worktree add .claude/worktrees/agent-XXX develop',
+        valid: true,
+        baseBranch: onlyCandidate,
+        message: `Worktree is correctly based on ${onlyCandidate}.`,
     };
 }
-// === C15: Integration readiness — typecheck + lint must pass ===
 export function validateIntegrationReadiness(projectPath) {
     const issues = [];
     const typecheckResult = runCmd('pnpm typecheck', projectPath);

package/dist/storage/transition-log.d.ts

@@ -1,23 +1,11 @@
 import type { TransitionLogEntry, AppendTransitionEventInput, VerifyChainResult } from '../types/transition-log.js';
+export declare function transitionLogPath(projectId: string): string;
 /**
  * Append a transition event to the project's transition log.
  * Writes are serialized per file to preserve hash-chain integrity.
  */
 export declare function appendTransitionEvent(input: AppendTransitionEventInput): Promise<TransitionLogEntry>;
-/**
- * Read all transition log entries for a given project and spec.
- * Returns an empty array if the file does not exist.
- */
 export declare function readTransitionLog(projectId: string, specId?: string): Promise<TransitionLogEntry[]>;
-/**
- * SPEC-734: Verify the hash-chain integrity of a project's transition log.
- *
- * For each entry, recomputes `sha` from `canonicalEntry(entry)` and checks
- * that `prevSha` matches the previous entry's `sha`. Legacy entries that
- * predate SPEC-734 (missing `sessionId`/`modelId`/`gateResults`) are
- * tolerated — their sha was computed without those fields and remains valid
- * because `canonicalEntry` serialises undefined fields as JSON `undefined`
- * (i.e. they are omitted from the string, same as when they were written).
- */
 export declare function verifyTransitionLogChain(projectId: string): Promise<VerifyChainResult>;
+export declare function streamJsonlLines(filePath: string): AsyncGenerator<string>;
 //# sourceMappingURL=transition-log.d.ts.map

package/dist/storage/transition-log.js

@@ -5,14 +5,15 @@
 // Each entry is a JSON object on its own line. The `sha` field is a SHA-256 hash
 // of the entry's canonical JSON (excluding `sha`), chained via `prevSha`.
 import { createHash, randomUUID } from 'node:crypto';
-import { appendFile, readFile, mkdir } from 'node:fs/promises';
+import { appendFile, mkdir } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { projectDataDir } from './base-store.js';
 import { reportClassifiedDegradation } from '../errors/classified-degradation.js';
 // ---------------------------------------------------------------------------
 // Path helper
 // ---------------------------------------------------------------------------
-function transitionLogPath(projectId) {
+export function transitionLogPath(projectId) {
     return join(projectDataDir(projectId), 'transition-log.jsonl');
 }
 // ---------------------------------------------------------------------------
@@ -55,11 +56,12 @@ function computeEntrySha(entry) {
 const writeQueues = new Map();
 async function doAppend(filePath, input) {
     await mkdir(dirname(filePath), { recursive: true });
-    // Read last entry's sha to chain
-    const lines = await readJsonlLines(filePath);
+    let lastLine;
+    for await (const line of streamJsonlLines(filePath)) {
+        lastLine = line;
+    }
     let prevSha = '';
-    if (lines.length > 0) {
-        const lastLine = lines[lines.length - 1] ?? '';
+    if (lastLine !== undefined) {
         try {
             const parsed = JSON.parse(lastLine);
             prevSha = typeof parsed.sha === 'string' ? parsed.sha : '';
@@ -107,15 +109,10 @@ export function appendTransitionEvent(input) {
     writeQueues.set(filePath, next.then(() => undefined, () => undefined));
     return next.then(() => result);
 }
-/**
- * Read all transition log entries for a given project and spec.
- * Returns an empty array if the file does not exist.
- */
 export async function readTransitionLog(projectId, specId) {
     const filePath = transitionLogPath(projectId);
-    const lines = await readJsonlLines(filePath);
     const entries = [];
-    for (const line of lines) {
+    for await (const line of streamJsonlLines(filePath)) {
         try {
             const entry = JSON.parse(line);
             if (specId === undefined || entry.specId === specId) {
@@ -130,64 +127,106 @@ export async function readTransitionLog(projectId, specId) {
     }
     return entries;
 }
-/**
- * SPEC-734: Verify the hash-chain integrity of a project's transition log.
- *
- * For each entry, recomputes `sha` from `canonicalEntry(entry)` and checks
- * that `prevSha` matches the previous entry's `sha`. Legacy entries that
- * predate SPEC-734 (missing `sessionId`/`modelId`/`gateResults`) are
- * tolerated — their sha was computed without those fields and remains valid
- * because `canonicalEntry` serialises undefined fields as JSON `undefined`
- * (i.e. they are omitted from the string, same as when they were written).
- */
 export async function verifyTransitionLogChain(projectId) {
     const filePath = transitionLogPath(projectId);
-    const lines = await readJsonlLines(filePath);
-    if (lines.length === 0) {
-        return { valid: true, totalEntries: 0, brokenAt: null };
-    }
     let prevSha = '';
-    for (let i = 0; i < lines.length; i++) {
+    let totalEntries = 0;
+    for await (const line of streamJsonlLines(filePath)) {
+        const index = totalEntries;
+        totalEntries++;
         let entry;
         try {
-            entry = JSON.parse(lines[i] ?? '');
+            entry = JSON.parse(line);
         }
         catch {
-            return { valid: false, totalEntries: lines.length, brokenAt: i };
+            return { valid: false, totalEntries, brokenAt: index };
         }
-        // Recompute sha from all fields except 'sha' itself
         const { sha: storedSha, ...rest } = entry;
         const expectedSha = computeEntrySha(rest);
         if (storedSha !== expectedSha) {
-            return { valid: false, totalEntries: lines.length, brokenAt: i };
+            return { valid: false, totalEntries, brokenAt: index };
         }
-        if (i === 0) {
-            // First entry must have prevSha === '' (genesis)
-            if (entry.prevSha !== '') {
-                return { valid: false, totalEntries: lines.length, brokenAt: 0 };
-            }
-        }
-        else if (entry.prevSha !== prevSha) {
-            return { valid: false, totalEntries: lines.length, brokenAt: i };
+        const expectedPrevSha = index === 0 ? '' : prevSha;
+        if (entry.prevSha !== expectedPrevSha) {
+            return { valid: false, totalEntries, brokenAt: index };
         }
         prevSha = storedSha;
     }
-    return { valid: true, totalEntries: lines.length, brokenAt: null };
+    return { valid: true, totalEntries, brokenAt: null };
 }
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-async function readJsonlLines(filePath) {
-    let raw;
+const MAX_LINE_BYTES = 64 * 1024 * 1024;
+export async function* streamJsonlLines(filePath) {
+    const stream = createReadStream(filePath);
+    let pending = [];
+    let pendingLength = 0;
+    let discardingOversizedLine = false;
+    function resetPending() {
+        pending = [];
+        pendingLength = 0;
+    }
+    function* drainCompleteLines(buf) {
+        let start = 0;
+        let newlineIndex = buf.indexOf(0x0a, start);
+        while (newlineIndex !== -1) {
+            const line = buf.toString('utf-8', start, newlineIndex);
+            if (line.trim().length > 0) {
+                yield line;
+            }
+            start = newlineIndex + 1;
+            newlineIndex = buf.indexOf(0x0a, start);
+        }
+        const remainder = buf.subarray(start);
+        if (remainder.length > 0) {
+            pending = [Buffer.from(remainder)];
+            pendingLength = remainder.length;
+        }
+    }
+    function* processChunk(chunk) {
+        let data = chunk;
+        if (discardingOversizedLine) {
+            const newlineIndex = data.indexOf(0x0a);
+            if (newlineIndex === -1) {
+                return;
+            }
+            discardingOversizedLine = false;
+            data = data.subarray(newlineIndex + 1);
+            if (data.length === 0) {
+                return;
+            }
+        }
+        if (!data.includes(0x0a)) {
+            pending.push(Buffer.from(data));
+            pendingLength += data.length;
+            if (pendingLength > MAX_LINE_BYTES) {
+                reportClassifiedDegradation('OVERSIZED_TRANSITION_LINE', new Error(`Line exceeds ${MAX_LINE_BYTES} bytes without a newline: ${filePath}`));
+                resetPending();
+                discardingOversizedLine = true;
+            }
+            return;
+        }
+        const buf = pendingLength > 0 ? Buffer.concat([...pending, data]) : Buffer.from(data);
+        resetPending();
+        yield* drainCompleteLines(buf);
+    }
     try {
-        raw = await readFile(filePath, 'utf-8');
+        for await (const chunk of stream) {
+            yield* processChunk(chunk);
+        }
     }
     catch (err) {
         if (isNodeError(err) && err.code === 'ENOENT') {
-            return [];
+            return;
         }
         throw err;
     }
-    return raw.split('\n').filter((l) => l.trim().length > 0);
+    if (pendingLength > 0) {
+        const line = Buffer.concat(pending).toString('utf-8');
+        if (line.trim().length > 0) {
+            yield line;
+        }
+    }
 }
 //# sourceMappingURL=transition-log.js.map

package/dist/tools/challenge-spec/challenge-report.js

@@ -24,10 +24,12 @@ function uniqueMatchingEvidence(evidence, scenarioNames) {
     }
     return [...matched.values()];
 }
+const NEGATED_ACCEPTANCE_RE = /\b(?:not|never|no|cannot|can not|can't|won't|isn't|aren't|doesn't|didn't)\b(?:\W+\w+){0,2}\W+(?:accepted|accept risk|accepted risk|known risk)\b/i;
 function inferResolution(text) {
-    return /\b(accepted|accept risk|accepted risk|known risk)\b/i.test(text)
-        ? 'accepted'
-        : 'mitigated';
+    if (!/\b(accepted|accept risk|accepted risk|known risk)\b/i.test(text)) {
+        return 'mitigated';
+    }
+    return NEGATED_ACCEPTANCE_RE.test(text) ? 'mitigated' : 'accepted';
 }
 function extractChallengeResolutionSection(specContent) {
     const normalized = specContent.replace(/\r\n/g, '\n');
@@ -37,11 +39,40 @@ function extractChallengeResolutionSection(specContent) {
         return '';
     }
     const start = match.index + match[0].length;
-    const nextRe = /^###\s+\S/gm;
+    const nextRe = /^#{2,3}\s+\S/gm;
     nextRe.lastIndex = start;
     const next = nextRe.exec(normalized);
     return normalized.slice(start, next ? next.index : normalized.length).trim();
 }
+function collapseWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function foldChallengeResolutionBullets(section) {
+    const bullets = [];
+    let current = null;
+    for (const rawLine of section.split('\n')) {
+        const line = rawLine.trim();
+        if (/^-\s+/.test(line)) {
+            if (current !== null) {
+                bullets.push(current);
+            }
+            current = line.replace(/^-\s+/, '');
+        }
+        else if (line.length === 0) {
+            if (current !== null) {
+                bullets.push(current);
+            }
+            current = null;
+        }
+        else if (current !== null) {
+            current += ` ${line}`;
+        }
+    }
+    if (current !== null) {
+        bullets.push(current);
+    }
+    return bullets.map(collapseWhitespace);
+}
 export function parseChallengeResolutionEvidence(specContent, scenarios, runAt) {
     const section = extractChallengeResolutionSection(specContent);
     if (section.length === 0 || scenarios.length === 0) {
@@ -52,23 +83,23 @@ export function parseChallengeResolutionEvidence(specContent, scenarios, runAt)
         if (!singleScenario) {
             return [];
         }
+        const collapsedSection = collapseWhitespace(section);
+        if (!collapsedSection.includes(collapseWhitespace(singleScenario.scenario))) {
+            return [];
+        }
         return [
             {
                 scenario: singleScenario.scenario,
                 resolution: inferResolution(section),
-                evidence: section.replace(/\s+/g, ' ').trim(),
+                evidence: collapsedSection,
                 resolvedAt: runAt,
             },
         ];
     }
-    const bullets = section
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => /^-\s+/.test(line))
-        .map((line) => line.replace(/^-\s+/, '').trim());
+    const bullets = foldChallengeResolutionBullets(section);
     const evidence = [];
     for (const bullet of bullets) {
-        const scenario = scenarios.find((item) => bullet.includes(item.scenario));
+        const scenario = scenarios.find((item) => bullet.includes(collapseWhitespace(item.scenario)));
         if (!scenario) {
             continue;
         }

package/dist/tools/challenge-spec/scenarios-utils.js

@@ -2,8 +2,6 @@
 import { hasAffirmedMatch, hasAnyAffirmedMatch, stripMetaAnalysisText, stripNonContractText, } from '../../engine/text-signal-boundaries.js';
 const CAPABILITY_SIGNALS = {
     networkApi: [
-        /(?<!compiler\s)\bapi\b(?!\s+(?:compatibility|surface|package|type))/i,
-        /\b(?:public|external|remote|rest|http)\s+api\b/i,
         /\bapi\s+(?:endpoint|route|request|response|server|client)\b/i,
         /\b(?:http|rest)\s+(?:endpoint|route|request|response)\b/i,
         /\bfetch(?:es|ing)?\s+(?:from\s+)?(?:an?\s+)?(?:endpoint|service|url)\b/i,
@@ -104,6 +102,14 @@ function hasProductAuthenticationEvidence(contract) {
     return (hasAffirmedMatch(contract, AUTHENTICATION_BARE_TOKEN_RE) &&
         !REGISTRY_AUTH_CONTEXT_RE.test(contract));
 }
+const NETWORK_API_BARE_TOKEN_RE = /(?<!compiler\s)\bapi\b(?!\s+(?:compatibility|surface|package|type))/i;
+const NETWORK_API_CONTEXT_RE = /\b(?:endpoint|route|http|https|rest|fetch|url|socket|request|response|timeout|retry|webhook|payload|keys?)\b(?:\W+\w+){0,6}?\W+api\b|\bapi\b(?:\W+\w+){0,6}?\W+\b(?:endpoint|route|http|https|rest|fetch|url|socket|request|response|timeout|retry|webhook|payload|keys?)\b/i;
+function hasProductNetworkEvidence(contract) {
+    if (hasAnyAffirmedMatch(contract, CAPABILITY_SIGNALS.networkApi)) {
+        return true;
+    }
+    return (hasAffirmedMatch(contract, NETWORK_API_BARE_TOKEN_RE) && NETWORK_API_CONTEXT_RE.test(contract));
+}
 function keywordPattern(keyword) {
     const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+');
     const suffix = /^[a-z0-9]+$/i.test(keyword) && keyword.length > 3 ? '[a-z0-9_-]*' : '';
@@ -139,6 +145,7 @@ export function detectChallengeCapabilities(spec, specContent) {
         hasAnyAffirmedMatch(contract, patterns),
     ]));
     capabilities.authentication = hasProductAuthenticationEvidence(contract);
+    capabilities.networkApi = hasProductNetworkEvidence(contract);
     return capabilities;
 }
 export function hasAnyChallengeCapability(capabilities, names) {

package/dist/tools/generate-orchestration-script.js

@@ -1,6 +1,7 @@
 // tools/generate-orchestration-script.ts — SPEC-022 TD: 3-layer parallel automation script generator
 // Generates a bash orchestration script for parallel multi-agent execution via git worktrees.
 import { t } from '../i18n/index.js';
+import { resolveCanonicalBranch } from '../engine/git/canonical-branch.js';
 import { generateOrchestrationScript } from './suggest-tooling/orchestration-generator.js';
 export function handleGenerateOrchestrationScript(args) {
     const { specIds, projectPath, mainBranch, baseBranch } = args;
@@ -21,7 +22,7 @@ export function handleGenerateOrchestrationScript(args) {
         '',
         `**Specs:** ${specIds.join(', ')}`,
         `**Project path:** ${projectPath}`,
-        `**Base branch:** ${baseBranch ?? 'develop'}`,
+        `**Base branch:** ${(baseBranch ?? resolveCanonicalBranch(projectPath)) || 'main'}`,
         '',
         '### Usage',
         '',

package/dist/tools/register-platform-tools/design-stack-tools.js

@@ -218,7 +218,7 @@ export function registerDesignStackTools(server) {
                 .string()
                 .max(500)
                 .optional()
-                .describe('Base branch for worktrees (default: develop)'),
+                .describe("Base branch for worktrees (default: the project's canonical branch)"),
         },
     }, safeGoverned('generate_orchestration_script', (args) => Promise.resolve(handleGenerateOrchestrationScript(args))));
     // 32. red_team

package/dist/tools/suggest-tooling/orchestration-generator.js

@@ -1,7 +1,7 @@
 // tools/suggest-tooling/orchestration-generator.ts — SPEC-022 TD: 3-layer orchestration script generator
 // Generates a parallel automation bash script: validate → worktrees → parallel claude -p → wait → report → cleanup
+import { resolveCanonicalBranch } from '../../engine/git/canonical-branch.js';
 const DEFAULT_MAIN_BRANCH = 'main';
-const DEFAULT_BASE_BRANCH = 'develop';
 const WORKTREE_BASE = '.claude/worktrees';
 /**
  * Generates a parallel orchestration bash script that:
@@ -15,7 +15,7 @@ const WORKTREE_BASE = '.claude/worktrees';
 export function generateOrchestrationScript(input) {
     const { specIds, projectPath, mainBranch, baseBranch } = input;
     const main = mainBranch ?? DEFAULT_MAIN_BRANCH;
-    const base = baseBranch ?? DEFAULT_BASE_BRANCH;
+    const base = (baseBranch ?? resolveCanonicalBranch(projectPath)) || 'main';
     const worktreeSetupLines = buildWorktreeSetup(specIds, base);
     const launchLines = buildParallelLaunch(specIds, projectPath);
     const waitLines = buildWaitAndReport(specIds);

package/dist/tools/sync-spec-state-handler.js

@@ -10,7 +10,7 @@ import { hashProjectPath } from '../storage/base-store.js';
 import { handleUpdateStatus } from './update-status/index.js';
 import { parseFrontmatter } from '../engine/frontmatter-parser.js';
 import { verifyTerminalFrontmatter } from '../engine/frontmatter-sha/index.js';
-import { appendTransitionEvent } from '../storage/transition-log.js';
+import { appendTransitionEvent, streamJsonlLines, transitionLogPath, } from '../storage/transition-log.js';
 import { cleanEphemeralArtifacts } from '../engine/housekeeping/index.js';
 import { readFile, stat } from 'node:fs/promises';
 // ---------------------------------------------------------------------------
@@ -142,14 +142,24 @@ export async function syncSpecState(projectPath, projectId) {
     }
     return report;
 }
-/**
- * SPEC-1351 (AC3): scan the data store for entries whose spec.md is missing on
- * disk and quarantine each one — appends a `ghost_spec_quarantined` transition
- * event (surfaced by workspace_alerts with a recovery action) and returns the
- * list so callers can report it inline.
- */
+async function collectQuarantinedSpecIds(projectId) {
+    const quarantined = new Set();
+    for await (const line of streamJsonlLines(transitionLogPath(projectId))) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.eventType === 'ghost_spec_quarantined' && typeof entry.specId === 'string') {
+                quarantined.add(entry.specId);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return quarantined;
+}
 async function detectGhostSpecs(projectId, dataEntries) {
     const ghosts = [];
+    const alreadyQuarantined = await collectQuarantinedSpecIds(projectId);
     await Promise.all(dataEntries.map(async (entry) => {
         if (!entry.specPath) {
             return;
@@ -165,6 +175,9 @@ async function detectGhostSpecs(projectId, dataEntries) {
         }
         const reason = `Store entry ${entry.id} references spec.md at ${entry.specPath}, which is missing or empty on disk. Recreate the spec via create_spec or restore spec.md from git/backup.`;
         ghosts.push({ specId: entry.id, specPath: entry.specPath, reason });
+        if (alreadyQuarantined.has(entry.id)) {
+            return;
+        }
         void appendTransitionEvent({
             projectId,
             specId: entry.id,