@planu/cli 5.3.62 → 5.3.64

package/CHANGELOG.md

@@ -1,3 +1,55 @@
+## [5.3.64] - 2026-08-27
+
+### Bug Fixes
+- fix(SPEC-1264): merge shared implementation-review adapter with arbitrated fixes
+- fix(SPEC-1257): merge post-transition observability drain with arbitrated fixes
+- fix(SPEC-1264): apply arbitrated dual-review fixes
+- fix(SPEC-1294): merge grounded execution plans with arbitrated dual-review fixes
+- fix(SPEC-1294): apply arbitrated dual-review fixes
+- fix(SPEC-1264): unify implementation-review verification behind one shared adapter
+- fix(SPEC-1257): isolate postcommit and cascade launches from request scope, drain on stdio shutdown
+- fix(SPEC-1329): merge grounded challenge capability gates with review fix round
+- fix(SPEC-1329): widen outbound-call detection and drop narrative comments
+- fix(SPEC-1294): ground execution plans in approved contract and preserve foreign plans
+- fix(SPEC-1329): gate challenge templates on positive capability evidence
+- fix(SPEC-1301): route every CLI json-mode result through one shared writer
+- fix(SPEC-1652): reject title-less create_spec input before path redaction
+- fix(SPEC-1301): emit one structured JSON document in CLI global json mode
+
+### Chores
+- chore(SPEC-1257): record implementing transition
+- chore(SPEC-1329): record implementing transition
+- chore(planu): record SPEC-1652 and SPEC-1301 done transitions
+- chore(SPEC-1294): record implementing transition
+- chore(SPEC-1294): record approval transition
+- chore(planu): move SPEC-1652 and SPEC-1301 to implementing
+- chore(planu): approve SPEC-1652 and discard SPEC-1653 with codex evidence
+- chore(planu): rescope SPEC-1652 after dual review and file SPEC-1654 dogfood bug
+
+
+## [5.3.63] - 2026-08-27
+
+### Bug Fixes
+- fix(SPEC-1644): stop emitting the default architecture rule and every line-cap instruction
+- fix(SPEC-1643): remove the empty typescript-patterns builtin skill
+- fix(SPEC-1371): compute branch cleanup against main with literal protected matching
+- fix(SPEC-1646): discriminate contradiction findings by offending criterion
+- fix(SPEC-1646): discriminate contradiction findings by offending criterion
+- fix(SPEC-1645): widen the load-bearing separator class per dual review
+- fix(SPEC-1645): stop treating load-bearing as a scale signal
+
+### Chores
+- chore(planu): file goal stop-hook loop dogfood bug
+- chore(SPEC-1644): record done transition
+- chore(planu): file SPEC-1651 and SPEC-1652 dogfood bugs
+- chore(SPEC-1644): record approved status
+- chore(SPEC-1643): mark acceptance criteria done
+- chore(SPEC-1643): lifecycle transition to approved
+- chore(planu): record SPEC-1371 approval and SPEC-1649 filing
+- chore(SPEC-1646): record approval transition
+- chore(SPEC-1645): record done transition
+
+
 ## [5.3.62] - 2026-08-26
 
 ### Bug Fixes

package/dist/.planu-build.json

@@ -1 +1 @@
-{"schemaVersion":1,"commit":"653317c22ebdf21ad6b7f82f5d86dd042b05aaab"}
+{"schemaVersion":1,"commit":"eb49b07b8d2c6ae54132af679fc3319180bab2b8"}

package/dist/cli/commands/create.js

@@ -2,8 +2,8 @@
 import { parseArgs } from 'node:util';
 import { resolve } from 'node:path';
 import { handleCreateSpec } from '../../tools/create-spec.js';
-import { formatToolResult } from '../formatter.js';
-import { green, red } from '../colors.js';
+import { writeCliResult } from '../formatter.js';
+import { red } from '../colors.js';
 export const createCommand = {
     name: 'create',
     description: 'Create a new spec',
@@ -39,20 +39,7 @@ export const createCommand = {
             target: values.target,
             feature: values.feature ?? undefined,
         });
-        if (result.isError) {
-            process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        const output = formatToolResult(result, flags);
-        if (flags?.quiet) {
-            if (output) {
-                process.stdout.write(output + '\n');
-            }
-        }
-        else {
-            process.stdout.write(`${green('Spec created!')} ${output}\n`);
-        }
+        writeCliResult(result, flags, 'Spec created!');
     },
 };
 //# sourceMappingURL=create.js.map

