@shepai/cli 1.176.0-pr539.02342cf → 1.177.0

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

@@ -14,9 +14,8 @@ export declare class SQLitePhaseTimingRepository implements IPhaseTimingReposito
     private readonly db;
     constructor(db: Database.Database);
     save(phaseTiming: PhaseTiming): Promise<void>;
-    update(id: string, updates: Partial<Pick<PhaseTiming, 'completedAt' | 'durationMs' | 'inputTokens' | 'outputTokens' | 'cacheCreationInputTokens' | 'cacheReadInputTokens' | 'costUsd' | 'numTurns' | 'durationApiMs' | 'exitCode' | 'errorMessage' | 'originalTokenEstimate' | 'optimizedTokenEstimate' | 'savingsPercent' | 'capabilitiesApplied' | 'outputFilterLinesRemoved' | 'deltaContextFilesSkipped' | 'compressionRatio' | 'aliasesCreated'>>): Promise<void>;
+    update(id: string, updates: Partial<Pick<PhaseTiming, 'completedAt' | 'durationMs' | 'inputTokens' | 'outputTokens' | 'cacheCreationInputTokens' | 'cacheReadInputTokens' | 'costUsd' | 'numTurns' | 'durationApiMs' | 'exitCode' | 'errorMessage'>>): Promise<void>;
     updateApprovalWait(id: string, updates: Partial<Pick<PhaseTiming, 'waitingApprovalAt' | 'approvalWaitMs'>>): Promise<void>;
-    findById(id: string): Promise<PhaseTiming | null>;
     findByRunId(agentRunId: string): Promise<PhaseTiming[]>;
     findByFeatureId(featureId: string): Promise<PhaseTiming[]>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"sqlite-phase-timing.repository.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/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;AA+HpE;;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;IAkC7C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CACd,IAAI,CACF,WAAW,EACT,aAAa,GACb,YAAY,GACZ,aAAa,GACb,cAAc,GACd,0BAA0B,GAC1B,sBAAsB,GACtB,SAAS,GACT,UAAU,GACV,eAAe,GACf,UAAU,GACV,cAAc,GACd,uBAAuB,GACvB,wBAAwB,GACxB,gBAAgB,GAChB,qBAAqB,GACrB,0BAA0B,GAC1B,0BAA0B,GAC1B,kBAAkB,GAClB,gBAAgB,CACnB,CACF,GACA,OAAO,CAAC,IAAI,CAAC;IA8GV,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,GAC1E,OAAO,CAAC,IAAI,CAAC;IA2BV,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAWjD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IASvD,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAWjE"}
