@shepai/cli 1.38.0 → 1.40.0

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.d.ts

@@ -35,6 +35,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     validationRetries: number;
     lastValidationTarget: string;
     lastValidationErrors: string[];
+    _approvalAction: string | null;
+    _rejectionFeedback: string | null;
+    _needsReexecution: boolean;
     prUrl: string | null;
     prNumber: number | null;
     commitHash: string | null;
@@ -53,6 +56,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     validationRetries?: number | undefined;
     lastValidationTarget?: string | undefined;
     lastValidationErrors?: string[] | undefined;
+    _approvalAction?: string | null | undefined;
+    _rejectionFeedback?: string | null | undefined;
+    _needsReexecution?: boolean | undefined;
     prUrl?: string | null | undefined;
     prNumber?: number | null | undefined;
     commitHash?: string | null | undefined;
@@ -91,6 +97,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
     lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
     prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
     commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -129,6 +138,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
     lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
     prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
     commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -168,6 +180,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -207,6 +222,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -246,6 +264,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -285,6 +306,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -324,6 +348,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -363,6 +390,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -402,6 +432,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -441,6 +474,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -480,6 +516,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -519,6 +558,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -558,6 +600,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -597,6 +642,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
@@ -636,6 +684,9 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
         lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
         commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAOpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAS5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAuGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEnC"}