package/dist/cli/commands/dashboard.js

@@ -1,8 +1,7 @@
 // cli/commands/dashboard.ts — planu dashboard [--port 5050] (SPEC-124)
 import { parseArgs } from 'node:util';
 import { handleStartDashboard } from '../../tools/dashboard.js';
-import { formatToolResult } from '../formatter.js';
-import { green, red } from '../colors.js';
+import { writeCliResult } from '../formatter.js';
 export const dashboardCommand = {
     name: 'dashboard',
     description: 'Start the Planu dashboard',
@@ -18,20 +17,7 @@ export const dashboardCommand = {
         });
         const port = values.port ? Number(values.port) : undefined;
         const result = await handleStartDashboard({ port });
-        if (result.isError) {
-            process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        const output = formatToolResult(result, flags);
-        if (flags?.quiet) {
-            if (output) {
-                process.stdout.write(output + '\n');
-            }
-        }
-        else {
-            process.stdout.write(`${green('Dashboard started!')} ${output}\n`);
-        }
+        writeCliResult(result, flags, 'Dashboard started!');
     },
 };
 //# sourceMappingURL=dashboard.js.map

package/dist/cli/commands/init.js

@@ -2,8 +2,7 @@
 import { parseArgs } from 'node:util';
 import { resolve } from 'node:path';
 import { handleInitProject } from '../../tools/init-project.js';
-import { formatToolResult } from '../formatter.js';
-import { green, red } from '../colors.js';
+import { writeCliResult } from '../formatter.js';
 export const initCommand = {
     name: 'init',
     description: 'Initialize a project for Planu',
@@ -32,20 +31,7 @@ export const initCommand = {
             experienceLevel: experienceLevel,
             userProfile: userProfile,
         });
-        if (result.isError) {
-            process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        const output = formatToolResult(result, flags);
-        if (flags?.quiet) {
-            if (output) {
-                process.stdout.write(output + '\n');
-            }
-        }
-        else {
-            process.stdout.write(`${green('Project initialized!')} ${output}\n`);
-        }
+        writeCliResult(result, flags, 'Project initialized!');
     },
 };
 //# sourceMappingURL=init.js.map

package/dist/cli/commands/spec.js

@@ -13,9 +13,9 @@ import { handleListSpecs } from '../../tools/list-specs.js';
 import { handleUpdateStatus } from '../../tools/update-status.js';
 import { handleUpdateStatusBatch } from '../../tools/update-status/batch.js';
 import { handleValidate } from '../../tools/validate.js';
-import { formatToolResult } from '../formatter.js';
+import { formatToolResult, writeCliResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
-import { bold, cyan, green, red, dim } from '../colors.js';
+import { bold, cyan, red, dim } from '../colors.js';
 import { SINGLE_STATUS_PARSE_OPTIONS, buildSingleStatusInput } from './status.js';
 // ---------------------------------------------------------------------------
 // Helpers
@@ -107,20 +107,7 @@ async function runCreate(args, flags) {
         target: values.target,
         feature: values.feature ?? undefined,
     });
-    if (result.isError) {
-        process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const output = formatToolResult(result, flags);
-    if (flags?.quiet) {
-        if (output) {
-            process.stdout.write(output + '\n');
-        }
-    }
-    else {
-        process.stdout.write(`${green('Spec created!')} ${output}\n`);
-    }
+    writeCliResult(result, flags, 'Spec created!');
 }
 // ---------------------------------------------------------------------------
 // Subcommand: spec list
@@ -246,32 +233,14 @@ async function runStatus(args, flags) {
             status: status,
             reviewNotes: values.notes ?? undefined,
         });
-        if (result.isError) {
-            process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        process.stdout.write(formatToolResult(result, flags) + '\n');
+        writeCliResult(result, flags);
         return;
     }
     const result = await handleUpdateStatus({
         ...buildSingleStatusInput(values, specId, projectId, status),
         implementationReviewDigest: values['implementation-review-digest'] ?? undefined,
     });
