@shepai/cli 1.19.0 → 1.20.0

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-graph.js

@@ -5,15 +5,112 @@ import { createRequirementsNode } from './nodes/requirements.node.js';
 import { createResearchNode } from './nodes/research.node.js';
 import { createPlanNode } from './nodes/plan.node.js';
 import { createImplementNode } from './nodes/implement.node.js';
+import { createValidateNode } from './nodes/validate.node.js';
+import { createRepairNode } from './nodes/repair.node.js';
+import { validateSpecAnalyze, validateSpecRequirements } from './nodes/schemas/spec.schema.js';
+import { validateResearch } from './nodes/schemas/research.schema.js';
+import { validatePlan, validateTasks } from './nodes/schemas/plan.schema.js';
+import { readSpecFile, safeYamlLoad, createNodeLogger } from './nodes/node-helpers.js';
 // Re-export state types for consumers
 export { FeatureAgentAnnotation } from './state.js';
+/**
+ * Factory that creates a conditional edge function for validation routing.
+ *
+ * Routes to successNode on pass, repairNode on fail, throws after maxRetries.
+ */
+function routeValidation(successNode, repairNode, maxRetries = 3) {
+    return (state) => {
+        if (state.lastValidationErrors.length === 0)
+            return successNode;
+        if (state.validationRetries >= maxRetries) {
+            throw new Error(`Validation failed after ${maxRetries} repair attempts for '${state.lastValidationTarget}': ${state.lastValidationErrors.join('; ')}`);
+        }
+        return repairNode;
+    };
+}
+/**
+ * Creates a combined plan+tasks validator node.
+ *
+ * Validates plan.yaml first, then tasks.yaml with cross-referencing
+ * of phaseIds from the plan. Combines all errors.
+ */
+function createPlanTasksValidator() {
+    const log = createNodeLogger('validate:plan+tasks');
+    return async (state) => {
+        log.info('Validating plan.yaml and tasks.yaml');
+        const allErrors = [];
+        // Validate plan.yaml
+        const planContent = readSpecFile(state.specDir, 'plan.yaml');
+        if (!planContent) {
+            allErrors.push("File 'plan.yaml' not found or empty");
+        }
+        else {
+            try {
+                const planData = safeYamlLoad(planContent);
+                const planResult = validatePlan(planData);
+                allErrors.push(...planResult.errors);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                allErrors.push(`YAML parse error in plan.yaml: ${msg}`);
+            }
+        }
+        // Validate tasks.yaml with cross-reference
+        const tasksContent = readSpecFile(state.specDir, 'tasks.yaml');
+        if (!tasksContent) {
+            allErrors.push("File 'tasks.yaml' not found or empty");
+        }
+        else {
+            try {
+                const tasksData = safeYamlLoad(tasksContent);
+                // Extract phaseIds from plan for cross-validation
+                let phaseIds = [];
+                if (planContent) {
+                    try {
+                        const planData = safeYamlLoad(planContent);
+                        const phases = Array.isArray(planData?.phases) ? planData.phases : [];
+                        phaseIds = phases
+                            .filter((p) => typeof p?.id === 'string')
+                            .map((p) => p.id);
+                    }
+                    catch {
+                        // Plan parse already reported above
+                    }
+                }
+                const tasksResult = validateTasks(tasksData, phaseIds);
+                allErrors.push(...tasksResult.errors);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                allErrors.push(`YAML parse error in tasks.yaml: ${msg}`);
+            }
+        }
+        if (allErrors.length === 0) {
+            log.info('Validation passed');
+            return {
+                lastValidationTarget: 'plan.yaml+tasks.yaml',
+                lastValidationErrors: [],
+                validationRetries: 0,
+                messages: ['[validate:plan+tasks] PASS'],
+            };
+        }
+        log.error(`Validation failed: ${allErrors.join('; ')}`);
+        return {
+            lastValidationTarget: 'plan.yaml+tasks.yaml',
+            lastValidationErrors: allErrors,
+            validationRetries: state.validationRetries + 1,
+            messages: [`[validate:plan+tasks] FAIL: ${allErrors.length} error(s)`],
+        };
+    };
+}
 /**
  * Factory function that creates and compiles the feature-agent LangGraph.
  *
- * The graph defines a linear SDLC workflow:
- *   analyze → requirements → research → plan → implement
+ * The graph defines a linear SDLC workflow with validation gates:
+ *   analyze → validate → requirements → validate → research → validate → plan → validate → implement
  *
- * Each node delegates work to the injected IAgentExecutor (e.g. Claude Code).
+ * Each YAML-producing node is followed by a validate/repair loop that ensures
+ * the output YAML conforms to its schema before proceeding.
  *
  * @param executor - The agent executor to delegate prompt execution to
  * @param checkpointer - Optional checkpoint saver for state persistence
@@ -21,16 +118,36 @@ export { FeatureAgentAnnotation } from './state.js';
  */
 export function createFeatureAgentGraph(executor, checkpointer) {
     const graph = new StateGraph(FeatureAgentAnnotation)
+        // --- Producer nodes ---
         .addNode('analyze', createAnalyzeNode(executor))
         .addNode('requirements', createRequirementsNode(executor))
         .addNode('research', createResearchNode(executor))
         .addNode('plan', createPlanNode(executor))
         .addNode('implement', createImplementNode(executor))
+        // --- Validate nodes ---
+        .addNode('validate_spec_analyze', createValidateNode('spec.yaml', validateSpecAnalyze))
+        .addNode('validate_spec_requirements', createValidateNode('spec.yaml', validateSpecRequirements))
+        .addNode('validate_research', createValidateNode('research.yaml', validateResearch))
+        .addNode('validate_plan_tasks', createPlanTasksValidator())
+        // --- Repair nodes ---
+        .addNode('repair_spec_analyze', createRepairNode('spec.yaml', executor))
+        .addNode('repair_spec_requirements', createRepairNode('spec.yaml', executor))
+        .addNode('repair_research', createRepairNode('research.yaml', executor))
+        .addNode('repair_plan_tasks', createRepairNode(['plan.yaml', 'tasks.yaml'], executor))
+        // --- Edges: linear flow with validation gates ---
         .addEdge(START, 'analyze')
-        .addEdge('analyze', 'requirements')
-        .addEdge('requirements', 'research')
-        .addEdge('research', 'plan')
-        .addEdge('plan', 'implement')
+        .addEdge('analyze', 'validate_spec_analyze')
+        .addConditionalEdges('validate_spec_analyze', routeValidation('requirements', 'repair_spec_analyze'))
+        .addEdge('repair_spec_analyze', 'validate_spec_analyze')
+        .addEdge('requirements', 'validate_spec_requirements')
+        .addConditionalEdges('validate_spec_requirements', routeValidation('research', 'repair_spec_requirements'))
+        .addEdge('repair_spec_requirements', 'validate_spec_requirements')
+        .addEdge('research', 'validate_research')
+        .addConditionalEdges('validate_research', routeValidation('plan', 'repair_research'))
+        .addEdge('repair_research', 'validate_research')
+        .addEdge('plan', 'validate_plan_tasks')
+        .addConditionalEdges('validate_plan_tasks', routeValidation('implement', 'repair_plan_tasks'))
+        .addEdge('repair_plan_tasks', 'validate_plan_tasks')
         .addEdge('implement', END);
     return graph.compile({ checkpointer });
 }

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-process.service.d.ts

