@shepai/cli 1.19.0 → 1.20.1

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

@@ -4,10 +4,11 @@ export { FeatureAgentAnnotation, type FeatureAgentState } from './state.js';
 /**
  * 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
@@ -20,8 +21,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
     worktreePath: string;
     currentNode: string;
     error: string | null;
-    approvalMode: string | undefined;
+    approvalGates: import("../../../../domain/generated/output.js").ApprovalGates | undefined;
     messages: string[];
+    validationRetries: number;
+    lastValidationTarget: string;
+    lastValidationErrors: string[];
 }, {
     featureId?: string | undefined;
     repositoryPath?: string | undefined;
@@ -29,9 +33,12 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
     worktreePath?: string | undefined;
     currentNode?: string | undefined;
     error?: string | null | undefined;
-    approvalMode?: string | undefined;
+    approvalGates?: import("../../../../domain/generated/output.js").ApprovalGates | undefined;
     messages?: string[] | undefined;
-}, "__start__" | "analyze" | "requirements" | "research" | "plan" | "implement", {
+    validationRetries?: number | undefined;
+    lastValidationTarget?: string | undefined;
+    lastValidationErrors?: string[] | undefined;
+}, "__start__" | "analyze" | "requirements" | "plan" | "implement" | "research" | "validate_spec_analyze" | "validate_spec_requirements" | "validate_research" | "validate_plan_tasks" | "repair_spec_analyze" | "repair_spec_requirements" | "repair_research" | "repair_plan_tasks", {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
         (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
@@ -58,8 +65,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
     error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-    approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
     messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
 }, {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -87,8 +97,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
     error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-    approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
     messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
 }, import("@langchain/langgraph").StateDefinition, {
     analyze: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -117,8 +130,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
             Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
         };
         error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-        approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
         messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
     }>>;
     requirements: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -147,8 +163,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
             Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
         };
         error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-        approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
         messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
     }>>;
     research: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -177,8 +196,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
             Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
         };
         error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-        approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
         messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
     }>>;
     plan: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -207,8 +229,11 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
             Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
         };
         error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-        approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
         messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
     }>>;
     implement: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -237,8 +262,275 @@ export declare function createFeatureAgentGraph(executor: IAgentExecutor, checkp
             Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
         };
         error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-        approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
         messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    validate_spec_analyze: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    validate_spec_requirements: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    validate_research: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    validate_plan_tasks: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    repair_spec_analyze: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    repair_spec_requirements: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    repair_research: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    }>>;
+    repair_plan_tasks: Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/generated/output.js").ApprovalGates | undefined, import("../../../../domain/generated/output.js").ApprovalGates | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
     }>>;
 }, unknown, unknown>;
 //# sourceMappingURL=feature-agent-graph.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../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;AASpG,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,cAAc,EACxB,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgBnC"}
+{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../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;AAepG,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAuG5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,cAAc,EACxB,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoDnC"}

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;