@shepai/cli 1.98.0 → 1.99.0

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

@@ -14,7 +14,7 @@ export interface FeatureAgentGraphDeps {
  * Factory function that creates and compiles the feature-agent LangGraph.
  *
  * The graph defines a linear SDLC workflow with validation gates:
- *   analyze → validate → requirements → validate → research → validate → plan → validate → implement → merge
+ *   analyze → validate → requirements → validate → research → validate → plan → validate → implement (+ evidence sub-agent) → merge
  *
  * Each YAML-producing node is followed by a validate/repair loop that ensures
  * the output YAML conforms to its schema before proceeding.
@@ -45,6 +45,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciStatus: string | null;
     push: boolean;
     openPr: boolean;
+    evidence: import("../../../../domain/index.js").Evidence[];
     ciFixAttempts: number;
     ciFixHistory: import("../../../../domain/index.js").CiFixRecord[];
     ciFixStatus: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted";
@@ -70,6 +71,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciStatus?: string | null | undefined;
     push?: boolean | undefined;
     openPr?: boolean | undefined;
+    evidence?: import("../../../../domain/index.js").Evidence[] | undefined;
     ciFixAttempts?: number | undefined;
     ciFixHistory?: import("../../../../domain/index.js").CiFixRecord[] | undefined;
     ciFixStatus?: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted" | undefined;
@@ -115,6 +117,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
     push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
     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">;
@@ -160,6 +163,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
     ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
     push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
     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">;
@@ -206,6 +210,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -252,6 +257,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -298,6 +304,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -344,6 +351,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -390,6 +398,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -436,6 +445,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -482,6 +492,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -528,6 +539,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -574,6 +586,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -620,6 +633,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -666,6 +680,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -712,6 +727,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;
@@ -758,6 +774,7 @@ export declare function createFeatureAgentGraph(depsOrExecutor: FeatureAgentGrap
         ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
         push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
         openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
         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">;

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;AASlF,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;AAyHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwEnC"}
+{"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;AASlF,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;AAyHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwEnC"}

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

@@ -123,7 +123,7 @@ function createPlanTasksValidator() {
  * Factory function that creates and compiles the feature-agent LangGraph.
  *
  * The graph defines a linear SDLC workflow with validation gates:
- *   analyze → validate → requirements → validate → research → validate → plan → validate → implement → merge
+ *   analyze → validate → requirements → validate → research → validate → plan → validate → implement (+ evidence sub-agent) → merge
  *
  * Each YAML-producing node is followed by a validate/repair loop that ensures
  * the output YAML conforms to its schema before proceeding.

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence-output-parser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Evidence Output Parser
+ *
+ * Extracts structured Evidence records from free-form agent text output.
+ * Looks for a fenced JSON code block containing an array of evidence objects.
+ * Returns empty array gracefully on any parsing failure.
+ */
+import type { Evidence } from '../../../../../domain/generated/output.js';
+/**
+ * Extract Evidence records from agent text output.
+ * Looks for a fenced JSON code block containing a JSON array of evidence objects.
+ * Returns empty array when no block found, JSON is malformed, or no valid records exist.
+ */
+export declare function parseEvidenceRecords(output: string): Evidence[];
+//# sourceMappingURL=evidence-output-parser.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence-output-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-output-parser.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence-output-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAwB1E;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CAc/D"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence-output-parser.js

@@ -0,0 +1,48 @@
+/**
+ * Evidence Output Parser
+ *
+ * Extracts structured Evidence records from free-form agent text output.
+ * Looks for a fenced JSON code block containing an array of evidence objects.
+ * Returns empty array gracefully on any parsing failure.
+ */
+import { EvidenceType } from '../../../../../domain/generated/output.js';
+// Matches a fenced JSON code block: ```json ... ```
+const JSON_BLOCK_RE = /```json\s*\n([\s\S]*?)\n\s*```/;
+const VALID_EVIDENCE_TYPES = new Set(Object.values(EvidenceType));
+function isValidRecord(record) {
+    if (record === null || typeof record !== 'object')
+        return false;
+    const r = record;
+    if (typeof r.type !== 'string' || !VALID_EVIDENCE_TYPES.has(r.type))
+        return false;
+    if (typeof r.capturedAt !== 'string')
+        return false;
+    if (typeof r.description !== 'string')
+        return false;
+    if (typeof r.relativePath !== 'string')
+        return false;
+    // Block path traversal
+    if (r.relativePath.includes('..'))
+        return false;
+    return true;
+}
+/**
+ * Extract Evidence records from agent text output.
+ * Looks for a fenced JSON code block containing a JSON array of evidence objects.
+ * Returns empty array when no block found, JSON is malformed, or no valid records exist.
+ */
+export function parseEvidenceRecords(output) {
+    const match = output.match(JSON_BLOCK_RE);
+    if (!match)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(match[1]);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter(isValidRecord);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Evidence Node — Agent-Directed Evidence Collection
+ *
+ * Captures visual and textual evidence (screenshots, test outputs,
+ * terminal recordings) proving that implemented tasks work as expected.
+ * Evidence files are committed to .shep/evidence/ on the feature branch
+ * and evidence records flow through graph state to the merge node for
+ * inclusion in the PR body.
+ *
+ * Uses a custom node pattern (not executeNode) because it needs a
+ * post-execution parsing step to extract Evidence[] from the agent's
+ * text output via parseEvidenceRecords. Reuses the same helpers as
+ * other nodes (createNodeLogger, buildExecutorOptions, retryExecute,
+ * getCompletedPhases, markPhaseComplete).
+ *
+ * Graceful degradation (FR-8): parse failures return empty evidence
+ * array and log a warning. Evidence failures never block the merge.
+ */
+import type { IAgentExecutor } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
+import type { FeatureAgentState } from '../state.js';
+/**
+ * Factory that creates the evidence collection node function.
+ *
+ * @param executor - Agent executor for running the evidence capture prompt
+ * @returns A LangGraph node function
+ */
+export declare function createEvidenceNode(executor: IAgentExecutor): (state: FeatureAgentState) => Promise<Partial<FeatureAgentState>>;
+//# sourceMappingURL=evidence.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAEpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAerD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,IAG3C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAsE7E"}

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

@@ -0,0 +1,98 @@
+/**
+ * Evidence Node — Agent-Directed Evidence Collection
+ *
+ * Captures visual and textual evidence (screenshots, test outputs,
+ * terminal recordings) proving that implemented tasks work as expected.
+ * Evidence files are committed to .shep/evidence/ on the feature branch
+ * and evidence records flow through graph state to the merge node for
+ * inclusion in the PR body.
+ *
+ * Uses a custom node pattern (not executeNode) because it needs a
+ * post-execution parsing step to extract Evidence[] from the agent's
+ * text output via parseEvidenceRecords. Reuses the same helpers as
+ * other nodes (createNodeLogger, buildExecutorOptions, retryExecute,
+ * getCompletedPhases, markPhaseComplete).
+ *
+ * Graceful degradation (FR-8): parse failures return empty evidence
+ * array and log a warning. Evidence failures never block the merge.
+ */
+import { isGraphBubbleUp } from '@langchain/langgraph';
+import { createNodeLogger, getCompletedPhases, markPhaseComplete, retryExecute, buildExecutorOptions, } from './node-helpers.js';
+import { reportNodeStart } from '../heartbeat.js';
+import { recordPhaseStart, recordPhaseEnd } from '../phase-timing-context.js';
+import { updateNodeLifecycle } from '../lifecycle-context.js';
+import { buildEvidencePrompt } from './prompts/evidence-prompts.js';
+import { parseEvidenceRecords } from './evidence-output-parser.js';
+import { hasSettings, getSettings } from '../../../settings.service.js';
+/**
+ * Factory that creates the evidence collection node function.
+ *
+ * @param executor - Agent executor for running the evidence capture prompt
+ * @returns A LangGraph node function
+ */
+export function createEvidenceNode(executor) {
+    const log = createNodeLogger('evidence');
+    return async (state) => {
+        log.info('Starting evidence collection');
+        reportNodeStart('evidence');
+        await updateNodeLifecycle('evidence');
+        // --- Resume support: skip if already completed ---
+        const completedPhases = getCompletedPhases(state.specDir);
+        if (completedPhases.includes('evidence')) {
+            log.info('Evidence phase already completed, skipping execution');
+            return {
+                currentNode: 'evidence',
+                messages: ['[evidence] Already completed — skipping'],
+                _needsReexecution: false,
+            };
+        }
+        const startTime = Date.now();
+        const timingId = await recordPhaseStart('evidence');
+        try {
+            const commitEvidence = hasSettings() && getSettings().workflow.commitEvidence;
+            const prompt = buildEvidencePrompt(state, { commitEvidence });
+            const options = buildExecutorOptions(state);
+            log.info(`Executing agent at cwd=${options.cwd}`);
+            log.info(`Prompt length: ${prompt.length} chars`);
+            const result = await retryExecute(executor, prompt, options, { logger: log });
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
+            log.info(`Agent complete (${result.result.length} chars, ${elapsed}s)`);
+            // --- Parse evidence records from agent output (graceful degradation) ---
+            let evidence;
+            try {
+                evidence = parseEvidenceRecords(result.result);
+                log.info(`Parsed ${evidence.length} evidence record(s)`);
+            }
+            catch (parseErr) {
+                const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+                log.error(`Warning: evidence parsing failed: ${msg} — continuing with empty evidence`);
+                evidence = [];
+            }
+            await recordPhaseEnd(timingId, durationMs);
+            markPhaseComplete(state.specDir, 'evidence', log);
+            return {
+                currentNode: 'evidence',
+                evidence,
+                messages: [
+                    `[evidence] Complete — ${evidence.length} evidence record(s) captured (${elapsed}s)`,
+                    ...(evidence.length === 0
+                        ? ['[evidence] Warning: no evidence records parsed from agent output']
+                        : []),
+                ],
+                _needsReexecution: false,
+            };
+        }
+        catch (err) {
+            // Re-throw LangGraph control-flow exceptions (interrupt, Command, etc.)
+            if (isGraphBubbleUp(err))
+                throw err;
+            const message = err instanceof Error ? err.message : String(err);
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
+            log.error(`Evidence collection failed: ${message} (${elapsed}s)`);
+            await recordPhaseEnd(timingId, durationMs);
+            throw new Error(`[evidence] ${message}`);
+        }
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"fast-implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/fast-implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,IAGhD,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAwC7E"}
+{"version":3,"file":"fast-implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/fast-implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAEpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAUrD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,IAGhD,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAmD7E"}

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

@@ -9,12 +9,17 @@
  * Follows the same factory pattern as other nodes: takes executor
  * dependency, returns async (state) => Partial<FeatureAgentState>.
  */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 import { isGraphBubbleUp } from '@langchain/langgraph';
 import { createNodeLogger, buildExecutorOptions, retryExecute } from './node-helpers.js';
 import { reportNodeStart } from '../heartbeat.js';
 import { recordPhaseStart, recordPhaseEnd } from '../phase-timing-context.js';
 import { updateNodeLifecycle } from '../lifecycle-context.js';
 import { buildFastImplementPrompt } from './prompts/fast-implement.prompt.js';
+import { buildEvidencePrompt } from './prompts/evidence-prompts.js';
+import { parseEvidenceRecords } from './evidence-output-parser.js';
+import { hasSettings, getSettings } from '../../../settings.service.js';
 /**
  * Factory that creates the fast-implement node function.
  *
@@ -38,10 +43,20 @@ export function createFastImplementNode(executor) {
             const durationMs = Date.now() - startTime;
             const elapsed = (durationMs / 1000).toFixed(1);
             log.info(`Complete (${result.result.length} chars, ${elapsed}s)`);
+            // --- Evidence sub-agent: capture proof of completion (settings-gated) ---
+            const evidenceEnabled = hasSettings() && getSettings().workflow.enableEvidence;
+            const evidence = evidenceEnabled ? await collectEvidence(executor, state, log) : [];
+            if (!evidenceEnabled) {
+                log.info('Evidence collection disabled via settings — skipping');
+            }
             await recordPhaseEnd(timingId, durationMs);
             return {
                 currentNode: 'fast-implement',
-                messages: [`[fast-implement] Complete (${result.result.length} chars, ${elapsed}s)`],
+                evidence,
+                messages: [
+                    `[fast-implement] Complete (${result.result.length} chars, ${elapsed}s)`,
+                    `[fast-implement] Evidence: ${evidence.length} record(s) captured`,
+                ],
                 _needsReexecution: false,
             };
         }
@@ -58,3 +73,56 @@ export function createFastImplementNode(executor) {
         }
     };
 }
+/**
+ * Sub-agent call to collect evidence after fast implementation completes.
+ * Graceful degradation: returns empty array on any failure so evidence
+ * collection never blocks the workflow.
+ */
+async function collectEvidence(executor, state, log) {
+    try {
+        log.info('Collecting evidence (sub-agent)');
+        const commitEvidence = hasSettings() && getSettings().workflow.commitEvidence;
+        const prompt = buildEvidencePrompt(state, { commitEvidence });
+        const options = buildExecutorOptions(state);
+        const result = await retryExecute(executor, prompt, options, { logger: log });
+        try {
+            const evidence = parseEvidenceRecords(result.result);
+            log.info(`Parsed ${evidence.length} evidence record(s)`);
+            saveEvidenceManifest(state, evidence, log);
+            return evidence;
+        }
+        catch (parseErr) {
+            const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+            log.error(`Warning: evidence parsing failed: ${msg} — continuing with empty evidence`);
+            return [];
+        }
+    }
+    catch (err) {
+        // Re-throw LangGraph control-flow exceptions
+        if (isGraphBubbleUp(err))
+            throw err;
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`Evidence collection failed: ${msg} — continuing without evidence`);
+        return [];
+    }
+}
+/**
+ * Save evidence manifest to the shep home evidence folder so the
+ * merge review UI can read it without accessing graph state.
+ */
+function saveEvidenceManifest(state, evidence, log) {
+    if (evidence.length === 0)
+        return;
+    try {
+        const cwd = state.worktreePath || state.repositoryPath;
+        const repoHashDir = dirname(dirname(cwd));
+        const evidenceDir = join(repoHashDir, 'evidence', state.featureId);
+        mkdirSync(evidenceDir, { recursive: true });
+        writeFileSync(join(evidenceDir, 'manifest.json'), JSON.stringify(evidence, null, 2), 'utf-8');
+        log.info(`Saved evidence manifest to ${evidenceDir}/manifest.json`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`Failed to save evidence manifest: ${msg}`);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAqErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAgL7E"}
+{"version":3,"file":"implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAEpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAwErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAwL7E"}

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

@@ -7,14 +7,17 @@
  * feature.yaml between phases.
  */
 import yaml from 'js-yaml';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
 import { createNodeLogger, readSpecFile, buildExecutorOptions, shouldInterrupt, safeYamlLoad, retryExecute, getCompletedPhases, markPhaseComplete, } from './node-helpers.js';
 import { reportNodeStart } from '../heartbeat.js';
 import { recordPhaseStart, recordPhaseEnd, recordApprovalWaitStart, } from '../phase-timing-context.js';
 import { updateNodeLifecycle } from '../lifecycle-context.js';
 import { buildImplementPhasePrompt, } from './prompts/implement.prompt.js';
+import { buildEvidencePrompt } from './prompts/evidence-prompts.js';
+import { parseEvidenceRecords } from './evidence-output-parser.js';
+import { hasSettings, getSettings } from '../../../settings.service.js';
 /**
  * Update feature.yaml with current implementation progress.
  * Silently no-ops if the file is missing or unparseable.
@@ -141,6 +144,13 @@ export function createImplementNode(executor) {
             log.info(`All phases complete — ${completedTasks}/${totalTasks} tasks (${elapsed}s)`);
             updateFeatureProgress(state.specDir, totalTasks, totalTasks, 'implementation-complete', null, log);
             messages.push(`[implement] Complete: ${totalTasks} tasks across ${totalPhases} phases (${elapsed}s)`);
+            // --- Evidence sub-agent: capture proof of completion (settings-gated) ---
+            const evidenceEnabled = hasSettings() && getSettings().workflow.enableEvidence;
+            const evidence = evidenceEnabled ? await collectEvidence(executor, state, log) : [];
+            if (!evidenceEnabled) {
+                log.info('Evidence collection disabled via settings — skipping');
+            }
+            messages.push(`[implement] Evidence: ${evidence.length} record(s) captured`);
             // Record top-level implement phase completion
             await recordPhaseEnd(implementTimingId, Date.now() - startTime);
             if (shouldInterrupt('implement', state.approvalGates)) {
@@ -151,7 +161,7 @@ export function createImplementNode(executor) {
                     message: `Implementation complete: ${totalTasks} tasks across ${totalPhases} phases. Approve to finish.`,
                 });
             }
-            return { currentNode: 'implement', messages };
+            return { currentNode: 'implement', evidence, messages };
         }
         catch (err) {
             if (isGraphBubbleUp(err))
@@ -168,3 +178,58 @@ export function createImplementNode(executor) {
         }
     };
 }
+/**
+ * Sub-agent call to collect evidence after implementation completes.
+ * Graceful degradation: returns empty array on any failure so evidence
+ * collection never blocks the workflow.
+ */
+async function collectEvidence(executor, state, log) {
+    try {
+        log.info('Collecting evidence (sub-agent)');
+        const commitEvidence = hasSettings() && getSettings().workflow.commitEvidence;
+        const prompt = buildEvidencePrompt(state, { commitEvidence });
+        const options = buildExecutorOptions(state);
+        const result = await retryExecute(executor, prompt, options, { logger: log });
+        try {
+            const evidence = parseEvidenceRecords(result.result);
+            log.info(`Parsed ${evidence.length} evidence record(s)`);
+            saveEvidenceManifest(state, evidence, log);
+            return evidence;
+        }
+        catch (parseErr) {
+            const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+            log.error(`Warning: evidence parsing failed: ${msg} — continuing with empty evidence`);
+            return [];
+        }
+    }
+    catch (err) {
+        // Re-throw LangGraph control-flow exceptions
+        if (isGraphBubbleUp(err))
+            throw err;
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`Evidence collection failed: ${msg} — continuing without evidence`);
+        return [];
+    }
+}
+/**
+ * Save evidence manifest to the shep home evidence folder so the
+ * merge review UI can read it without accessing graph state.
+ */
+function saveEvidenceManifest(state, evidence, log) {
+    if (evidence.length === 0)
+        return;
+    try {
+        const cwd = state.worktreePath || state.repositoryPath;
+        // Worktree path: ~/.shep/repos/<hash>/wt/<slug>
+        // Evidence dir:  ~/.shep/repos/<hash>/evidence/<featureId>/
+        const repoHashDir = dirname(dirname(cwd));
+        const evidenceDir = join(repoHashDir, 'evidence', state.featureId);
+        mkdirSync(evidenceDir, { recursive: true });
+        writeFileSync(join(evidenceDir, 'manifest.json'), JSON.stringify(evidence, null, 2), 'utf-8');
+        log.info(`Saved evidence manifest to ${evidenceDir}/manifest.json`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`Failed to save evidence manifest: ${msg}`);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"merge.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge/merge.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yEAAyE,CAAC;AAClH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACd,MAAM,iEAAiE,CAAC;AAkBzE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uEAAuE,CAAC;AAE3H,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1E,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC;IACnE;;;OAGG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1F,YAAY,EAAE,aAAa,CAAC;IAC5B,6BAA6B,EAAE,IAAI,CAAC,6BAA6B,EAAE,SAAS,CAAC,CAAC;CAC/E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,IAGnC,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CA0Q7E"}
+{"version":3,"file":"merge.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge/merge.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yEAAyE,CAAC;AAClH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACd,MAAM,iEAAiE,CAAC;AAkBzE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uEAAuE,CAAC;AAE3H,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1E,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC;IACnE;;;OAGG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1F,YAAY,EAAE,aAAa,CAAC;IAC5B,6BAA6B,EAAE,IAAI,CAAC,6BAA6B,EAAE,SAAS,CAAC,CAAC;CAC/E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,IAGnC,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAmR7E"}

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

@@ -82,6 +82,9 @@ export function createMergeNode(deps) {
             let ciFixStatus = state.ciFixStatus ?? 'idle';
             // --- Check for git remote (needed by both agent calls) ---
             const remoteAvailable = await deps.hasRemote(cwd);
+            const repoUrl = remoteAvailable
+                ? ((await deps.gitPrService.getRemoteUrl(cwd)) ?? undefined)
+                : undefined;
             // --- Agent Call 1: Commit + Push + PR (skip on approval resume) ---
             if (!isResumeAfterInterrupt) {
                 if (!remoteAvailable) {
@@ -89,7 +92,7 @@ export function createMergeNode(deps) {
                 }
                 const effectiveState = remoteAvailable ? state : { ...state, push: false, openPr: false };
                 log.info('Agent call 1: commit + push + PR');
-                const commitPushPrPrompt = buildCommitPushPrPrompt(effectiveState, branch, baseBranch);
+                const commitPushPrPrompt = buildCommitPushPrPrompt(effectiveState, branch, baseBranch, repoUrl);
                 const commitResult = await retryExecute(executor, commitPushPrPrompt, options, {
                     logger: log,
                 });
@@ -162,6 +165,7 @@ export function createMergeNode(deps) {
                         prUrl,
                         prNumber,
                         ciStatus,
+                        evidence: state.evidence ?? [],
                     });
                 }
             }