@@ -7,11 +7,12 @@
  */
 import type { IFeatureAgentProcessService } from '../../../../application/ports/output/agents/feature-agent-process.interface.js';
 import type { IAgentRunRepository } from '../../../../application/ports/output/agents/agent-run-repository.interface.js';
+import { type ApprovalGates } from '../../../../domain/generated/output.js';
 export declare class FeatureAgentProcessService implements IFeatureAgentProcessService {
     private readonly runRepository;
     constructor(runRepository: IAgentRunRepository);
     spawn(featureId: string, runId: string, repoPath: string, specDir: string, worktreePath?: string, options?: {
-        approvalMode?: string;
+        approvalGates?: ApprovalGates;
         resume?: boolean;
         threadId?: string;
         resumeFromInterrupt?: boolean;

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-process.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-process.service.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/feature-agent-process.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sEAAsE,CAAC;AACxH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qEAAqE,CAAC;AAa/G,qBAAa,0BAA2B,YAAW,2BAA2B;IAChE,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,mBAAmB;IAE/D,KAAK,CACH,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QACR,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,GACA,MAAM;IAkDT,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASvB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAexD"}
+{"version":3,"file":"feature-agent-process.service.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/feature-agent-process.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sEAAsE,CAAC;AACxH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qEAAqE,CAAC;AAC/G,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAYlF,qBAAa,0BAA2B,YAAW,2BAA2B;IAChE,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,mBAAmB;IAE/D,KAAK,CACH,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,aAAa,CAAC;QAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,GACA,MAAM;IAkDT,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASvB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAexD"}

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-process.service.js

@@ -41,8 +41,8 @@ export class FeatureAgentProcessService {
         if (worktreePath) {
             args.push('--worktree-path', worktreePath);
         }
-        if (options?.approvalMode) {
-            args.push('--approval-mode', options.approvalMode);
+        if (options?.approvalGates) {
+            args.push('--approval-gates', JSON.stringify(options.approvalGates));
         }
         if (options?.threadId) {
             args.push('--thread-id', options.threadId);

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-worker.d.ts

@@ -9,13 +9,14 @@
  * CLI Args: --feature-id <id> --run-id <id> --repo <path> --spec-dir <path>
  */
 import 'reflect-metadata';
+import type { ApprovalGates } from '../../../../domain/generated/output.js';
 export interface WorkerArgs {
     featureId: string;
     runId: string;
     repo: string;
     specDir: string;
     worktreePath?: string;
-    approvalMode?: string;
+    approvalGates?: ApprovalGates;
     resume?: boolean;
     threadId?: string;
     resumeFromInterrupt?: boolean;

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAc1B,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAmC1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmI/D"}
+{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAgB1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA0C1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAsI/D"}

package/dist/src/infrastructure/services/agents/feature-agent/feature-agent-worker.js

@@ -19,6 +19,7 @@ import { AgentRunStatus } from '../../../../domain/generated/output.js';
 import { initializeSettings } from '../../../../infrastructure/services/settings.service.js';
 import { InitializeSettingsUseCase } from '../../../../application/use-cases/settings/initialize-settings.use-case.js';
 import { setHeartbeatContext } from './heartbeat.js';
+import { setPhaseTimingContext } from './phase-timing-context.js';
 /**
  * Parse CLI arguments into a WorkerArgs object.
  * Throws if any required argument is missing.
@@ -33,8 +34,17 @@ export function parseWorkerArgs(args) {
     };
     const worktreeIdx = args.indexOf('--worktree-path');
     const worktreePath = worktreeIdx !== -1 && worktreeIdx + 1 < args.length ? args[worktreeIdx + 1] : undefined;
-    const approvalIdx = args.indexOf('--approval-mode');
-    const approvalMode = approvalIdx !== -1 && approvalIdx + 1 < args.length ? args[approvalIdx + 1] : undefined;
+    const approvalIdx = args.indexOf('--approval-gates');
+    let approvalGates;
+    if (approvalIdx !== -1 && approvalIdx + 1 < args.length) {
+        try {
+            approvalGates = JSON.parse(args[approvalIdx + 1]);
+        }
+        catch {
+            // Fall back to no gates if JSON parse fails
+            approvalGates = undefined;
+        }
+    }
     const resume = args.includes('--resume');
     const resumeFromInterrupt = args.includes('--resume-from-interrupt');
     const threadIdx = args.indexOf('--thread-id');
@@ -45,7 +55,7 @@ export function parseWorkerArgs(args) {
         repo: getArg('repo'),
         specDir: getArg('spec-dir'),
         worktreePath,
-        approvalMode,
+        approvalGates,
         resume,
         threadId,
         resumeFromInterrupt,
@@ -87,7 +97,7 @@ export async function runWorker(args) {
     log(`  repo=${args.repo}`);
     log(`  specDir=${args.specDir}`);
     log(`  worktreePath=${args.worktreePath ?? '(none)'}`);
-    log(`  approvalMode=${args.approvalMode ?? '(none)'}`);
+    log(`  approvalGates=${args.approvalGates ? JSON.stringify(args.approvalGates) : '(none)'}`);
     log(`  resume=${args.resume}`);
     log('Initializing container...');
     await initializeContainer();
@@ -121,6 +131,9 @@ export async function runWorker(args) {
     const stopHeartbeat = startHeartbeat(args.runId, runRepository);
     // Set heartbeat context so node-helpers can update current node
     setHeartbeatContext(args.runId, runRepository);
+    // Set phase timing context so executeNode() records per-phase durations
+    const timingRepository = container.resolve('IPhaseTimingRepository');
+    setPhaseTimingContext(args.runId, timingRepository);
     try {
         const graphConfig = { configurable: { thread_id: checkpointId } };
         let result;
@@ -139,7 +152,7 @@ export async function runWorker(args) {
                 worktreePath: args.worktreePath ?? args.repo,
                 specDir: args.specDir,
                 error: undefined, // Clear previous error state
-                ...(args.approvalMode ? { approvalMode: args.approvalMode } : {}),
+                ...(args.approvalGates ? { approvalGates: args.approvalGates } : {}),
             }, graphConfig);
         }
         else {
@@ -149,7 +162,7 @@ export async function runWorker(args) {
                 repositoryPath: args.repo,
                 worktreePath: args.worktreePath ?? args.repo,
                 specDir: args.specDir,
-                ...(args.approvalMode ? { approvalMode: args.approvalMode } : {}),
+                ...(args.approvalGates ? { approvalGates: args.approvalGates } : {}),
             }, graphConfig);
         }
         log(`Graph invocation completed. Error: ${result.error ?? 'none'}`);
@@ -159,7 +172,6 @@ export async function runWorker(args) {
         if (interruptPayload && interruptPayload.length > 0) {
             const now = new Date();
             await runRepository.updateStatus(args.runId, AgentRunStatus.waitingApproval, {
-                approvalStatus: 'waiting',
                 updatedAt: now,
             });
             log('Run paused — waiting for human approval');

package/dist/src/infrastructure/services/agents/feature-agent/nodes/implement.node.js

@@ -132,7 +132,7 @@ export function createImplementNode(executor) {
             log.info(`All phases complete — ${completedTasks}/${totalTasks} tasks (${elapsed}s)`);
             updateFeatureProgress(state.specDir, totalTasks, totalTasks, 'implementation-complete', null, log);
             messages.push(`[implement] Complete: ${totalTasks} tasks across ${totalPhases} phases (${elapsed}s)`);
-            if (shouldInterrupt('implement', state.approvalMode)) {
+            if (shouldInterrupt('implement', state.approvalGates)) {
                 log.info('Interrupting for human approval');
                 interrupt({
                     node: 'implement',

package/dist/src/infrastructure/services/agents/feature-agent/nodes/node-helpers.d.ts

@@ -5,6 +5,7 @@
  * and error handling so every node follows the same patterns.
  */
 import type { IAgentExecutor, AgentExecutionOptions, AgentExecutionResult } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
+import type { ApprovalGates } from '../../../../../domain/generated/output.js';
 import type { FeatureAgentState } from '../state.js';
 /**
  * Create a scoped logger that prefixes messages with the node name.
@@ -31,9 +32,17 @@ export declare function buildExecutorOptions(state: FeatureAgentState): AgentExe
 export declare function safeYamlLoad(content: string): unknown;
 /**
  * Determine whether the current node should trigger an interrupt
- * for human approval given the configured approval mode.
+ * for human approval given the configured approval gates.
+ *
+ * Gates control which phases auto-approve:
+ * - allowPrd: when true, skip interrupt after requirements phase
+ * - allowPlan: when true, skip interrupt after plan phase
+ *
+ * Nodes not covered by a gate (analyze, research) never interrupt.
+ * The implement node always interrupts when gates are present
+ * (unless both gates are true, meaning fully autonomous).
  */
-export declare function shouldInterrupt(nodeName: string, approvalMode: string | undefined): boolean;
+export declare function shouldInterrupt(nodeName: string, gates: ApprovalGates | undefined): boolean;
 export type ErrorCategory = 'retryable-api' | 'retryable-network' | 'non-retryable' | 'unknown';
 /**
  * Classify an error message into a retry category.

package/dist/src/infrastructure/services/agents/feature-agent/nodes/node-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/node-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,+DAA+D,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM;kBAE/B,MAAM,GAAG,IAAI;mBAIZ,MAAM,GAAG,IAAI;EAK/B;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,qBAAqB,CAMpF;AAeD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQrD;AAUD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAI3F;AAMD,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,mBAAmB,GAAG,eAAe,GAAG,SAAS,CAAC;AAMhG;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAKjE;AAED,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,qBAAqB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACvB,OAAO,CAAC,oBAAoB,CAAC,CA6B/B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAW5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAwB1F;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,EACxB,WAAW,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,UAAU,KAAK,MAAM,GACjE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAgDnE"}
+{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/node-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,+DAA+D,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM;kBAE/B,MAAM,GAAG,IAAI;mBAIZ,MAAM,GAAG,IAAI;EAK/B;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,qBAAqB,CAMpF;AAeD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAO3F;AAMD,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,mBAAmB,GAAG,eAAe,GAAG,SAAS,CAAC;AAMhG;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAKjE;AAED,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,qBAAqB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACvB,OAAO,CAAC,oBAAoB,CAAC,CA6B/B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAW5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAwB1F;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,EACxB,WAAW,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,UAAU,KAAK,MAAM,GACjE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CA4EnE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/node-helpers.js

@@ -9,6 +9,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
 import { reportNodeStart } from '../heartbeat.js';
+import { recordPhaseStart, recordPhaseEnd } from '../phase-timing-context.js';
 /**
  * Create a scoped logger that prefixes messages with the node name.
  * Output goes to stdout which the worker redirects to the log file.
@@ -70,22 +71,30 @@ export function safeYamlLoad(content) {
         return yaml.load(sanitized);
     }
 }
-/** Nodes that are auto-approved (no interrupt) for each approval mode. */
-const AUTO_APPROVED_NODES = {
-    interactive: [],
-    'allow-prd': ['analyze', 'requirements'],
-    'allow-plan': ['analyze', 'requirements', 'research', 'plan'],
-    'allow-all': ['analyze', 'requirements', 'research', 'plan', 'implement'],
-};
 /**
  * Determine whether the current node should trigger an interrupt
- * for human approval given the configured approval mode.
+ * for human approval given the configured approval gates.
+ *
+ * Gates control which phases auto-approve:
+ * - allowPrd: when true, skip interrupt after requirements phase
+ * - allowPlan: when true, skip interrupt after plan phase
+ *
+ * Nodes not covered by a gate (analyze, research) never interrupt.
+ * The implement node always interrupts when gates are present
+ * (unless both gates are true, meaning fully autonomous).
  */
-export function shouldInterrupt(nodeName, approvalMode) {
-    if (!approvalMode || approvalMode === 'allow-all')
+export function shouldInterrupt(nodeName, gates) {
+    if (!gates)
+        return false;
+    if (gates.allowPrd && gates.allowPlan)
         return false;
-    const autoApproved = AUTO_APPROVED_NODES[approvalMode] ?? [];
-    return !autoApproved.includes(nodeName);
+    if (nodeName === 'requirements')
+        return !gates.allowPrd;
+    if (nodeName === 'plan')
+        return !gates.allowPlan;
+    if (nodeName === 'implement')
+        return true;
+    return false;
 }
 const API_ERROR_RE = /API Error: (400|429|5\d{2})/;
 const NETWORK_ERROR_RE = /ECONNREFUSED|ETIMEDOUT|ENOTFOUND|timed out/i;
@@ -193,21 +202,41 @@ export function executeNode(nodeName, executor, buildPrompt) {
     return async (state) => {
         log.info('Starting...');
         reportNodeStart(nodeName);
+        // On resume from interrupt, LangGraph re-executes the node function from
+        // the top. Skip the expensive executor call if this phase already completed
+        // (markPhaseComplete is called before interrupt, so completed = done but
+        // awaiting approval; the approval has now been granted).
+        const completedPhases = getCompletedPhases(state.specDir);
+        if (completedPhases.includes(nodeName)) {
+            log.info('Phase already completed (resuming from approval), skipping execution');
+            return {
+                currentNode: nodeName,
+                messages: [`[${nodeName}] Approved — continuing`],
+            };
+        }
         const startTime = Date.now();
+        // Record phase start (no-op if timing context not set)
+        const timingId = await recordPhaseStart(nodeName);
         try {
             const prompt = buildPrompt(state, log);
             const options = buildExecutorOptions(state);
             log.info(`Executing agent at cwd=${options.cwd}`);
             log.info(`Prompt length: ${prompt.length} chars`);
             const result = await executor.execute(prompt, options);
-            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
             log.info(`Complete (${result.result.length} chars, ${elapsed}s)`);
+            // Record phase completion
+            await recordPhaseEnd(timingId, durationMs);
+            // Mark phase complete BEFORE interrupting so that on resume the
+            // node detects the work is already done and skips re-execution.
+            markPhaseComplete(state.specDir, nodeName, log);
             const nodeResult = {
                 currentNode: nodeName,
                 messages: [`[${nodeName}] Complete (${result.result.length} chars, ${elapsed}s)`],
             };
             // Human-in-the-loop: interrupt after node execution for review
-            if (shouldInterrupt(nodeName, state.approvalMode)) {
+            if (shouldInterrupt(nodeName, state.approvalGates)) {
                 log.info('Interrupting for human approval');
                 interrupt({
                     node: nodeName,
@@ -222,8 +251,10 @@ export function executeNode(nodeName, executor, buildPrompt) {
             if (isGraphBubbleUp(err))
                 throw err;
             const message = err instanceof Error ? err.message : String(err);
-            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
             log.error(`${message} (after ${elapsed}s)`);
+            // Leave timingId without completedAt (partial timing for failed nodes)
             // Throw so LangGraph does NOT checkpoint this node as "completed".
             // The worker catch block marks the run as failed, and on resume
             // LangGraph re-executes from the last successfully checkpointed node.

package/dist/src/infrastructure/services/agents/feature-agent/nodes/repair.node.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Repair node factory for the feature-agent graph.
+ *
+ * Reads broken YAML content and validation errors from state,
+ * builds a constrained repair prompt, and sends it to the executor
+ * with limited tools (write-only) to fix the YAML files.
+ */
+import type { FeatureAgentState } from '../state.js';
+import type { IAgentExecutor } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
+/**
+ * Build a repair prompt containing the broken YAML, validation errors,
+ * and file paths for the executor to write fixed files.
+ */
+export declare function buildRepairPrompt(filename: string | string[], content: string, errors: string[], specDir: string): string;
+/**
+ * Factory that creates a repair node for a specific YAML file (or files).
+ *
+ * Reads the broken YAML, builds a repair prompt with validation errors
+ * from state, and calls the executor with constrained options (maxTurns=5,
+ * write-only tools, no MCP).
+ */
+export declare function createRepairNode(filename: string | string[], executor: IAgentExecutor): (state: FeatureAgentState) => Promise<Partial<FeatureAgentState>>;
+//# sourceMappingURL=repair.node.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/repair.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.node.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/repair.node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAGpG;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAC3B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,EAAE,MAAM,GACd,MAAM,CA0BR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAC3B,QAAQ,EAAE,cAAc,GACvB,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAuCnE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/repair.node.js

@@ -0,0 +1,77 @@
+/**
+ * Repair node factory for the feature-agent graph.
+ *
+ * Reads broken YAML content and validation errors from state,
+ * builds a constrained repair prompt, and sends it to the executor
+ * with limited tools (write-only) to fix the YAML files.
+ */
+import { join } from 'node:path';
+import { readSpecFile, createNodeLogger } from './node-helpers.js';
+/**
+ * Build a repair prompt containing the broken YAML, validation errors,
+ * and file paths for the executor to write fixed files.
+ */
+export function buildRepairPrompt(filename, content, errors, specDir) {
+    const filenames = Array.isArray(filename) ? filename : [filename];
+    const filePaths = filenames.map((f) => join(specDir, f));
+    return [
+        '## YAML Repair Task',
+        '',
+        `Fix the following YAML validation errors in ${filenames.join(' and ')}.`,
+        '',
+        '### Validation Errors',
+        ...errors.map((e) => `- ${e}`),
+        '',
+        '### Current File Content',
+        '```yaml',
+        content,
+        '```',
+        '',
+        '### Output Files',
+        ...filePaths.map((p) => `- Write fixed YAML to: ${p}`),
+        '',
+        '### Rules',
+        '- Fix ONLY the reported errors',
+        '- Preserve all existing valid content',
+        '- Use proper YAML formatting',
+        '- Do not add fields that were not in the original',
+    ].join('\n');
+}
+/**
+ * Factory that creates a repair node for a specific YAML file (or files).
+ *
+ * Reads the broken YAML, builds a repair prompt with validation errors
+ * from state, and calls the executor with constrained options (maxTurns=5,
+ * write-only tools, no MCP).
+ */
+export function createRepairNode(filename, executor) {
+    const label = Array.isArray(filename) ? filename.join('+') : filename;
+    const log = createNodeLogger(`repair:${label}`);
+    return async (state) => {
+        log.info(`Repairing ${label} (attempt ${state.validationRetries})`);
+        const filenames = Array.isArray(filename) ? filename : [filename];
+        const contents = filenames.map((f) => readSpecFile(state.specDir, f));
+        const combinedContent = filenames.map((f, i) => `--- ${f} ---\n${contents[i]}`).join('\n\n');
+        const prompt = buildRepairPrompt(filename, combinedContent, state.lastValidationErrors, state.specDir);
+        const options = {
+            cwd: state.worktreePath || state.repositoryPath,
+            maxTurns: 5,
+            disableMcp: true,
+            allowedTools: ['write'],
+        };
+        try {
+            const result = await executor.execute(prompt, options);
+            log.info(`Repair complete (${result.result.length} chars)`);
+            return {
+                messages: [`[repair:${label}] Repair attempt ${state.validationRetries} complete`],
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`Repair failed: ${msg}`);
+            return {
+                messages: [`[repair:${label}] Repair failed: ${msg}`],
+            };
+        }
+    };
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/plan.schema.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationResult } from './validation.js';
+export declare function validatePlan(data: unknown): ValidationResult;
+export declare function validateTasks(data: unknown, phaseIds: string[]): ValidationResult;
+//# sourceMappingURL=plan.schema.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/plan.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.schema.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/schemas/plan.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CA+B5D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,gBAAgB,CA+BjF"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/plan.schema.js

@@ -0,0 +1,54 @@
+import { requireString, requireNonEmptyArray, requireArrayOfShape, } from './validation.js';
+export function validatePlan(data) {
+    const errors = [];
+    if (!data || typeof data !== 'object') {
+        errors.push('YAML parsed to null or non-object');
+        return { valid: false, errors };
+    }
+    const d = data;
+    requireString(d, 'content', errors);
+    requireArrayOfShape(d, 'phases', errors, (item, idx, errs) => {
+        const phase = item;
+        if (!phase || typeof phase !== 'object') {
+            errs.push(`phases[${idx}] must be an object`);
+            return;
+        }
+        requireString(phase, 'id', errs, `phases[${idx}].`);
+        requireString(phase, 'name', errs, `phases[${idx}].`);
+        if (typeof phase.parallel !== 'boolean') {
+            errs.push(`phases[${idx}].parallel must be a boolean`);
+        }
+    });
+    const ftc = Array.isArray(d.filesToCreate) ? d.filesToCreate : [];
+    const ftm = Array.isArray(d.filesToModify) ? d.filesToModify : [];
+    if (ftc.length === 0 && ftm.length === 0) {
+        errors.push("At least one of 'filesToCreate' or 'filesToModify' must be non-empty");
+    }
+    return { valid: errors.length === 0, errors };
+}
+export function validateTasks(data, phaseIds) {
+    const errors = [];
+    if (!data || typeof data !== 'object') {
+        errors.push('YAML parsed to null or non-object');
+        return { valid: false, errors };
+    }
+    const d = data;
+    requireArrayOfShape(d, 'tasks', errors, (item, idx, errs) => {
+        const task = item;
+        if (!task || typeof task !== 'object') {
+            errs.push(`tasks[${idx}] must be an object`);
+            return;
+        }
+        requireString(task, 'id', errs, `tasks[${idx}].`);
+        requireString(task, 'title', errs, `tasks[${idx}].`);
+        requireString(task, 'state', errs, `tasks[${idx}].`);
+        requireNonEmptyArray(task, 'acceptanceCriteria', errs, `tasks[${idx}].`);
+        if (typeof task.phaseId === 'string' && !phaseIds.includes(task.phaseId)) {
+            errs.push(`tasks[${idx}].phaseId '${task.phaseId}' does not match any phase (valid: ${phaseIds.join(', ')})`);
+        }
+        else if (typeof task.phaseId !== 'string') {
+            requireString(task, 'phaseId', errs, `tasks[${idx}].`);
+        }
+    });
+    return { valid: errors.length === 0, errors };
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/research.schema.d.ts

@@ -0,0 +1,3 @@
+import { type ValidationResult } from './validation.js';
+export declare function validateResearch(data: unknown): ValidationResult;
+//# sourceMappingURL=research.schema.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/research.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research.schema.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/schemas/research.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CA0BhE"}