-    if (result.isError) {
-        process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const output = formatToolResult(result, flags);
-    if (flags?.quiet) {
-        if (output) {
-            process.stdout.write(output + '\n');
-        }
-    }
-    else {
-        process.stdout.write(`${green('Status updated!')} ${output}\n`);
-    }
+    writeCliResult(result, flags, 'Status updated!');
 }
 // ---------------------------------------------------------------------------
 // Exported command

package/dist/cli/commands/status.js

@@ -4,9 +4,9 @@ import { resolve } from 'node:path';
 import { handleUpdateStatus } from '../../tools/update-status.js';
 import { handleUpdateStatusBatch } from '../../tools/update-status/batch.js';
 import { handlePlanStatus } from '../../tools/status-handler.js';
-import { formatToolResult } from '../formatter.js';
+import { writeCliResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
-import { red, green } from '../colors.js';
+import { red } from '../colors.js';
 export const statusCommand = {
     name: 'status',
     description: 'Show project status or update the status of a spec',
@@ -92,15 +92,7 @@ async function runProjectStatus(values, flags) {
         projectPath: values['project-path'] ?? process.cwd(),
         projectId: values['project-id'],
     });
-    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`);
-    }
+    writeCliResult(result, flags);
 }
 function writeUsageError(message) {
     process.stderr.write(`${red('Error:')} ${message}\nUsage: ${statusCommand.usage}\n`);
@@ -112,25 +104,10 @@ async function runBatchStatus(specIds, values, status, flags) {
         status: status,
         reviewNotes: values.notes,
     });
-    writeToolResult(result, flags, false);
+    writeCliResult(result, flags);
 }
 async function runSingleStatus(specId, values, status, flags) {
     const result = await handleUpdateStatus(buildSingleStatusInput(values, specId, values['project-id'] ?? detectProjectId(), status));
-    writeToolResult(result, flags, true);
-}
-function writeToolResult(result, flags, includeSuccessPrefix) {
-    if (result.isError) {
-        process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const output = formatToolResult(result, flags);
-    if (flags?.quiet) {
-        if (output) {
-            process.stdout.write(`${output}\n`);
-        }
-        return;
-    }
-    process.stdout.write(includeSuccessPrefix ? `${green('Status updated!')} ${output}\n` : `${output}\n`);
+    writeCliResult(result, flags, 'Status updated!');
 }
 //# sourceMappingURL=status.js.map

package/dist/cli/formatter.d.ts

@@ -3,11 +3,17 @@ import type { GlobalFlags } from '../types/cli.js';
 /**
  * Format a ToolResult for terminal display.
  * Parses JSON text content when possible, otherwise returns raw text.
- * Respects global flags: --json for raw JSON, --quiet returns empty string.
+ * Respects global flags: --json for one structured JSON document, --quiet returns empty string.
  */
 export declare function formatToolResult(result: ToolResult, options?: {
     json?: boolean;
 } | GlobalFlags): string;
+/**
+ * Write a ToolResult to stdout/stderr, owning quiet/json precedence, error
+ * routing, and the human success prefix. In json mode stdout carries exactly
+ * one JSON document — no prefix, no ANSI.
+ */
+export declare function writeCliResult(result: ToolResult, flags: GlobalFlags | undefined, successPrefix?: string): void;
 /**
  * Render an ASCII table with column alignment.
  */

package/dist/cli/formatter.js

@@ -1,20 +1,19 @@
 // cli/formatter.ts — Convert MCP ToolResult to terminal output (SPEC-124)
+import { green, red } from './colors.js';
 /**
  * Format a ToolResult for terminal display.
  * Parses JSON text content when possible, otherwise returns raw text.
- * Respects global flags: --json for raw JSON, --quiet returns empty string.
+ * Respects global flags: --json for one structured JSON document, --quiet returns empty string.
  */
 export function formatToolResult(result, options) {
     if (options && 'quiet' in options && options.quiet) {
         return '';
     }
-    const useJson = options?.json;
+    if (options?.json) {
+        return JSON.stringify(resolveJsonValue(result));
+    }
     const parts = [];
     for (const item of result.content) {
-        if (useJson) {
-            parts.push(item.text);
-            continue;
-        }
         // Try to parse as JSON for prettier output
         try {
             const parsed = JSON.parse(item.text);
@@ -31,6 +30,50 @@ export function formatToolResult(result, options) {
     }
     return parts.join('\n');
 }
+function resolveJsonValue(result) {
+    if (result.structuredContent !== undefined) {
+        return result.structuredContent;
+    }
+    if (result.content.length === 1) {
+        const parsed = tryParseJson(result.content[0].text);
+        if (parsed !== undefined) {
+            return parsed;
+        }
+    }
+    const envelope = {
+        content: result.content.map((item) => tryParseJson(item.text) ?? item.text),
+    };
+    return envelope;
+}
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write a ToolResult to stdout/stderr, owning quiet/json precedence, error
+ * routing, and the human success prefix. In json mode stdout carries exactly
+ * one JSON document — no prefix, no ANSI.
+ */
+export function writeCliResult(result, flags, successPrefix) {
+    if (result.isError) {
+        const message = formatToolResult(result, flags);
+        process.stderr.write(`${flags?.json ? message : red(message)}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const output = formatToolResult(result, flags);
+    if (flags?.quiet || flags?.json) {
+        if (output) {
+            process.stdout.write(`${output}\n`);
+        }
+        return;
+    }
+    process.stdout.write(successPrefix ? `${green(successPrefix)} ${output}\n` : `${output}\n`);
+}
 function formatObject(obj, indent = 0) {
     const prefix = ' '.repeat(indent);
     const lines = [];

package/dist/engine/cascade-hooks/hooks/implementing-kickoff.hook.js

@@ -1,14 +1,46 @@
+import { appendAutopilotLogEntry } from '../../../storage/autopilot-log-store.js';
+import { hashProjectPath } from '../../../storage/base-store.js';
+function logExecutionPlanOutcome(projectPath, entry) {
+    try {
+        void appendAutopilotLogEntry(hashProjectPath(projectPath), entry);
+    }
+    catch {
+        return;
+    }
+}
+async function fireExecutionPlan(projectPath, projectId, specId) {
+    const start = Date.now();
+    try {
+        const { handleGenerateExecutionPlan } = await import('../../../tools/generate-execution-plan.js');
+        const result = await handleGenerateExecutionPlan({ specId, projectId });
+        logExecutionPlanOutcome(projectPath, {
+            specId,
+            hookName: 'implementing-kickoff-execution-plan',
+            result: result.isError ? 'fail' : 'pass',
+            ...(result.isError
+                ? { error: result.content[0]?.text ?? 'execution plan generation failed' }
+                : {}),
+            timestamp: new Date().toISOString(),
+            durationMs: Date.now() - start,
+        });
+    }
+    catch (err) {
+        logExecutionPlanOutcome(projectPath, {
+            specId,
+            hookName: 'implementing-kickoff-execution-plan',
+            result: 'fail',
+            error: err instanceof Error ? err.message : String(err),
+            timestamp: new Date().toISOString(),
+            durationMs: Date.now() - start,
+        });
+    }
+}
 async function handler(ctx) {
     const { projectPath, projectId, specId } = ctx;
     if (!projectPath) {
         return;
     }
-    // Sub-task 1: generate execution plan (fire-and-forget)
-    await import('../../../tools/generate-execution-plan.js')
-        .then(({ handleGenerateExecutionPlan }) => handleGenerateExecutionPlan({ specId, projectId }))
-        .catch(() => {
-        /* best-effort */
-    });
+    await fireExecutionPlan(projectPath, projectId, specId);
     // Sub-task 2: fire TDD scaffold via complete-loop (fire-and-forget)
     await import('../../../engine/autopilot/complete-loop.js')
         .then(({ fireAutoScaffoldTdd }) => {

package/dist/engine/dor-dod/index.d.ts

@@ -1,4 +1,4 @@
 export { generateDoR, validateDoR, addCustomDoRItem, enrichDoRWithLearning } from './dor.js';
 export { generateDoD, validateDoD, addCustomDoDItem } from './dod.js';
-export { generatePlanMarkdown } from './plan.js';
+export { generatePlanMarkdown, EXECUTION_PLAN_MARKER } from './plan.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/dor-dod/index.js

@@ -1,5 +1,5 @@
 // dor-dod/index.ts — Barrel re-export for DoR/DoD engine
 export { generateDoR, validateDoR, addCustomDoRItem, enrichDoRWithLearning } from './dor.js';
 export { generateDoD, validateDoD, addCustomDoDItem } from './dod.js';
-export { generatePlanMarkdown } from './plan.js';
+export { generatePlanMarkdown, EXECUTION_PLAN_MARKER } from './plan.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/dor-dod/plan.d.ts

@@ -1,4 +1,5 @@
 import type { Spec, ExecutionPlan } from '../../types/index.js';
+export declare const EXECUTION_PLAN_MARKER = "<!-- planu:execution-plan -->";
 /**
  * Generate a PLAN.md markdown string from an ExecutionPlan.
  * Includes RED/GREEN/VERIFY cycles, [P] markers for parallelizable steps,

package/dist/engine/dor-dod/plan.js

@@ -1,3 +1,4 @@
+export const EXECUTION_PLAN_MARKER = '<!-- planu:execution-plan -->';
 /**
  * Generate a PLAN.md markdown string from an ExecutionPlan.
  * Includes RED/GREEN/VERIFY cycles, [P] markers for parallelizable steps,
@@ -7,6 +8,7 @@ export function generatePlanMarkdown(plan, spec) {
     const totalMinutes = plan.phases.reduce((sum, ph) => sum + ph.steps.reduce((s, st) => s + st.estimatedMinutes, 0), 0);
     const estimatedHours = Math.round((totalMinutes / 60) * 10) / 10;
     const lines = [
+        EXECUTION_PLAN_MARKER,
         `# PLAN.md — ${spec.title}`,
         '',
         `> **Spec**: ${spec.id} | **Status**: ${spec.status} | **Generated**: ${new Date().toISOString()}`,

package/dist/engine/evidence-gates/artifact-reader.js

@@ -64,6 +64,7 @@ const TaskPlanSchema = z
     .object({
     version: z.literal(1),
     provenance: ProvenanceSchema.optional(),
+    generatedBy: z.literal('planu-evidence-skeleton').optional(),
     tasks: z
         .array(z
         .object({

package/dist/engine/evidence-gates/evidence-skeletons.js

@@ -54,6 +54,7 @@ export function generateTaskPlanSkeleton(args) {
     const criteria = args.criteria.length > 0 ? args.criteria : ['Implementation satisfies the approved spec.'];
     return {
         version: 1,
+        generatedBy: 'planu-evidence-skeleton',
         tasks: criteria.map((criterion, index) => ({
             id: `AC-${String(index + 1)}`,
             title: criterion.length > 500 ? `${criterion.slice(0, 497)}...` : criterion,

package/dist/engine/execution-plan/plan-utils.d.ts

@@ -1,10 +1,6 @@
-import type { ExecutionPhase, Spec, ProjectKnowledge } from '../../types/index.js';
+import type { ExecutionPhase, ExecutionPlanGraphViolation, Spec } from '../../types/index.js';
+export declare function validateExecutionPlanGraph(phases: ExecutionPhase[]): ExecutionPlanGraphViolation[];
 export declare function determineCriticalPath(phases: ExecutionPhase[]): string[];
 export declare function findParallelizable(phases: ExecutionPhase[]): string[][];
-export declare function inferDataLayerFiles(spec: Spec, knowledge: ProjectKnowledge): string[];
-export declare function inferServiceFiles(spec: Spec, knowledge: ProjectKnowledge): string[];
-export declare function inferApiFiles(spec: Spec, knowledge: ProjectKnowledge): string[];
-export declare function inferPageFiles(spec: Spec, knowledge: ProjectKnowledge): string[];
-export declare function inferComponentFiles(spec: Spec, knowledge: ProjectKnowledge): string[];
 export declare function readSpecContent(spec: Spec): Promise<string>;
 //# sourceMappingURL=plan-utils.d.ts.map

package/dist/engine/execution-plan/plan-utils.js

@@ -1,8 +1,76 @@
-import { technologyValue } from '../technology-registry.js';
-// engine/execution-plan/plan-utils.ts — Utilities for execution plan generation
-// Critical path analysis, parallelization detection, and file inference helpers.
 import { readFile } from 'node:fs/promises';
 import { readSpecTechnicalSection } from '../spec-format/read-technical-section.js';
+function findStepDependencyCycle(steps) {
+    const dependsOnByOrder = new Map(steps.map((step) => [step.order, step.dependsOn]));
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    function visit(order) {
+        if (visited.has(order)) {
+            return null;
+        }
+        if (visiting.has(order)) {
+            const cycleStart = stack.indexOf(order);
+            return [...stack.slice(cycleStart), order];
+        }
+        visiting.add(order);
+        stack.push(order);
+        for (const dep of dependsOnByOrder.get(order) ?? []) {
+            const cycle = visit(dep);
+            if (cycle) {
+                return cycle;
+            }
+        }
+        stack.pop();
+        visiting.delete(order);
+        visited.add(order);
+        return null;
+    }
+    for (const order of dependsOnByOrder.keys()) {
+        const cycle = visit(order);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    return null;
+}
+export function validateExecutionPlanGraph(phases) {
+    const steps = phases.flatMap((phase) => phase.steps);
+    const orders = new Set(steps.map((step) => step.order));
+    const violations = [];
+    for (const step of steps) {
+        for (const dep of step.dependsOn) {
+            if (!Number.isInteger(dep) || dep < 1) {
+                violations.push({
+                    code: 'INVALID_STEP_DEPENDENCY',
+                    message: `Step ${step.order} declares a non-integer or non-positive dependency (${dep}).`,
+                });
+            }
+            else if (dep === step.order) {
+                violations.push({
+                    code: 'SELF_DEPENDENT_STEP',
+                    message: `Step ${step.order} depends on itself.`,
+                });
+            }
+            else if (!orders.has(dep)) {
+                violations.push({
+                    code: 'INVALID_STEP_DEPENDENCY',
+                    message: `Step ${step.order} depends on non-existent step ${dep}.`,
+                });
+            }
+        }
+    }
+    if (violations.length === 0) {
+        const cycle = findStepDependencyCycle(steps);
+        if (cycle) {
+            violations.push({
+                code: 'CYCLIC_STEP_DEPENDENCIES',
+                message: `Cyclic step dependency: ${cycle.join(' -> ')}.`,
+            });
+        }
+    }
+    return violations;
+}
 // --- Critical path & parallelization ---
 export function determineCriticalPath(phases) {
     const path = [];
@@ -35,40 +103,6 @@ export function findParallelizable(phases) {
     }
     return groups;
 }
-// --- File inference helpers (SRP: each infers one type of file) ---
-export function inferDataLayerFiles(spec, knowledge) {
-    const base = knowledge.architecture.layers.find((l) => l.name === 'infrastructure')?.directories[0] ?? 'src';
-    return [`${base}/${spec.slug}-repository.ts`];
-}
-export function inferServiceFiles(spec, knowledge) {
-    const base = knowledge.architecture.layers.find((l) => l.name === 'application')?.directories[0] ?? 'src';
-    return [`${base}/${spec.slug}-service.ts`];
-}
-export function inferApiFiles(spec, knowledge) {
-    const firstContract = knowledge.apiContracts[0];
-    const apiType = firstContract ? firstContract.type : 'rest';
-    const base = apiType === technologyValue('technology-trpc-7a75ed') ? 'src/server/routers' : 'src/routes';
-    return [`${base}/${spec.slug}.ts`];
-}
-export function inferPageFiles(spec, knowledge) {
-    const framework = (knowledge.framework ?? '').toLowerCase();
-    if (framework.includes('next')) {
-        return [`app/${spec.slug}/page.tsx`];
-    }
-    if (framework.includes(technologyValue('technology-nuxt-22c407'))) {
-        return [`pages/${spec.slug}.vue`];
-    }
-    return [`src/pages/${spec.slug}.tsx`];
-}
-export function inferComponentFiles(spec, knowledge) {
-    const ext = (knowledge.framework ?? '')
-        .toLowerCase()
-        .includes(technologyValue('technology-vue-564382'))
-        ? technologyValue('technology-vue-564382')
-        : 'tsx';
-    return [`src/components/${spec.slug}/${spec.slug}.${ext}`];
-}
-// --- Spec content reader ---
 export async function readSpecContent(spec) {
     let content = `${spec.title} ${spec.type} ${spec.scope} ${spec.target} ${spec.tags.join(' ')}`;
     try {

package/dist/engine/handoff-artifacts/implementation-review-reader.d.ts

@@ -0,0 +1,4 @@
+import type { VerifiedImplementationReviewResult } from '../../types/index.js';
+export declare function isLifecycleStubBody(specId: string, body: string): boolean;
+export declare function readVerifiedImplementationReview(projectId: string, specId: string): Promise<VerifiedImplementationReviewResult>;
+//# sourceMappingURL=implementation-review-reader.d.ts.map