+{"version":3,"file":"sqlite-phase-timing.repository.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/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;AA6FpE;;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;IA0B7C,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CACd,IAAI,CACF,WAAW,EACT,aAAa,GACb,YAAY,GACZ,aAAa,GACb,cAAc,GACd,0BAA0B,GAC1B,sBAAsB,GACtB,SAAS,GACT,UAAU,GACV,eAAe,GACf,UAAU,GACV,cAAc,CACjB,CACF,GACA,OAAO,CAAC,IAAI,CAAC;IAsEV,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,GAC1E,OAAO,CAAC,IAAI,CAAC;IA2BV,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/packages/core/src/infrastructure/repositories/sqlite-phase-timing.repository.js

@@ -36,14 +36,6 @@ function toDatabase(timing) {
         duration_api_ms: timing.durationApiMs != null ? Number(timing.durationApiMs) : null,
         exit_code: timing.exitCode ?? null,
         error_message: timing.errorMessage ?? null,
-        original_token_estimate: timing.originalTokenEstimate != null ? Number(timing.originalTokenEstimate) : null,
-        optimized_token_estimate: timing.optimizedTokenEstimate != null ? Number(timing.optimizedTokenEstimate) : null,
-        savings_percent: timing.savingsPercent != null ? Number(timing.savingsPercent) : null,
-        capabilities_applied: timing.capabilitiesApplied ?? null,
-        output_filter_lines_removed: timing.outputFilterLinesRemoved ?? null,
-        delta_context_files_skipped: timing.deltaContextFilesSkipped ?? null,
-        compression_ratio: timing.compressionRatio != null ? Number(timing.compressionRatio) : null,
-        aliases_created: timing.aliasesCreated ?? null,
         created_at: timing.createdAt instanceof Date ? timing.createdAt.getTime() : timing.createdAt,
         updated_at: timing.updatedAt instanceof Date ? timing.updatedAt.getTime() : timing.updatedAt,
     };
@@ -78,22 +70,6 @@ function fromDatabase(row) {
         ...(row.duration_api_ms !== null && { durationApiMs: BigInt(row.duration_api_ms) }),
         ...(row.exit_code !== null && { exitCode: row.exit_code }),
         ...(row.error_message !== null && { errorMessage: row.error_message }),
-        ...(row.original_token_estimate !== null && {
-            originalTokenEstimate: BigInt(row.original_token_estimate),
-        }),
-        ...(row.optimized_token_estimate !== null && {
-            optimizedTokenEstimate: BigInt(row.optimized_token_estimate),
-        }),
-        ...(row.savings_percent !== null && { savingsPercent: row.savings_percent }),
-        ...(row.capabilities_applied !== null && { capabilitiesApplied: row.capabilities_applied }),
-        ...(row.output_filter_lines_removed !== null && {
-            outputFilterLinesRemoved: row.output_filter_lines_removed,
-        }),
-        ...(row.delta_context_files_skipped !== null && {
-            deltaContextFilesSkipped: row.delta_context_files_skipped,
-        }),
-        ...(row.compression_ratio !== null && { compressionRatio: row.compression_ratio }),
-        ...(row.aliases_created !== null && { aliasesCreated: row.aliases_created }),
     };
 }
 /**
@@ -114,10 +90,6 @@ let SQLitePhaseTimingRepository = class SQLitePhaseTimingRepository {
         cache_creation_input_tokens, cache_read_input_tokens,
         cost_usd, num_turns, duration_api_ms,
         exit_code, error_message,
-        original_token_estimate, optimized_token_estimate,
-        savings_percent, capabilities_applied,
-        output_filter_lines_removed, delta_context_files_skipped,
-        compression_ratio, aliases_created,
         created_at, updated_at
       ) VALUES (
         @id, @agent_run_id, @phase, @started_at, @completed_at, @duration_ms,
@@ -126,10 +98,6 @@ let SQLitePhaseTimingRepository = class SQLitePhaseTimingRepository {
         @cache_creation_input_tokens, @cache_read_input_tokens,
         @cost_usd, @num_turns, @duration_api_ms,
         @exit_code, @error_message,
-        @original_token_estimate, @optimized_token_estimate,
-        @savings_percent, @capabilities_applied,
-        @output_filter_lines_removed, @delta_context_files_skipped,
-        @compression_ratio, @aliases_created,
         @created_at, @updated_at
       )
     `);
@@ -186,38 +154,6 @@ let SQLitePhaseTimingRepository = class SQLitePhaseTimingRepository {
             setClauses.push('error_message = @error_message');
             params.error_message = updates.errorMessage;
         }
-        if (updates.originalTokenEstimate !== undefined) {
-            setClauses.push('original_token_estimate = @original_token_estimate');
-            params.original_token_estimate = Number(updates.originalTokenEstimate);
-        }
-        if (updates.optimizedTokenEstimate !== undefined) {
-            setClauses.push('optimized_token_estimate = @optimized_token_estimate');
-            params.optimized_token_estimate = Number(updates.optimizedTokenEstimate);
-        }
-        if (updates.savingsPercent !== undefined) {
-            setClauses.push('savings_percent = @savings_percent');
-            params.savings_percent = Number(updates.savingsPercent);
-        }
-        if (updates.capabilitiesApplied !== undefined) {
-            setClauses.push('capabilities_applied = @capabilities_applied');
-            params.capabilities_applied = updates.capabilitiesApplied;
-        }
-        if (updates.outputFilterLinesRemoved !== undefined) {
-            setClauses.push('output_filter_lines_removed = @output_filter_lines_removed');
-            params.output_filter_lines_removed = updates.outputFilterLinesRemoved;
-        }
-        if (updates.deltaContextFilesSkipped !== undefined) {
-            setClauses.push('delta_context_files_skipped = @delta_context_files_skipped');
-            params.delta_context_files_skipped = updates.deltaContextFilesSkipped;
-        }
-        if (updates.compressionRatio !== undefined) {
-            setClauses.push('compression_ratio = @compression_ratio');
-            params.compression_ratio = Number(updates.compressionRatio);
-        }
-        if (updates.aliasesCreated !== undefined) {
-            setClauses.push('aliases_created = @aliases_created');
-            params.aliases_created = updates.aliasesCreated;
-        }
         const stmt = this.db.prepare(`UPDATE phase_timings SET ${setClauses.join(', ')} WHERE id = @id`);
         stmt.run(params);
     }
@@ -241,14 +177,6 @@ let SQLitePhaseTimingRepository = class SQLitePhaseTimingRepository {
         const stmt = this.db.prepare(`UPDATE phase_timings SET ${setClauses.join(', ')} WHERE id = @id`);
         stmt.run(params);
     }
-    async findById(id) {
-        const stmt = this.db.prepare('SELECT * FROM phase_timings WHERE id = ?');
-        const row = stmt.get(id);
-        if (!row) {
-            return null;
-        }
-        return fromDatabase(row);
-    }
     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);

package/dist/packages/core/src/infrastructure/repositories/sqlite-settings.repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-settings.repository.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/infrastructure/repositories/sqlite-settings.repository.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8EAA8E,CAAC;AACxH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAOjE;;;GAGG;AACH,qBACa,wBAAyB,YAAW,mBAAmB;IACtD,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAElD;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA2FnD;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAgBtC;;;;;OAKG;IACG,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAmGhD"}
+{"version":3,"file":"sqlite-settings.repository.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/infrastructure/repositories/sqlite-settings.repository.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8EAA8E,CAAC;AACxH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAOjE;;;GAGG;AACH,qBACa,wBAAyB,YAAW,mBAAmB;IACtD,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAElD;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAmFnD;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAgBtC;;;;;OAKG;IACG,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CA2FhD"}

package/dist/packages/core/src/infrastructure/repositories/sqlite-settings.repository.js

@@ -73,11 +73,7 @@ let SQLiteSettingsRepository = class SQLiteSettingsRepository {
         interactive_agent_max_concurrent_sessions,
         auto_archive_delay_minutes,
         stage_timeout_fast_implement_ms,
-        fab_position_swapped,
-        skill_injection_enabled, skill_injection_skills,
-        token_opt_enabled, token_opt_output_filtering,
-        token_opt_skill_routing, token_opt_delta_context,
-        token_opt_semantic_compression, token_opt_alias_compression
+        fab_position_swapped
       ) VALUES (
         @id, @created_at, @updated_at,
         @model_analyze, @model_requirements, @model_plan, @model_implement, @model_default,
@@ -109,11 +105,7 @@ let SQLiteSettingsRepository = class SQLiteSettingsRepository {
         @interactive_agent_max_concurrent_sessions,
         @auto_archive_delay_minutes,
         @stage_timeout_fast_implement_ms,
-        @fab_position_swapped,
-        @skill_injection_enabled, @skill_injection_skills,
-        @token_opt_enabled, @token_opt_output_filtering,
-        @token_opt_skill_routing, @token_opt_delta_context,
-        @token_opt_semantic_compression, @token_opt_alias_compression
+        @fab_position_swapped
       )
     `);
         // Execute with named parameters (safe from SQL injection)
@@ -219,15 +211,7 @@ let SQLiteSettingsRepository = class SQLiteSettingsRepository {
         interactive_agent_max_concurrent_sessions = @interactive_agent_max_concurrent_sessions,
         auto_archive_delay_minutes = @auto_archive_delay_minutes,
         stage_timeout_fast_implement_ms = @stage_timeout_fast_implement_ms,
-        fab_position_swapped = @fab_position_swapped,
-        skill_injection_enabled = @skill_injection_enabled,
-        skill_injection_skills = @skill_injection_skills,
-        token_opt_enabled = @token_opt_enabled,
-        token_opt_output_filtering = @token_opt_output_filtering,
-        token_opt_skill_routing = @token_opt_skill_routing,
-        token_opt_delta_context = @token_opt_delta_context,
-        token_opt_semantic_compression = @token_opt_semantic_compression,
-        token_opt_alias_compression = @token_opt_alias_compression
+        fab_position_swapped = @fab_position_swapped
       WHERE id = @id
     `);
         // Execute with named parameters (safe from SQL injection)

package/dist/packages/core/src/infrastructure/services/agents/analyze-repo/analyze-repository-graph.d.ts

@@ -43,7 +43,7 @@ export declare function createAnalyzeRepositoryGraph(executor: IAgentExecutor, c
     repositoryPath?: string | undefined;
     analysisMarkdown?: string | undefined;
     error?: string | undefined;
-}, "analyze" | "__start__", {
+}, "__start__" | "analyze", {
     repositoryPath: {
         (): import("@langchain/langgraph").LastValue<string>;
         (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;

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

@@ -69,7 +69,6 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: number;
     ciFixHistory: import("../../../../domain/index.js").CiFixRecord[];
     ciFixStatus: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted";
-    specFileHashes: Record<string, string>;
 }, {
     featureId?: string | undefined;
     repositoryPath?: string | undefined;
@@ -103,8 +102,7 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts?: number | undefined;
     ciFixHistory?: import("../../../../domain/index.js").CiFixRecord[] | undefined;
     ciFixStatus?: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted" | undefined;
-    specFileHashes?: Record<string, string> | undefined;
-}, "fast-implement" | "__start__", {
+}, "__start__" | "fast-implement", {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
         (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
@@ -157,7 +155,6 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }, {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -211,7 +208,6 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }, import("@langchain/langgraph").StateDefinition, {
     "fast-implement": Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -266,7 +262,6 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
 }, unknown, unknown>;
 //# sourceMappingURL=fast-feature-agent-graph.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fast-feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAGpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGlF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,yBAAyB,GAAG,cAAc,EAC1D,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BnC"}
+{"version":3,"file":"fast-feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAGpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGlF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,yBAAyB,GAAG,cAAc,EAC1D,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BnC"}

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

@@ -56,7 +56,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciFixAttempts: number;
     ciFixHistory: import("../../../../domain/index.js").CiFixRecord[];
     ciFixStatus: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted";
-    specFileHashes: Record<string, string>;
 }, {
     featureId?: string | undefined;
     repositoryPath?: string | undefined;
@@ -90,8 +89,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciFixAttempts?: number | undefined;
     ciFixHistory?: import("../../../../domain/index.js").CiFixRecord[] | undefined;
     ciFixStatus?: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted" | undefined;
-    specFileHashes?: Record<string, string> | undefined;
-}, "analyze" | "requirements" | "research" | "plan" | "implement" | "__start__" | "validate_spec_analyze" | "validate_spec_requirements" | "validate_research" | "validate_plan_tasks" | "repair_spec_analyze" | "repair_spec_requirements" | "repair_research" | "repair_plan_tasks", {
+}, "implement" | "__start__" | "analyze" | "requirements" | "research" | "plan" | "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>;
@@ -144,7 +142,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }, {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -198,7 +195,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }, import("@langchain/langgraph").StateDefinition, {
     analyze: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -253,7 +249,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     requirements: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -308,7 +303,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     research: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -363,7 +357,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     plan: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -418,7 +411,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     implement: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -473,7 +465,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     validate_spec_analyze: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -528,7 +519,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     validate_spec_requirements: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -583,7 +573,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     validate_research: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -638,7 +627,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     validate_plan_tasks: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -693,7 +681,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     repair_spec_analyze: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -748,7 +735,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     repair_spec_requirements: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -803,7 +789,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     repair_research: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -858,7 +843,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
     repair_plan_tasks: Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -913,7 +897,6 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-        specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
     }>>;
 }, unknown, unknown>;
 //# sourceMappingURL=feature-agent-graph.d.ts.map

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,6BAA6B,CAAC;AAclF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAwID;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgFnC"}
+{"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,6BAA6B,CAAC;AAelF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAwJD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsFnC"}

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

@@ -11,7 +11,7 @@ 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, getCompletedPhases, } from './nodes/node-helpers.js';
+import { readSpecFile, safeYamlLoad, createNodeLogger, getCompletedPhases, clearCompletedPhase, } from './nodes/node-helpers.js';
 // Re-export state types for consumers
 export { FeatureAgentAnnotation } from './state.js';
 /**
@@ -33,12 +33,26 @@ function routeReexecution(selfNode, nextNode) {
  * Factory that creates a conditional edge function for validation routing.
  *
  * Routes to successNode on pass, repairNode on fail, throws after maxRetries.
+ *
+ * When retries are exhausted, clears the producer node's completedPhases entry
+ * before throwing. This ensures that on resume, the producer node re-executes
+ * the full agent instead of skipping (because `executeNode` checks
+ * completedPhases). Without this, a phase that produced empty/unfilled output
+ * would be permanently stuck: the repair node can only fix formatting, not
+ * generate content from scratch, and the producer would skip on every retry.
  */
