@planu/cli 5.7.5 → 5.7.6

package/dist/engine/validation/validation-freshness.js

@@ -635,15 +635,15 @@ async function readStableState(lease, expectedGeneration) {
     return undefined;
 }
 /** Drain invalidation work and verify epoch, generation, health, expiry and bound inputs. */
-export async function assertValidationFreshnessBarrier(lease, bindings) {
+export async function evaluateValidationFreshnessBarrier(lease, bindings) {
     const candidate = active.get(key(lease.projectId, lease.specId));
     if (!candidate?.healthy ||
         candidate.epoch !== lease.epoch ||
         candidate.generation !== lease.generation) {
-        return false;
+        return { fresh: false, reason: 'lease-superseded' };
     }
     if (!(await drainAmbiguousEvents(lease, candidate, candidate.bindings))) {
-        return false;
+        return { fresh: false, reason: 'invalidation-drain-failed' };
     }
     let fingerprintBefore;
     try {
@@ -652,23 +652,23 @@ export async function assertValidationFreshnessBarrier(lease, bindings) {
     catch (error) {
         reportClassifiedDegradation('VALIDATION_FRESHNESS_CHECK_FAILED', error);
         invalidateExactEpoch(lease, candidate);
-        return false;
+        return { fresh: false, reason: 'evidence-check-failed', changedInput: candidate.handoffPath };
     }
     if (fingerprintBefore !== candidate.evidenceFingerprint) {
         invalidateExactEpoch(lease, candidate);
-        return false;
+        return { fresh: false, reason: 'evidence-changed', changedInput: candidate.handoffPath };
     }
     try {
         if (candidate.bindings &&
             (await gitSourceTreeDigest(candidate.projectPath)) !== candidate.bindings.sourceDigest) {
             invalidateExactEpoch(lease, candidate);
-            return false;
+            return { fresh: false, reason: 'source-changed', changedInput: candidate.projectPath };
         }
     }
     catch (error) {
         reportClassifiedDegradation('VALIDATION_FRESHNESS_CHECK_FAILED', error);
         invalidateExactEpoch(lease, candidate);
-        return false;
+        return { fresh: false, reason: 'source-check-failed', changedInput: candidate.projectPath };
     }
     // A generation change invalidates the lease synchronously. Do not wait for
     // the durable receipt cleanup when the in-memory barrier already fails
@@ -684,15 +684,21 @@ export async function assertValidationFreshnessBarrier(lease, bindings) {
     }
     if (!state || fingerprintAfter !== fingerprintBefore) {
         invalidateExactEpoch(lease, candidate);
-        return false;
+        return { fresh: false, reason: 'state-lost', changedInput: candidate.handoffPath };
     }
     if (state.generation !== lease.generation) {
-        return false;
+        return { fresh: false, reason: 'lease-superseded' };
     }
     if (Date.now() >= state.expiresAt) {
-        return false;
+        return { fresh: false, reason: 'lease-expired' };
+    }
+    if (bindings !== undefined && JSON.stringify(state.bindings) !== JSON.stringify(bindings)) {
+        return { fresh: false, reason: 'bindings-mismatch' };
     }
-    return bindings === undefined || JSON.stringify(state.bindings) === JSON.stringify(bindings);
+    return { fresh: true };
+}
+export async function assertValidationFreshnessBarrier(lease, bindings) {
+    return (await evaluateValidationFreshnessBarrier(lease, bindings)).fresh;
 }
 export async function captureValidationFreshnessLease(identity, bindings) {
     const state = active.get(key(identity.projectId, identity.specId));
@@ -707,7 +713,7 @@ export async function rebaselineValidationFreshnessLeaseAfterRecompute(input) {
     for (let attempt = 0; attempt < 2; attempt += 1) {
         const before = await readStableState(input.lease);
         if (!before || Date.now() >= before.expiresAt) {
-            return undefined;
+            return { rejection: { reason: 'lease-expired' } };
         }
         const generationBefore = before.generation;
         let fingerprintBefore;
@@ -721,14 +727,14 @@ export async function rebaselineValidationFreshnessLeaseAfterRecompute(input) {
         catch (error) {
             reportClassifiedDegradation('VALIDATION_FRESHNESS_CHECK_FAILED', error);
             invalidateExactEpoch(input.lease, before);
-            return undefined;
+            return { rejection: { reason: 'recompute-failed', changedInput: before.handoffPath } };
         }
         const after = await readStableState(input.lease);
         if (after?.generation !== generationBefore || fingerprintBefore !== fingerprintAfter) {
             continue;
         }
         if (JSON.stringify(input.expectedBindings) !== JSON.stringify(observedBindings)) {
-            return undefined;
+            return { rejection: { reason: 'bindings-mismatch' } };
         }
         const confirmed = await readStableState(input.lease);
         if (confirmed?.generation !== after.generation) {
@@ -736,9 +742,9 @@ export async function rebaselineValidationFreshnessLeaseAfterRecompute(input) {
         }
         confirmed.bindings = structuredClone(observedBindings);
         confirmed.evidenceFingerprint = fingerprintAfter;
-        return { ...input.lease, generation: confirmed.generation };
+        return { lease: { ...input.lease, generation: confirmed.generation } };
     }
-    return undefined;
+    return { rejection: { reason: 'lease-unstable' } };
 }
 export async function resetValidationFreshnessForTests() {
     const leases = [...active.entries()].map(([identity, state]) => {

package/dist/engine/validation/validation-worktree.js

@@ -9,6 +9,7 @@ const runFile = promisify(execFile);
 const ROOT_ID = /^[a-f0-9]{64}$/u;
 const SAFE_SPEC_ID = /^SPEC-[1-9]\d*$/u;
 const PORTABLE_SPEC = /^planu\/specs\/(SPEC-\d{3,}(?:-[^/]+)?)\/spec\.md$/u;
+const STALE_SPEC_TAIL = /planu[/\\]specs[/\\]([^/\\]+)[/\\]spec\.md$/u;
 export class ValidationWorktreeError extends Error {
     code;
     specId;
@@ -83,6 +84,35 @@ async function resolveGitRoot(projectPath, specId) {
     }
     return membership;
 }
+function derivePortableSuffix(specPath, specId) {
+    const match = STALE_SPEC_TAIL.exec(specPath);
+    const dir = match?.[1];
+    if (!dir || (dir !== specId && !dir.startsWith(`${specId}-`))) {
+        return undefined;
+    }
+    const portableSuffix = `planu/specs/${dir}/spec.md`;
+    return PORTABLE_SPEC.test(portableSuffix) ? portableSuffix : undefined;
+}
+async function classifyStaleSpecPath(specPath, specId) {
+    if (!isAbsolute(specPath)) {
+        return undefined;
+    }
+    const portableSuffix = derivePortableSuffix(specPath, specId);
+    if (!portableSuffix) {
+        return undefined;
+    }
+    try {
+        await lstat(dirname(specPath));
+        return undefined;
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            return portableSuffix;
+        }
+        reportClassifiedDegradation('VALIDATION_STALE_PREFIX_PROBE_FAILED', error);
+        return undefined;
+    }
+}
 async function resolveSpecSourceRoot(input) {
     const specPath = isAbsolute(input.canonicalSpecPath)
         ? input.canonicalSpecPath
@@ -92,6 +122,10 @@ async function resolveSpecSourceRoot(input) {
         source = await resolveGitMembership(dirname(specPath), input.specId);
     }
     catch {
+        const portableSuffix = await classifyStaleSpecPath(specPath, input.specId);
+        if (portableSuffix) {
+            throw new ValidationWorktreeError('VALIDATION_STALE_SPEC_PATH', input.specId, portableSuffix);
+        }
         throw new ValidationWorktreeError('VALIDATION_SPEC_PATH_TRAVERSAL', input.specId);
     }
     if (source.gitCommonDir !== input.canonical.gitCommonDir) {

package/dist/hosts/claude-code/ux/mcp-prompts.js

@@ -87,7 +87,7 @@ function buildExecuteSddFlowPrompt(specId, projectPath, mode) {
     const branchStep = mode !== 'implement-only'
         ? '4. Create a feature branch: `git checkout -b feat/' + specId + '-<slug>`.'
         : '4. Implement in the current branch (implement-only mode).';
-    const prStep = mode !== 'implement-only' ? '12. Open a PR with `create_pr_from_spec`.' : '';
+    const prStep = mode !== 'implement-only' ? '12. Open a PR with `gh pr create`.' : '';
     return [
         `You are implementing Planu spec \`${specId}\`${pathHint}${modeHint} using the full SDD flow.`,
         '',
@@ -104,7 +104,7 @@ function buildExecuteSddFlowPrompt(specId, projectPath, mode) {
         '8. Call `validate({ specId: "' +
             specId +
             '" })` and capture the durable acknowledgement fields: `operationId`, `projectId`, `workspaceId`, and `cursor`.',
-        '9. Call `watch_job` with those identifiers and the latest cursor. Repeat while the job is non-terminal; do not treat an accepted or running job as a validation result.',
+        '9. Poll `get_job` with those identifiers and the latest cursor. Repeat while the job is non-terminal; do not treat an accepted or running job as a validation result.',
         '10. Require terminal state `completed`, then inspect `job.result.structuredContent`. If the job is failed, dead-letter, or cancelled, stop and report it. Fix every failing criterion and submit a new validation job when needed.',
         '11. Call `update_status({ specId: "' +
             specId +
@@ -118,18 +118,18 @@ function buildExecuteSddFlowPrompt(specId, projectPath, mode) {
 }
 function buildChallengeSpecPrompt(specId, focus) {
     const focusHint = focus !== undefined && focus !== 'all' ? ` with a focus on **${focus}**` : '';
-    const securityStep = focus === 'security' || focus === 'all'
-        ? '5. Call `red_team` for adversarial security scenarios.'
+    const securityHint = focus === 'security' || focus === 'all'
+        ? ' Pay special attention to adversarial and security-relevant scenarios.'
         : '';
     return [
         `You are stress-testing Planu spec \`${specId}\`${focusHint} to find weaknesses before implementation.`,
         '',
         'Steps:',
         `1. Call \`list_specs\` and read the full spec for \`${specId}\`.`,
-        `2. Call \`challenge_spec({ specId: "${specId}" })\` and read all findings.`,
-        '3. Call `ears_lint` to check criterion format quality.',
-        '4. Call `validate_criteria_quality` for testability gaps.',
-        securityStep,
+        `2. Call \`challenge_spec({ specId: "${specId}" })\` and read all findings.${securityHint}`,
+        '3. Call `check_readiness({ specId: "' +
+            specId +
+            '" })` to verify the spec has enough detail to implement.',
         '',
         'For each finding, provide:',
         '- Severity: 🔴 blocking | 🟡 missing edge case | 🟢 ambiguity',

package/dist/index.js

@@ -83,6 +83,9 @@ function scheduleStartupStateRecovery(startupSync, recoverPendingPostCommitTasks
     void import('./engine/execution/validate-job-executor.js').then(({ recoverValidateJobsAtStartup }) => {
         recoverValidateJobsAtStartup();
     });
+    void import('./engine/execution/package-handoff-job-executor.js').then(({ recoverPackageHandoffJobsAtStartup }) => {
+        recoverPackageHandoffJobsAtStartup();
+    });
 }
 const MCP_HOST_MARKERS = [
     ['claude-code', 'claude-code'],
@@ -139,23 +142,6 @@ async function setupPostHandshake(handshakeGate, officialToolNames) {
     checkForUpdates().catch(() => {
         /* best-effort */
     });
-    // SPEC-566: Auto-configure Claude Code keybindings (global, one-time)
-    void (async () => {
-        try {
-            const { globalStore: gs } = await import('./storage/index.js');
-            const cfg = await gs.getGlobalConfig();
-            if (!cfg.keybindingsConfigured) {
-                const { configureClaudeKeybindings } = await import('./engine/claude-setup/keybindings-configurator.js');
-                const configured = await configureClaudeKeybindings();
-                if (configured) {
-                    await gs.updateGlobalConfig({ keybindingsConfigured: true });
-                }
-            }
-        }
-        catch {
-            /* best-effort */
-        }
-    })();
     // SPEC-334: Sync planu/ YAML frontmatter status → data/ store (non-blocking)
     scheduleStartupStateRecovery(startupSync, recoverPendingPostCommitTasksAtStartup);
     // SPEC-1271: bounded, fair, durable spec.created outbox recovery — fire-and-forget so a

package/dist/resources/process.js

@@ -16,90 +16,63 @@ function getSddProcess() {
             {
                 id: 'initializing',
                 name: '1. Initialize',
-                tools: ['init_project', 'init_constitution', 'detect_agent'],
-                description: 'Detect project language, framework, architecture, and conventions. ' +
-                    'Generate the project constitution. Detect the AI agent platform in use.',
+                tools: ['init_project'],
+                description: 'Load or bootstrap the Planu project context for the current repository.',
             },
             {
-                id: 'analyzing',
-                name: '2. Analyze',
-                tools: [
-                    'clarify_requirements',
-                    'suggest_stack',
-                    'check_versions',
-                    'consult_docs',
-                    'discover_mcps',
-                    'suggest_mcps',
-                    'suggest_tooling',
-                ],
-                description: 'Clarify requirements, analyze the stack, check dependency versions, ' +
-                    'discover available MCP servers, and assess dev lifecycle tooling.',
-            },
-            {
-                id: 'creating-spec',
-                name: '3. Create Spec',
-                tools: ['create_spec', 'reverse_engineer', 'estimate'],
-                description: 'Create a full SDD spec.md from requirements or ' +
-                    'reverse-engineer from existing code. Estimate effort, cost, and tokens.',
+                id: 'defining',
+                name: '2. Define',
+                tools: ['facilitate', 'create_spec'],
+                description: 'Facilitate requirements discovery through the universal SDD entry point, ' +
+                    'then create the spec.md that becomes the contract for implementation.',
             },
             {
-                id: 'filtering',
-                name: '4. Filter & Enrich',
+                id: 'approving',
+                name: '3. Refine & Approve',
                 tools: [
-                    'generate_adr',
-                    'design_schema',
-                    'define_ui_contract',
                     'challenge_spec',
-                    'generate_execution_plan',
-                ],
-                description: 'Enrich the spec with architecture decisions, database schema, UI contracts, ' +
-                    'resilience analysis, and step-by-step execution plans.',
-            },
-            {
-                id: 'reviewing',
-                name: '5. Review',
-                tools: [
-                    'summarize_spec',
-                    'generate_checklist',
-                    'reconcile_spec',
-                    'list_specs',
+                    'check_readiness',
+                    'estimate',
+                    'request_changes',
                     'update_status',
                 ],
-                description: 'Review specs via summaries and checklists. Reconcile with changes. ' +
-                    'Transition spec status through the lifecycle.',
+                description: 'Stress-test the spec, verify it has enough detail to implement, estimate ' +
+                    'effort and cost, request changes if gaps remain, and move the spec through ' +
+                    'draft → review → approved.',
             },
             {
                 id: 'implementing',
-                name: '6. Implement',
-                tools: [
-                    'generate_skill',
-                    'generate_sub_agent',
-                    'generate_rules',
-                    'manage_git',
-                    'manage_context',
-                    'orchestrate',
-                ],
-                description: 'Generate agent skills and rules. Manage git branches and PRs. ' +
-                    'Orchestrate multi-agent workflows. Persist context across sessions.',
+                name: '4. Implement',
+                tools: ['package_handoff', 'bump_spec_version'],
+                description: 'Generate the implementation handoff package for the coding agent and bump ' +
+                    "the spec's SemVer as its contract evolves.",
             },
             {
                 id: 'validating',
-                name: '7. Validate',
-                tools: ['validate', 'detect_drift', 'audit', 'generate_tests'],
-                description: 'Validate implementation against spec. Detect drift. Audit code quality. ' +
-                    'Generate and run test plans.',
+                name: '5. Validate',
+                tools: ['validate', 'get_job', 'restart_job'],
+                description: 'Check the implementation against acceptance criteria, poll the durable ' +
+                    'validation job to completion, and restart it if it fails or is cancelled.',
+            },
+            {
+                id: 'closing',
+                name: '6. Reconcile & Close',
+                tools: ['reconcile_spec', 'migrate_legacy_spec', 'update_status_batch'],
+                description: 'Reconcile implementation drift back into the spec, migrate legacy spec docs ' +
+                    'onto the canonical spec.md, and batch-transition specs to done. Shipping ' +
+                    'runs the local-first release contract (`pnpm check:preflight`, then ' +
+                    '`pnpm release:local`) outside the MCP tool surface.',
             },
             {
-                id: 'documenting',
-                name: '8. Document & Ship',
-                tools: ['generate_docs', 'generate_docs_site', 'integrate_pm', 'learn_pattern'],
-                description: 'Generate documentation, run the local-first release contract ' +
-                    '(`pnpm check:preflight`, `pnpm release:local` when shipping), ' +
-                    'sync with project management tools, and learn patterns for future estimations.',
+                id: 'tracking',
+                name: '7. Track',
+                tools: ['list_specs', 'planu_status', 'session_checkpoint'],
+                description: 'List specs and their status, check overall project health, and persist ' +
+                    'session context so work can resume across sessions.',
             },
         ],
         specLifecycle: ['draft', 'review', 'approved', 'implementing', 'done'],
-        totalTools: 104,
+        totalTools: 19,
     };
 }
 /**

package/dist/storage/session-state-store.js

@@ -31,6 +31,8 @@ export function getStagedFiles(projectPath) {
             cwd: projectPath,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5_000,
+            maxBuffer: 10 * 1024 * 1024,
         });
         return output
             .split('\n')

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

@@ -33,8 +33,8 @@ const CAPABILITY_SIGNALS = {
         /\bbatch\s+upload\b/i,
     ],
     scale: [
-        /\b(?:traffic|load\b(?![\s‐-―-]+bearing)|throughput|requests?\s+per\s+second|concurrent\s+users?)\b/i,
-        /\b(?:auto[ -]?scal|load\s+test|capacity\s+plan)/i,
+        /\b(?:traffic|throughput|requests?\s+per\s+second|concurrent\s+users?)\b/i,
+        /\b(?:auto[ -]?scal|load\s+(?:test|balanc|shedding|envelope|spike)|(?:peak|heavy|normal|sustained|read|write)\s+load|capacity\s+plan)/i,
         /\b(?:data\s+growth|growing\s+dataset|query\s+performance\s+at\s+scale)\b/i,
     ],
     dataWrite: [

package/dist/tools/configure-checkpoint-policy.js

@@ -1,16 +1,16 @@
 // tools/configure-checkpoint-policy.ts — Configure auto checkpoint policy (SPEC-563).
-import { sessionTracker } from '../engine/session/session-tracker.js';
+import { setCheckpointPolicy, getCheckpointPolicy } from '../engine/session/session-tracker.js';
 import { compactResult } from './output-formatter.js';
 /**
  * Handle the configure_checkpoint_policy tool.
  * Updates threshold and/or enabled flag, returns the current policy.
  */
 export function handleConfigureCheckpointPolicy(args) {
-    sessionTracker.setPolicy({
+    setCheckpointPolicy({
         threshold: args.threshold,
         enabled: args.enabled,
     });
-    const policy = sessionTracker.getPolicy();
+    const policy = getCheckpointPolicy();
     return compactResult(`Checkpoint policy updated for ${args.projectPath}.\n` +
         `Threshold: every ${String(policy.threshold)} calls, ` +
         `enabled: ${String(policy.enabled)}.`);

package/dist/tools/create-spec-helpers.js

@@ -26,11 +26,8 @@ export async function tryAutoSetupGit(projectId, specId, options) {
     /* v8 ignore start -- requires real git repo with branches */
     try {
         const r = await handleAutoSetup(projectId, specId, undefined, options);
-        if (!r.isError && r.content[0]?.type === 'text') {
-            const data = JSON.parse(r.content[0].text);
-            if (typeof data.newBranch !== 'string') {
-                return undefined;
-            }
+        const data = r.structuredContent;
+        if (!r.isError && data && typeof data.newBranch === 'string') {
             return { data, branch: data.newBranch };
         }
     }

package/dist/tools/create-spec.js

@@ -20,6 +20,7 @@ import { generateLeanTechnicalContent, } from '../engine/spec-format/lean-techni
 import { extractFilesFromSpecBody, extractMarkerDeclaredPaths, } from '../engine/spec-format/technical-md-populator.js';
 import { buildCanonicalUnifiedSpecContent, containsUnresolvedContractPlaceholder, validateUnifiedSpecCandidate, } from '../engine/spec-format/unified-spec-builder.js';
 import { buildImplementationContractSection } from '../engine/implementation-contract/index.js';
+import { updateFrontmatterField } from '../engine/frontmatter-parser.js';
 import { resolveEnglishOnlySpecGate } from '../engine/spec-language/english-only.js';
 import { FallbackGenerator } from '../engine/spec-generator/index.js';
 import { analyzeProjectForSpec, getEmptyAutopilotResult, } from './create-spec/autopilot-analyzer.js';
@@ -1257,7 +1258,7 @@ async function prepareCreateSpecCandidate(initialParams, server) {
         outOfScope,
         verificationCommands,
     });
-    const unifiedSpec = buildCanonicalUnifiedSpecContent({
+    let unifiedSpec = buildCanonicalUnifiedSpecContent({
         leanSpecBody: leanSpec,
         sourceDescription: params.description,
         technicalBody: leanTechnical,
@@ -1269,12 +1270,18 @@ async function prepareCreateSpecCandidate(initialParams, server) {
     const candidateValidation = validateUnifiedSpecCandidate(unifiedSpec, {
         groundedFilePaths: groundedTechnical.records.map((record) => record.path),
     });
-    if (!candidateValidation.valid) {
+    // SPEC-1435: MISSING_EXECUTABLE_CRITERIA no longer blocks persistence — plain-text
+    // criteria are accepted input today (checkbox items via extractAcceptanceCriteriaTexts),
+    // and the constant GIVEN/WHEN/THEN scaffold that used to satisfy this check has been
+    // retired. The readiness-checker approval gate now blocks a zero-BDD spec at
+    // review -> approved instead; here it downgrades to a persisted quality warning.
+    const blockingCandidateIssues = candidateValidation.issues.filter((issue) => issue.code !== 'MISSING_EXECUTABLE_CRITERIA');
+    if (blockingCandidateIssues.length > 0) {
         return earlyPreparation({
             content: [
                 {
                     type: 'text',
-                    text: `Unified spec candidate is invalid: ${candidateValidation.issues
+                    text: `Unified spec candidate is invalid: ${blockingCandidateIssues
                         .slice(0, 3)
                         .map((issue) => issue.message)
                         .join('; ')}`,
@@ -1285,10 +1292,20 @@ async function prepareCreateSpecCandidate(initialParams, server) {
                 error: 'SPEC_FORMAT_INVALID',
                 code: 422,
                 persisted: false,
-                issues: candidateValidation.issues,
+                issues: blockingCandidateIssues,
             },
         });
     }
+    if (candidateValidation.issues.some((issue) => issue.code === 'MISSING_EXECUTABLE_CRITERIA')) {
+        const nonExecutableCriteriaWarning = 'Acceptance criteria are not executable GIVEN/WHEN/THEN — restate them before approval';
+        spec.qualityWarnings = [
+            ...new Set([...(spec.qualityWarnings ?? []), nonExecutableCriteriaWarning]),
+        ];
+        // unifiedSpec's frontmatter was already serialized from `spec` before this warning was
+        // known — patch the persisted YAML field directly rather than re-serializing the whole
+        // candidate.
+        unifiedSpec = updateFrontmatterField(unifiedSpec, 'qualityWarnings', JSON.stringify(spec.qualityWarnings));
+    }
     const genericOutputGate = checkGenericSpecOutput(unifiedSpec);
     if (!genericOutputGate.passed) {
         return earlyPreparation({

package/dist/tools/facilitate.js

@@ -39,8 +39,8 @@ function buildExistingProjectResponse(description) {
     return (`I'll run a diagnostic on your project.\n\n` +
         `Please provide the project path and call:\n` +
         `- \`init_project\` with your project path (if not yet initialized)\n` +
-        `- \`reverse_engineer\` to analyze the codebase\n` +
-        `- \`audit\` to check spec health\n\n` +
+        `- \`list_specs\` to see existing specs\n` +
+        `- \`planu_status\` to check overall project health\n\n` +
         `Request received: "${description.slice(0, 120)}"`);
 }
 // ---------------------------------------------------------------------------
@@ -51,7 +51,6 @@ const PROBLEM_TO_TOOL = [
     [/validat/i, 'validate', 'validate a spec'],
     [/spec|user stor/i, 'create_spec', 'create a spec/user story'],
     [/estimat/i, 'estimate', 'estimate effort and cost'],
-    [/test/i, 'generate_tests', 'generate tests'],
     [/document|doc/i, 'generate_docs', 'generate documentation'],
     [/drift|diverge/i, 'detect_drift', 'detect spec drift'],
     [/schema|database|db/i, 'design_schema', 'design a database schema'],
@@ -69,10 +68,8 @@ function buildConcreteProblemResponse(description) {
     }
     return (`I can help with that! Here are the most relevant Planu tools:\n\n` +
         `- \`create_spec\` — write a new user story / spec\n` +
-        `- \`clarify_requirements\` — clarify vague requirements\n` +
         `- \`estimate\` — estimate effort and cost\n` +
-        `- \`validate\` — check if a spec is complete\n` +
-        `- \`generate_tests\` — generate test scaffolds\n\n` +
+        `- \`validate\` — check if a spec is complete\n\n` +
         `What specifically would you like to do?`);
 }
 // ---------------------------------------------------------------------------

package/dist/tools/git/branch-ops.js

@@ -54,7 +54,10 @@ export async function handleCreateBranch(projectId, specId, config, resolvedProj
                     ? `Switched to existing branch '${branchName}'`
                     : `Branch '${branchName}' already exists (checkout left untouched)`,
             };
-            return compactResult(formatKeyValue(result));
+            return {
+                ...compactResult(formatKeyValue(result)),
+                structuredContent: result,
+            };
         }
     }
     catch {
@@ -74,7 +77,10 @@ export async function handleCreateBranch(projectId, specId, config, resolvedProj
         branchName,
         message: ti('tools.manage_git.success', { action: 'create-branch' }),
     };
-    return compactResult(formatKeyValue(result));
+    return {
+        ...compactResult(formatKeyValue(result)),
+        structuredContent: result,
+    };
 }
 export async function handleCheckBranch(projectId, _specId, config) {
     const projectPath = await resolveProjectPath(projectId);
@@ -217,7 +223,10 @@ export async function handleAutoSetup(projectId, specId, config, options) {
                     ? `Switched to existing branch '${branchName}' (${gitFlowType} workflow detected)`
                     : `Branch '${branchName}' already exists (checkout left untouched)`,
             };
-            return compactResult(formatKeyValue(result));
+            return {
+                ...compactResult(formatKeyValue(result)),
+                structuredContent: result,
+            };
         }
     }
     catch {
@@ -235,7 +244,10 @@ export async function handleAutoSetup(projectId, specId, config, options) {
             ? `Created branch '${branchName}' from '${baseBranch}' (${gitFlowType} workflow detected)`
             : `Created branch '${branchName}' from '${baseBranch}' without switching the checkout`,
     };
-    return compactResult(formatKeyValue(result));
+    return {
+        ...compactResult(formatKeyValue(result)),
+        structuredContent: result,
+    };
 }
 // ---------------------------------------------------------------------------
 // Worktree operations (SPEC-260)

package/dist/tools/github-release-handler.js

@@ -252,26 +252,7 @@ export async function handleCreateRelease(args, exec = defaultExec) {
             /* best-effort — release_completed cascade never blocks the release response */
         }
     })();
-    // SPEC-1003: Auto-merge develop to main after release (best-effort)
-    void (async () => {
-        try {
-            const releasePath = process.cwd();
-            const run = promisify(nodeExecFile);
-            const { stdout: currentBranch } = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd: releasePath,
-            });
-            if (currentBranch.trim() === 'develop') {
-                await run('git', ['checkout', 'main'], { cwd: releasePath });
-                await run('git', ['merge', 'develop', '--no-edit'], { cwd: releasePath });
-                await run('git', ['push', '--no-verify', 'origin', 'main'], { cwd: releasePath });
-                await run('git', ['checkout', 'develop'], { cwd: releasePath });
-                outputLines.push('  Auto-merge: develop → main');
-            }
-        }
-        catch {
-            /* best-effort — auto-merge never blocks release */
-        }
-    })();
+    outputLines.push('  Mirror sync (run manually if develop exists): git checkout develop && git merge --ff-only origin/main && git push origin develop');
     return {
         content: [
             {

package/dist/tools/init-project/agents-md-writer.js

@@ -34,13 +34,13 @@ Auto-generated by \`init_project\`. Mirrors CLAUDE.md for IDEs that read AGENTS.
 \`\`\`
 facilitate("what to build") → create_spec → challenge_spec → check_readiness
 → update_status(review) → approve → update_status(approved) → implement
-→ validate (ack) → watch_job (completed) → inspect job.result → update_status(done)
+→ validate (ack) → get_job (poll until completed) → inspect job.result → update_status(done)
 \`\`\`
 
 ## Durable Validation Gate
 
-1. Call \`validate\` and capture \`operationId\`, \`projectId\`, \`workspaceId\`, and \`cursor\` from the acknowledgement
-2. Call \`watch_job\` with those identifiers and the latest cursor until the job reaches a terminal state
+1. Call \`validate\` and capture \`operationId\`, \`projectId\`, and \`workspaceId\` from the acknowledgement
+2. Poll \`get_job\` with those identifiers until the job reaches a terminal state
 3. Require \`completed\` and inspect \`job.result.structuredContent\`; stop on \`failed\`, \`dead-letter\`, or \`cancelled\`
 4. Call \`update_status(done)\` only when the completed result reports \`ready: true\`, \`status: "passing"\`, and passing quality gates
 
@@ -52,7 +52,7 @@ facilitate("what to build") → create_spec → challenge_spec → check_readine
 ## Session End
 
 - Call \`session_checkpoint\` to save context
-- Run \`validate\`, await the completed job with \`watch_job\`, inspect \`job.result.structuredContent\`, then call \`update_status(done)\`
+- Run \`validate\`, poll \`get_job\` until completed, inspect \`job.result.structuredContent\`, then call \`update_status(done)\`
 
 ## Quick Reference
 
@@ -79,7 +79,7 @@ Auto-generated by init_project.
 1. Before writing any code, call facilitate() or create_spec() first.
 2. Never write code without an approved Planu spec.
 3. Always call validate() after implementation; it returns a durable job acknowledgement, not pass/fail.
-4. Call watch_job() until completed and inspect job.result.structuredContent before marking done.
+4. Poll get_job() until completed and inspect job.result.structuredContent before marking done.
 5. Use update_status() to track progress: draft → review → approved → implementing → done.
 
 ## Session
@@ -91,7 +91,7 @@ Auto-generated by init_project.
 
 - New feature: facilitate("what to build")
 - Check status: planu_status
-- Mark done: validate, watch_job until completed, inspect job.result.structuredContent, then update_status(done)
+- Mark done: validate, poll get_job until completed, inspect job.result.structuredContent, then update_status(done)
 `;
 async function writeIfMissing(path, content) {
     try {