@shepai/cli 1.18.0 → 1.20.0

package/dist/src/infrastructure/repositories/agent-run.repository.js

@@ -45,14 +45,14 @@ let SQLiteAgentRunRepository = class SQLiteAgentRunRepository {
         started_at, completed_at, error,
         feature_id, repository_path,
         created_at, updated_at,
-        approval_mode, approval_status
+        approval_gates
       ) VALUES (
         @id, @agent_type, @agent_name, @status, @prompt, @result,
         @session_id, @thread_id, @pid, @last_heartbeat,
         @started_at, @completed_at, @error,
         @feature_id, @repository_path,
         @created_at, @updated_at,
-        @approval_mode, @approval_status
+        @approval_gates
       )
     `);
         stmt.run(row);
@@ -108,13 +108,9 @@ let SQLiteAgentRunRepository = class SQLiteAgentRunRepository {
             setClauses.push('error = @error');
             params.error = updates.error;
         }
-        if (updates?.approvalMode !== undefined) {
-            setClauses.push('approval_mode = @approval_mode');
-            params.approval_mode = updates.approvalMode;
-        }
-        if (updates?.approvalStatus !== undefined) {
-            setClauses.push('approval_status = @approval_status');
-            params.approval_status = updates.approvalStatus;
+        if (updates?.approvalGates !== undefined) {
+            setClauses.push('approval_gates = @approval_gates');
+            params.approval_gates = JSON.stringify(updates.approvalGates);
         }
         const stmt = this.db.prepare(`UPDATE agent_runs SET ${setClauses.join(', ')} WHERE id = @id`);
         stmt.run(params);

package/dist/src/infrastructure/repositories/sqlite-phase-timing.repository.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SQLite Phase Timing Repository Implementation
+ *
+ * Implements IPhaseTimingRepository using SQLite database.
+ * Uses prepared statements to prevent SQL injection.
+ */
+import type Database from 'better-sqlite3';
+import type { IPhaseTimingRepository } from '../../application/ports/output/agents/phase-timing-repository.interface.js';
+import type { PhaseTiming } from '../../domain/generated/output.js';
+/**
+ * SQLite implementation of IPhaseTimingRepository.
+ */
+export declare class SQLitePhaseTimingRepository implements IPhaseTimingRepository {
+    private readonly db;
+    constructor(db: Database.Database);
+    save(phaseTiming: PhaseTiming): Promise<void>;
+    update(id: string, updates: Partial<Pick<PhaseTiming, 'completedAt' | 'durationMs'>>): Promise<void>;
+    findByRunId(agentRunId: string): Promise<PhaseTiming[]>;
+    findByFeatureId(featureId: string): Promise<PhaseTiming[]>;
+}
+//# sourceMappingURL=sqlite-phase-timing.repository.d.ts.map

package/dist/src/infrastructure/repositories/sqlite-phase-timing.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-phase-timing.repository.d.ts","sourceRoot":"","sources":["../../../../src/infrastructure/repositories/sqlite-phase-timing.repository.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4EAA4E,CAAC;AACzH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AA0CpE;;GAEG;AACH,qBACa,2BAA4B,YAAW,sBAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAE5C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB7C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,GAAG,YAAY,CAAC,CAAC,GAChE,OAAO,CAAC,IAAI,CAAC;IAyBV,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IASvD,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAWjE"}

package/dist/src/infrastructure/repositories/sqlite-phase-timing.repository.js

@@ -0,0 +1,100 @@
+/**
+ * SQLite Phase Timing Repository Implementation
+ *
+ * Implements IPhaseTimingRepository using SQLite database.
+ * Uses prepared statements to prevent SQL injection.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+function toDatabase(timing) {
+    return {
+        id: timing.id,
+        agent_run_id: timing.agentRunId,
+        phase: timing.phase,
+        started_at: timing.startedAt instanceof Date ? timing.startedAt.getTime() : timing.startedAt,
+        completed_at: timing.completedAt instanceof Date ? timing.completedAt.getTime() : null,
+        duration_ms: timing.durationMs != null ? Number(timing.durationMs) : null,
+        created_at: timing.createdAt instanceof Date ? timing.createdAt.getTime() : timing.createdAt,
+        updated_at: timing.updatedAt instanceof Date ? timing.updatedAt.getTime() : timing.updatedAt,
+    };
+}
+function fromDatabase(row) {
+    return {
+        id: row.id,
+        agentRunId: row.agent_run_id,
+        phase: row.phase,
+        startedAt: new Date(row.started_at),
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+        ...(row.completed_at !== null && { completedAt: new Date(row.completed_at) }),
+        ...(row.duration_ms !== null && { durationMs: BigInt(row.duration_ms) }),
+    };
+}
+/**
+ * SQLite implementation of IPhaseTimingRepository.
+ */
+let SQLitePhaseTimingRepository = class SQLitePhaseTimingRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(phaseTiming) {
+        const row = toDatabase(phaseTiming);
+        const stmt = this.db.prepare(`
+      INSERT INTO phase_timings (
+        id, agent_run_id, phase, started_at, completed_at, duration_ms,
+        created_at, updated_at
+      ) VALUES (
+        @id, @agent_run_id, @phase, @started_at, @completed_at, @duration_ms,
+        @created_at, @updated_at
+      )
+    `);
+        stmt.run(row);
+    }
+    async update(id, updates) {
+        const setClauses = ['updated_at = @updated_at'];
+        const params = {
+            id,
+            updated_at: Date.now(),
+        };
+        if (updates.completedAt !== undefined) {
+            setClauses.push('completed_at = @completed_at');
+            params.completed_at =
+                updates.completedAt instanceof Date ? updates.completedAt.getTime() : updates.completedAt;
+        }
+        if (updates.durationMs !== undefined) {
+            setClauses.push('duration_ms = @duration_ms');
+            params.duration_ms = updates.durationMs;
+        }
+        const stmt = this.db.prepare(`UPDATE phase_timings SET ${setClauses.join(', ')} WHERE id = @id`);
+        stmt.run(params);
+    }
+    async findByRunId(agentRunId) {
+        const stmt = this.db.prepare('SELECT * FROM phase_timings WHERE agent_run_id = ? ORDER BY created_at');
+        const rows = stmt.all(agentRunId);
+        return rows.map(fromDatabase);
+    }
+    async findByFeatureId(featureId) {
+        const stmt = this.db.prepare(`
+      SELECT pt.* FROM phase_timings pt
+      INNER JOIN agent_runs ar ON pt.agent_run_id = ar.id
+      WHERE ar.feature_id = ?
+      ORDER BY pt.created_at
+    `);
+        const rows = stmt.all(featureId);
+        return rows.map(fromDatabase);
+    }
+};
+SQLitePhaseTimingRepository = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], SQLitePhaseTimingRepository);
+export { SQLitePhaseTimingRepository };

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"}