+{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAOpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAS5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAyHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0EnC"}

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

@@ -14,6 +14,21 @@ 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 re-execution routing.
+ *
+ * After an interruptible node resumes, it returns early with _needsReexecution
+ * set to true (rejection) or false (approval). This edge routes back to the
+ * same node on rejection for a fresh invocation, avoiding the stale interrupt
+ * replay bug caused by dual interrupt() calls.
+ */
+function routeReexecution(selfNode, nextNode) {
+    return (state) => {
+        if (state._needsReexecution)
+            return selfNode;
+        return nextNode;
+    };
+}
 /**
  * Factory that creates a conditional edge function for validation routing.
  *
@@ -141,17 +156,21 @@ export function createFeatureAgentGraph(depsOrExecutor, checkpointer) {
         .addNode('repair_research', createRepairNode('research.yaml', executor))
         .addNode('repair_plan_tasks', createRepairNode(['plan.yaml', 'tasks.yaml'], executor))
         // --- Edges: linear flow with validation gates ---
+        // Interruptible nodes (requirements, plan) use conditional edges that
+        // check _needsReexecution to loop back on rejection. This ensures each
+        // re-execution is a fresh node invocation with a clean interrupt index,
+        // avoiding the stale interrupt replay bug with dual interrupt() calls.
         .addEdge(START, 'analyze')
         .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('requirements', routeReexecution('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('plan', routeReexecution('plan', 'validate_plan_tasks'))
         .addConditionalEdges('validate_plan_tasks', routeValidation('implement', 'repair_plan_tasks'))
         .addEdge('repair_plan_tasks', 'validate_plan_tasks');
     // --- Merge node: wired when deps are provided ---

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

@@ -18,6 +18,7 @@ export declare class FeatureAgentProcessService implements IFeatureAgentProcessS
         resumeFromInterrupt?: boolean;
         push?: boolean;
         openPr?: boolean;
+        resumePayload?: string;
     }): number;
     isAlive(pid: number): boolean;
     checkAndMarkCrashed(runId: string): Promise<void>;

package/dist/packages/core/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":["../../../../../../../../packages/core/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;QAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,GACA,MAAM;IAuDT,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":["../../../../../../../../packages/core/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;QAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,GACA,MAAM;IA0DT,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASvB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAexD"}

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

@@ -59,6 +59,9 @@ export class FeatureAgentProcessService {
         if (options?.openPr) {
             args.push('--open-pr');
         }
+        if (options?.resumePayload) {
+            args.push('--resume-payload', options.resumePayload);
+        }
         // Create log file for worker output (for debugging)
         const logsDir = join(homedir(), '.shep', 'logs');
         mkdirSync(logsDir, { recursive: true });

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

@@ -22,6 +22,7 @@ export interface WorkerArgs {
     resumeFromInterrupt?: boolean;
     push?: boolean;
     openPr?: boolean;
+    resumePayload?: string;
 }
 /**
  * Parse CLI arguments into a WorkerArgs object.

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

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAqB1B,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;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA6C1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAoK/D"}
+{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAqB1B,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;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAoD1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAkM/D"}

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

@@ -53,6 +53,10 @@ export function parseWorkerArgs(args) {
     const openPr = args.includes('--open-pr');
     const threadIdx = args.indexOf('--thread-id');
     const threadId = threadIdx !== -1 && threadIdx + 1 < args.length ? args[threadIdx + 1] : undefined;
+    const resumePayloadIdx = args.indexOf('--resume-payload');
+    const resumePayload = resumePayloadIdx !== -1 && resumePayloadIdx + 1 < args.length
+        ? args[resumePayloadIdx + 1]
+        : undefined;
     return {
         featureId: getArg('feature-id'),
         runId: getArg('run-id'),
@@ -65,6 +69,7 @@ export function parseWorkerArgs(args) {
         resumeFromInterrupt,
         push,
         openPr,
+        resumePayload,
     };
 }
 /** Simple worker logger — writes to stdout which is redirected to log file by the parent. */
@@ -163,8 +168,33 @@ export async function runWorker(args) {
         let result;
         if (args.resume && args.resumeFromInterrupt) {
             // Resume from an interrupt (human-in-the-loop approval)
+            let resumeValue = { approved: true }; // default backward-compatible
+            if (args.resumePayload) {
+                try {
+                    resumeValue = JSON.parse(args.resumePayload);
+                    log(`Resuming with typed payload: ${args.resumePayload.slice(0, 200)}`);
+                }
+                catch (e) {
+                    log(`Warning: Failed to parse --resume-payload, using default approval: ${e}`);
+                }
+            }
+            // Derive state updates from the resume payload so executeNode() can
+            // read _approvalAction from state instead of from interrupt() return
+            // value (fixes the dual-interrupt stale replay bug).
+            const stateUpdate = {};
+            if (typeof resumeValue === 'object' &&
+                resumeValue !== null &&
+                'rejected' in resumeValue &&
+                resumeValue.rejected === true) {
+                stateUpdate._approvalAction = 'rejected';
+                stateUpdate._rejectionFeedback = resumeValue.feedback ?? null;
+            }
+            else {
+                stateUpdate._approvalAction = 'approved';
+                stateUpdate._rejectionFeedback = null;
+            }
             log('Resuming graph from interrupt checkpoint...');
-            result = await graph.invoke(new Command({ resume: { approved: true } }), graphConfig);
+            result = await graph.invoke(new Command({ resume: resumeValue, update: stateUpdate }), graphConfig);
         }
         else if (args.resume) {
             // Resume from error — re-invoke with initial state; LangGraph continues

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

@@ -39,9 +39,8 @@ export declare function safeYamlLoad(content: string): unknown;
  * - allowPlan: when true, skip interrupt after plan phase
  * - allowMerge: when true, skip interrupt after merge phase
  *
- * Nodes not covered by a gate (analyze, research) never interrupt.
- * The implement node always interrupts when gates are present
- * (unless all three gates are true, meaning fully autonomous).
+ * Nodes not covered by a gate (analyze, research, implement) never interrupt.
+ * Implementation always proceeds to merge; the merge node handles its own gate.
  *
  */
 export declare function shouldInterrupt(nodeName: string, gates: ApprovalGates | undefined): boolean;
@@ -75,10 +74,27 @@ export declare function retryExecute(executor: IAgentExecutor, prompt: string, o
  * Read completed phases from feature.yaml.
  */
 export declare function getCompletedPhases(specDir: string): string[];
+/**
+ * Remove a phase from completedPhases in feature.yaml.
+ * Used when a phase is rejected and needs to re-execute.
+ */
+export declare function clearCompletedPhase(specDir: string, phaseId: string, log?: NodeLogger): void;
+/**
+ * Type guard to detect rejection payloads from interrupt() return value.
+ */
+export declare function isRejectionPayload(value: unknown): value is {
+    rejected: true;
+    feedback: string;
+};
 /**
  * Mark a phase as complete in feature.yaml by adding its ID to completedPhases.
  */
 export declare function markPhaseComplete(specDir: string, phaseId: string, log?: NodeLogger): void;
+/**
+ * Write a spec file atomically using temp-file-then-rename pattern.
+ * Prevents corruption on crash mid-write.
+ */
+export declare function writeSpecFileAtomic(specDir: string, filename: string, content: string): void;
 /**
  * Execute a node with consistent logging and error handling.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/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;AASrD;;;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;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAS3F;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,CAiFnE"}
+{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/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;AASrD;;;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;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAQ3F;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;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAqB5F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAOhG;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAwB1F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAa5F;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,CAmHnE"}

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

@@ -5,7 +5,7 @@
  * and error handling so every node follows the same patterns.
  */
 import yaml from 'js-yaml';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
 import { reportNodeStart } from '../heartbeat.js';
@@ -81,9 +81,8 @@ export function safeYamlLoad(content) {
  * - allowPlan: when true, skip interrupt after plan phase
  * - allowMerge: when true, skip interrupt after merge phase
  *
- * Nodes not covered by a gate (analyze, research) never interrupt.
- * The implement node always interrupts when gates are present
- * (unless all three gates are true, meaning fully autonomous).
+ * Nodes not covered by a gate (analyze, research, implement) never interrupt.
+ * Implementation always proceeds to merge; the merge node handles its own gate.
  *
  */
 export function shouldInterrupt(nodeName, gates) {
@@ -97,8 +96,6 @@ export function shouldInterrupt(nodeName, gates) {
         return !gates.allowPlan;
     if (nodeName === 'merge')
         return !gates.allowMerge;
-    if (nodeName === 'implement')
-        return true;
     return false;
 }
 const API_ERROR_RE = /API Error: (400|429|5\d{2})/;
@@ -169,6 +166,38 @@ export function getCompletedPhases(specDir) {
         return [];
     }
 }
+/**
+ * Remove a phase from completedPhases in feature.yaml.
+ * Used when a phase is rejected and needs to re-execute.
+ */
+export function clearCompletedPhase(specDir, phaseId, log) {
+    try {
+        const content = readSpecFile(specDir, 'feature.yaml');
+        if (!content)
+            return;
+        const data = yaml.load(content);
+        if (!data || typeof data !== 'object')
+            return;
+        const status = (data.status ?? {});
+        const completedPhases = Array.isArray(status.completedPhases)
+            ? status.completedPhases.filter((p) => p !== phaseId)
+            : [];
+        data.status = { ...status, completedPhases };
+        writeFileSync(join(specDir, 'feature.yaml'), yaml.dump(data, { indent: 2, lineWidth: -1 }), 'utf-8');
+    }
+    catch (err) {
+        log?.error(`Failed to clear completed phase: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Type guard to detect rejection payloads from interrupt() return value.
+ */
+export function isRejectionPayload(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'rejected' in value &&
+        value.rejected === true);
+}
 /**
  * Mark a phase as complete in feature.yaml by adding its ID to completedPhases.
  */
@@ -194,6 +223,26 @@ export function markPhaseComplete(specDir, phaseId, log) {
         log?.error(`Failed to mark phase complete: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+/**
+ * Write a spec file atomically using temp-file-then-rename pattern.
+ * Prevents corruption on crash mid-write.
+ */
+export function writeSpecFileAtomic(specDir, filename, content) {
+    const targetPath = join(specDir, filename);
+    const tempPath = join(specDir, `.${filename}.tmp`);
+    try {
+        writeFileSync(tempPath, content, 'utf-8');
+        renameSync(tempPath, targetPath);
+    }
+    finally {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            // Temp file already renamed or doesn't exist
+        }
+    }
+}
 /**
  * Execute a node with consistent logging and error handling.
  *
@@ -210,16 +259,46 @@ export function executeNode(nodeName, executor, buildPrompt) {
         // Update feature lifecycle to reflect the current phase
         await updateNodeLifecycle(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).
+        // the top. Instead of re-executing within this invocation (which would
+        // require a second interrupt() call and trigger the stale-replay bug),
+        // we return early. Rejection sets _needsReexecution=true so a conditional
+        // edge in the graph routes back to this node for a fresh invocation.
         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`],
-            };
+            if (shouldInterrupt(nodeName, state.approvalGates)) {
+                if (state._approvalAction === 'rejected') {
+                    const feedback = state._rejectionFeedback ?? '(no feedback)';
+                    log.info(`Phase rejected with feedback: "${feedback}" — scheduling re-execution`);
+                    clearCompletedPhase(state.specDir, nodeName, log);
+                    // Return early — the conditional edge will route back to this node
+                    // for a fresh invocation with a clean interrupt index.
+                    return {
+                        currentNode: nodeName,
+                        messages: [`[${nodeName}] Rejected — will re-execute`],
+                        _approvalAction: null,
+                        _rejectionFeedback: null,
+                        _needsReexecution: true,
+                    };
+                }
+                else {
+                    log.info('Phase approved, skipping re-execution');
+                    return {
+                        currentNode: nodeName,
+                        messages: [`[${nodeName}] Approved — continuing`],
+                        _approvalAction: null,
+                        _rejectionFeedback: null,
+                        _needsReexecution: false,
+                    };
+                }
+            }
+            else {
+                log.info('Phase already completed (no gate), skipping execution');
+                return {
+                    currentNode: nodeName,
+                    messages: [`[${nodeName}] Approved — continuing`],
+                    _needsReexecution: false,
+                };
+            }
         }
         const startTime = Date.now();
         // Record phase start (no-op if timing context not set)
@@ -236,13 +315,19 @@ export function executeNode(nodeName, executor, buildPrompt) {
             // 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.
+            // node detects the work is already done and returns early.
             markPhaseComplete(state.specDir, nodeName, log);
             const nodeResult = {
                 currentNode: nodeName,
                 messages: [`[${nodeName}] Complete (${result.result.length} chars, ${elapsed}s)`],
+                _approvalAction: null,
+                _rejectionFeedback: null,
+                _needsReexecution: false,
             };
-            // Human-in-the-loop: interrupt after node execution for review
+            // Human-in-the-loop: interrupt after node execution for review.
+            // This is the ONLY interrupt() call in the entire execution path.
+            // On resume, the node returns early (above) without calling interrupt(),
+            // so there is no stale interrupt replay.
             if (shouldInterrupt(nodeName, state.approvalGates)) {
                 log.info('Interrupting for human approval');
                 await recordApprovalWaitStart(timingId);

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.d.ts

@@ -2,7 +2,8 @@
  * Requirements Phase Prompt
  *
  * Instructs the agent to build comprehensive requirements from the analysis,
- * including product questions with AI-recommended default answers.
+ * including product questions with structured QuestionOption[] arrays
+ * and AI-recommended default answers.
  * Writes back to spec.yaml with full requirements.
  */
 import type { FeatureAgentState } from '../../state.js';

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requirements.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAoIxE"}
+{"version":3,"file":"requirements.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/requirements.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAkKxE"}