-function routeValidation(successNode, repairNode, maxRetries = 3) {
+function routeValidation(successNode, repairNode, producerNode, maxRetries = 3) {
+    const log = createNodeLogger('routeValidation');
     return (state) => {
         if (state.lastValidationErrors.length === 0)
             return successNode;
         if (state.validationRetries >= maxRetries) {
+            // Clear the producer's completed phase so that on resume the producer
+            // node re-executes the full agent instead of skipping.
+            if (producerNode) {
+                log.info(`Clearing completed phase '${producerNode}' so retry re-runs the agent`);
+                clearCompletedPhase(state.specDir, producerNode, log);
+            }
             throw new Error(`Validation failed after ${maxRetries} repair attempts for '${state.lastValidationTarget}': ${state.lastValidationErrors.join('; ')}`);
         }
         return repairNode;
@@ -174,16 +188,16 @@ export function createFeatureAgentGraph(depsOrExecutor, checkpointer) {
         // --- Edges: linear flow with validation gates ---
         .addEdge(START, 'analyze')
         .addEdge('analyze', 'validate_spec_analyze')
-        .addConditionalEdges('validate_spec_analyze', routeValidation('requirements', 'repair_spec_analyze'))
+        .addConditionalEdges('validate_spec_analyze', routeValidation('requirements', 'repair_spec_analyze', 'analyze'))
         .addEdge('repair_spec_analyze', 'validate_spec_analyze')
         .addConditionalEdges('requirements', routeReexecution('requirements', 'validate_spec_requirements'))
-        .addConditionalEdges('validate_spec_requirements', routeValidation('research', 'repair_spec_requirements'))
+        .addConditionalEdges('validate_spec_requirements', routeValidation('research', 'repair_spec_requirements', 'requirements'))
         .addEdge('repair_spec_requirements', 'validate_spec_requirements')
         .addEdge('research', 'validate_research')
-        .addConditionalEdges('validate_research', routeValidation('plan', 'repair_research'))
+        .addConditionalEdges('validate_research', routeValidation('plan', 'repair_research', 'research'))
         .addEdge('repair_research', 'validate_research')
         .addConditionalEdges('plan', routeReexecution('plan', 'validate_plan_tasks'))
-        .addConditionalEdges('validate_plan_tasks', routeValidation('implement', 'repair_plan_tasks'))
+        .addConditionalEdges('validate_plan_tasks', routeValidation('implement', 'repair_plan_tasks', 'plan'))
         .addEdge('repair_plan_tasks', 'validate_plan_tasks');
     // --- Merge node: wired when deps are provided ---
     if (deps.mergeNodeDeps) {

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;AAgB1B,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAc7F,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,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAkF1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAoT/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;AAiB1B,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAW7F,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,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAkF1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAiU/D"}

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

@@ -11,6 +11,7 @@
 import 'reflect-metadata';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { unlinkSync } from 'node:fs';
 import { Command } from '@langchain/langgraph';
 import { initializeContainer, container } from '../../../di/container.js';
 import { createFeatureAgentGraph } from './feature-agent-graph.js';
@@ -21,7 +22,6 @@ import { initializeSettings } from '../../../services/settings.service.js';
 import { InitializeSettingsUseCase } from '../../../../application/use-cases/settings/initialize-settings.use-case.js';
 import { setHeartbeatContext } from './heartbeat.js';
 import { setPhaseTimingContext, recordLifecycleEvent } from './phase-timing-context.js';
-import { setPromptOptimizationContext } from './prompt-optimization-context.js';
 import { setLifecycleContext } from './lifecycle-context.js';
 import { setLogPrefix, getLogPrefix } from './log-context.js';
 import { UpdateFeatureLifecycleUseCase } from '../../../../application/use-cases/features/update/update-feature-lifecycle.use-case.js';
@@ -230,11 +230,6 @@ export async function runWorker(args) {
     // Set phase timing context so executeNode() records per-phase durations
     const timingRepository = container.resolve('IPhaseTimingRepository');
     setPhaseTimingContext(args.runId, timingRepository);
-    // Set prompt optimization context so executeNode() can run the
-    // token-optimization layer between buildPrompt() and executor.execute().
-    const promptOptimizer = container.resolve('IPromptOptimizerService');
-    const optimizationMetricsService = container.resolve('IOptimizationMetricsService');
-    setPromptOptimizationContext(promptOptimizer, optimizationMetricsService, args.runId, args.featureId);
     // Capture repos for SIGTERM handler
     runRepoForSignal = runRepository;
     timingRepoForSignal = timingRepository;
@@ -279,10 +274,32 @@ export async function runWorker(args) {
             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
-            // from the last successfully checkpointed node.
-            log('Resuming graph from error checkpoint...');
-            result = await graph.invoke({
+            // Resume from error — delete the stale checkpoint and re-invoke from
+            // scratch. Each producer node checks its completedPhases entry and skips
+            // if already done, so completed phases replay instantly. The phase that
+            // failed has its completedPhases entry cleared by routeValidation (or was
+            // never marked complete if the executor threw), so it re-executes fully.
+            //
+            // Why delete the checkpoint instead of resuming from it:
+            // When a validate/repair loop exhausts retries and throws, the checkpoint
+            // captures the validation node with maxed-out retries. Resuming from that
+            // checkpoint would re-evaluate the same conditional edge and throw again
+            // immediately — the user's retry would be stuck in an infinite loop.
+            log('Deleting stale checkpoint for fresh resume...');
+            try {
+                unlinkSync(checkpointPath);
+                log('Checkpoint deleted successfully');
+            }
+            catch {
+                log('No checkpoint to delete (first run or already cleaned)');
+            }
+            // Re-create checkpointer after deleting the old DB
+            const freshCheckpointer = createCheckpointer(checkpointPath);
+            const freshGraph = args.fast
+                ? createFastFeatureAgentGraph(graphDeps, freshCheckpointer)
+                : createFeatureAgentGraph(graphDeps, freshCheckpointer);
+            log('Resuming graph with fresh checkpoint...');
+            result = await freshGraph.invoke({
                 featureId: args.featureId,
                 repositoryPath: args.repo,
                 worktreePath: args.worktreePath ?? args.repo,

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":"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"}
+{"version":3,"file":"node-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/node-helpers.ts"],"names":[],"mappings":"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"}

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

@@ -12,7 +12,6 @@ import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
 import { hasSettings, getSettings } from '../../../../services/settings.service.js';
 import { reportNodeStart } from '../heartbeat.js';
 import { recordPhaseStart, recordPhaseEnd, recordApprovalWaitStart, } from '../phase-timing-context.js';
-import { optimizePromptIfEnabled, recordOptimizationMetricsIfEnabled, } from '../prompt-optimization-context.js';
 import { updateNodeLifecycle } from '../lifecycle-context.js';
 import { getLogPrefix, setCurrentPhase } from '../log-context.js';
 /**
@@ -492,18 +491,7 @@ export function executeNode(nodeName, executor, buildPrompt) {
         }
         const startTime = Date.now();
         const resumePrefix = buildResumeContext(state.resumeReason);
-        const rawPrompt = resumePrefix + buildPrompt(state, log);
-        // Token optimization layer — single interceptor between prompt build
-        // and executor invocation. Falls back to the raw prompt on any error
-        // so optimization failures can never break a phase.
-        const optimization = await optimizePromptIfEnabled(rawPrompt, nodeName, state.model, state.specFileHashes);
-        const prompt = optimization.prompt;
-        if (optimization.metrics) {
-            log.info(`Prompt optimized: ${optimization.metrics.originalTokenEstimate} → ` +
-                `${optimization.metrics.optimizedTokenEstimate} tokens ` +
-                `(${optimization.metrics.savingsPercent.toFixed(1)}% saved, ` +
-                `capabilities=${optimization.metrics.capabilitiesApplied.join(',') || 'none'})`);
-        }
+        const prompt = resumePrefix + buildPrompt(state, log);
         const options = buildExecutorOptions(state, undefined, nodeName);
         // Record phase start with pre-execution metadata
         const timingId = await recordPhaseStart(nodeName, {
@@ -529,9 +517,6 @@ export function executeNode(nodeName, executor, buildPrompt) {
                 durationApiMs: result.usage?.durationApiMs,
                 exitCode: 'success',
             });
-            // Persist optimization metrics on the same phase timing row.
-            // No-op when optimization is disabled or context is not set.
-            await recordOptimizationMetricsIfEnabled(timingId, optimization.metrics);
             // Safety net: undo spec commits if commitSpecs=false
             removeSpecCommitsIfNeeded(state, nodeName, log);
             // Mark phase complete BEFORE interrupting so that on resume the
@@ -543,7 +528,6 @@ export function executeNode(nodeName, executor, buildPrompt) {
                 _approvalAction: null,
                 _rejectionFeedback: null,
                 _needsReexecution: false,
-                specFileHashes: optimization.specFileHashes,
             };
             // Human-in-the-loop: interrupt after node execution for review.
             // This is the ONLY interrupt() call in the entire execution path.

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

@@ -59,7 +59,6 @@ export declare const FeatureAgentAnnotation: import("@langchain/langgraph").Anno
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<CiFixRecord[], CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
-    specFileHashes: import("@langchain/langgraph").BinaryOperatorAggregate<Record<string, string>, Record<string, string>>;
 }>;
 export type FeatureAgentState = typeof FeatureAgentAnnotation.State;
 //# sourceMappingURL=state.d.ts.map