@shepai/cli 1.130.0 → 1.130.1-pr419.86475da

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

@@ -6,8 +6,10 @@
  * Returns empty array gracefully on any parsing failure.
  *
  * Also provides validation to ensure UI-related evidence includes app-level
- * proof (not just Storybook screenshots).
+ * proof (not just Storybook screenshots), evidence completeness by task type,
+ * and file existence verification.
  */
+import { stat } from 'node:fs/promises';
 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*```/;
@@ -117,3 +119,121 @@ export function validateUiEvidenceHasAppProof(evidence) {
         warnings,
     };
 }
+// Keyword patterns for task type inference (compiled once at module level)
+const UI_KEYWORDS = /\b(component|ui|page|style|layout|markup|visual)\b/i;
+const TEST_KEYWORDS = /\b(tests?|specs?|unit tests?|integration tests?)\b/i;
+const CLI_KEYWORDS = /\b(cli|command|terminal|shell)\b/i;
+/**
+ * Infer task types from a task's description, acceptance criteria, and tdd field.
+ * Returns an array of inferred types. Tasks can have multiple types.
+ * Tasks without clear signals return an empty array (no completeness requirement).
+ */
+export function inferTaskTypes(task) {
+    const types = new Set();
+    const textSources = [task.description, ...task.acceptanceCriteria];
+    const combined = textSources.join(' ');
+    if (UI_KEYWORDS.test(combined)) {
+        types.add('ui');
+    }
+    if (TEST_KEYWORDS.test(combined) || task.tdd !== null) {
+        types.add('test');
+    }
+    if (CLI_KEYWORDS.test(combined)) {
+        types.add('cli');
+    }
+    return [...types];
+}
+/**
+ * Validate evidence completeness against task requirements.
+ * Checks three dimensions:
+ * 1. UI tasks have app-level screenshots (not just Storybook)
+ * 2. Test tasks have TestOutput evidence
+ * 3. CLI tasks have TerminalRecording evidence
+ *
+ * Pure function — no side effects, no I/O.
+ */
+export function validateEvidenceCompleteness(evidence, tasks) {
+    const errors = [];
+    for (const task of tasks) {
+        const types = inferTaskTypes(task);
+        if (types.includes('ui')) {
+            // Check for app-level screenshots (not just Storybook)
+            const screenshots = evidence.filter(isScreenshot);
+            const appScreenshots = screenshots.filter(isAppEvidence);
+            if (appScreenshots.length === 0) {
+                errors.push({
+                    type: 'ui',
+                    taskId: task.id,
+                    taskTitle: task.title,
+                    message: `Missing app-level screenshot for ${task.id} (UI task '${task.title}'). Storybook-only screenshots are insufficient.`,
+                });
+            }
+        }
+        if (types.includes('test')) {
+            const hasTestOutput = evidence.some((e) => e.type === EvidenceType.TestOutput);
+            if (!hasTestOutput) {
+                errors.push({
+                    type: 'completeness',
+                    taskId: task.id,
+                    taskTitle: task.title,
+                    message: `No TestOutput evidence for ${task.id} (test task '${task.title}'). Test results are required.`,
+                });
+            }
+        }
+        if (types.includes('cli')) {
+            const hasTerminalRecording = evidence.some((e) => e.type === EvidenceType.TerminalRecording);
+            if (!hasTerminalRecording) {
+                errors.push({
+                    type: 'completeness',
+                    taskId: task.id,
+                    taskTitle: task.title,
+                    message: `No TerminalRecording evidence for ${task.id} (CLI task '${task.title}'). Terminal output is required.`,
+                });
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Verify that each Evidence record's file exists on disk with non-zero size.
+ * Returns an array of error messages for missing or empty files.
+ * Never throws — all errors are caught and returned as strings (NFR-10).
+ */
+export async function validateFileExistence(evidence) {
+    if (evidence.length === 0)
+        return [];
+    const results = await Promise.all(evidence.map(async (e) => {
+        try {
+            const stats = await stat(e.relativePath);
+            if (stats.size === 0) {
+                return `Evidence file has zero size: ${e.relativePath} (${e.description})`;
+            }
+            return null;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                return `Evidence file not found: ${e.relativePath} (${e.description})`;
+            }
+            if (code === 'EACCES') {
+                return `Evidence file not accessible (permission denied): ${e.relativePath} (${e.description})`;
+            }
+            return `Evidence file error: ${e.relativePath} (${e.description}) — ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }));
+    return results.filter((r) => r !== null);
+}
+/**
+ * Full validation pipeline: runs completeness checks and file existence checks,
+ * returns a unified ValidationResult with all detected issues.
+ */
+export async function validateEvidence(evidence, tasks) {
+    const completenessResult = validateEvidenceCompleteness(evidence, tasks);
+    const fileErrors = await validateFileExistence(evidence);
+    const fileValidationErrors = fileErrors.map((msg) => ({
+        type: 'fileExistence',
+        message: msg,
+    }));
+    const allErrors = [...completenessResult.errors, ...fileValidationErrors];
+    return { valid: allErrors.length === 0, errors: allErrors };
+}

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

@@ -13,8 +13,12 @@
  * 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.
+ * Includes a validation loop that inspects Evidence[] for quality and
+ * completeness after each collection attempt. If validation fails, the
+ * agent is retried with structured feedback about what's missing. After
+ * exhausting retries, the system proceeds with partial evidence (FR-8
+ * graceful degradation). Each attempt is recorded as a separate phase
+ * activity (evidence:attempt-N) for timing visibility.
  */
 import type { IAgentExecutor } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
 import type { FeatureAgentState } from '../state.js';

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

@@ -1 +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,CAkG7E"}
+{"version":3,"file":"evidence.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/evidence.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAEpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAoDrD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,IAG3C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAmJ7E"}

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

@@ -13,17 +13,51 @@
  * 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.
+ * Includes a validation loop that inspects Evidence[] for quality and
+ * completeness after each collection attempt. If validation fails, the
+ * agent is retried with structured feedback about what's missing. After
+ * exhausting retries, the system proceeds with partial evidence (FR-8
+ * graceful degradation). Each attempt is recorded as a separate phase
+ * activity (evidence:attempt-N) for timing visibility.
  */
+import yaml from 'js-yaml';
 import { isGraphBubbleUp } from '@langchain/langgraph';
-import { createNodeLogger, getCompletedPhases, markPhaseComplete, retryExecute, buildExecutorOptions, } from './node-helpers.js';
+import { createNodeLogger, getCompletedPhases, markPhaseComplete, readSpecFile, 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, validateUiEvidenceHasAppProof } from './evidence-output-parser.js';
+import { buildEvidencePrompt, buildEvidenceRetryPrompt } from './prompts/evidence-prompts.js';
+import { parseEvidenceRecords, validateUiEvidenceHasAppProof, validateEvidence, } from './evidence-output-parser.js';
 import { hasSettings, getSettings } from '../../../settings.service.js';
+const DEFAULT_MAX_RETRIES = 3;
+/**
+ * Parse tasks.yaml into TaskForValidation[] for evidence completeness checking.
+ * Returns empty array if tasks.yaml is missing or unparseable.
+ */
+function parseTasks(specDir) {
+    const content = readSpecFile(specDir, 'tasks.yaml');
+    if (!content)
+        return [];
+    try {
+        const data = yaml.load(content);
+        if (!data?.tasks || !Array.isArray(data.tasks))
+            return [];
+        return data.tasks
+            .filter((t) => t !== null && typeof t === 'object')
+            .map((t) => ({
+            id: String(t.id ?? ''),
+            title: String(t.title ?? ''),
+            description: String(t.description ?? ''),
+            acceptanceCriteria: Array.isArray(t.acceptanceCriteria)
+                ? t.acceptanceCriteria.map(String)
+                : [],
+            tdd: t.tdd != null ? t.tdd : null,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Factory that creates the evidence collection node function.
  *
@@ -47,79 +81,109 @@ export function createEvidenceNode(executor) {
                 _needsReexecution: false,
             };
         }
-        const startTime = Date.now();
-        const commitEvidence = hasSettings() && getSettings().workflow.commitEvidence;
-        const prompt = buildEvidencePrompt(state, { commitEvidence });
-        const timingId = await recordPhaseStart('evidence', {
-            prompt,
-            modelId: state.model,
-            agentType: executor.agentType,
-        });
-        try {
-            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;
+        // --- Configuration ---
+        const settings = hasSettings() ? getSettings() : undefined;
+        const commitEvidence = settings?.workflow.commitEvidence ?? false;
+        const maxRetries = settings?.workflow.evidenceRetries ?? DEFAULT_MAX_RETRIES;
+        const options = buildExecutorOptions(state);
+        const tasks = parseTasks(state.specDir);
+        // --- Validation retry loop ---
+        let allEvidence = [];
+        const allMessages = [];
+        let attempt = 0;
+        let lastErrors = [];
+        while (attempt < maxRetries) {
+            attempt++;
+            const attemptStart = Date.now();
+            // Build prompt: base for first attempt, retry with feedback for subsequent
+            const prompt = attempt === 1
+                ? buildEvidencePrompt(state, { commitEvidence })
+                : buildEvidenceRetryPrompt(state, lastErrors, { commitEvidence });
+            const timingId = await recordPhaseStart(`evidence:attempt-${attempt}`, {
+                prompt,
+                modelId: state.model,
+                agentType: executor.agentType,
+            });
             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 = [];
-            }
-            // --- Validate UI evidence includes app-level proof ---
-            const validationResult = validateUiEvidenceHasAppProof(evidence);
-            const validationMessages = [];
-            if (validationResult.warnings.length > 0) {
-                for (const warning of validationResult.warnings) {
-                    log.error(`Evidence validation: ${warning}`);
-                    validationMessages.push(`[evidence] Warning: ${warning}`);
+                log.info(`Attempt ${attempt}/${maxRetries}: executing agent at cwd=${options.cwd}`);
+                const result = await retryExecute(executor, prompt, options, { logger: log });
+                const durationMs = Date.now() - attemptStart;
+                const elapsed = (durationMs / 1000).toFixed(1);
+                log.info(`Attempt ${attempt}: agent complete (${result.result.length} chars, ${elapsed}s)`);
+                // --- Parse evidence records (graceful degradation) ---
+                let evidence;
+                try {
+                    evidence = parseEvidenceRecords(result.result);
+                    log.info(`Attempt ${attempt}: parsed ${evidence.length} evidence record(s)`);
+                }
+                catch (parseErr) {
+                    const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+                    log.error(`Attempt ${attempt}: evidence parsing failed: ${msg} — continuing with empty evidence`);
+                    evidence = [];
+                }
+                // Accumulate evidence from all attempts (FR-11)
+                allEvidence = [...allEvidence, ...evidence];
+                // --- Validate UI evidence (informational warnings) ---
+                const uiResult = validateUiEvidenceHasAppProof(evidence);
+                if (uiResult.warnings.length > 0) {
+                    for (const warning of uiResult.warnings) {
+                        log.error(`Evidence validation: ${warning}`);
+                        allMessages.push(`[evidence] Warning: ${warning}`);
+                    }
+                }
+                // --- Validate evidence completeness + file existence ---
+                const validationResult = await validateEvidence(allEvidence, tasks);
+                await recordPhaseEnd(timingId, Date.now() - attemptStart, {
+                    inputTokens: result.usage?.inputTokens,
+                    outputTokens: result.usage?.outputTokens,
+                    cacheCreationInputTokens: result.usage?.cacheCreationInputTokens,
+                    cacheReadInputTokens: result.usage?.cacheReadInputTokens,
+                    costUsd: result.usage?.costUsd,
+                    numTurns: result.usage?.numTurns,
+                    durationApiMs: result.usage?.durationApiMs,
+                    exitCode: validationResult.valid ? 'success' : 'error',
+                });
+                if (validationResult.valid) {
+                    log.info(`Attempt ${attempt}: validation passed`);
+                    break;
+                }
+                // Validation failed
+                lastErrors = validationResult.errors;
+                const errorSummary = validationResult.errors.map((e) => e.message).join('; ');
+                if (attempt < maxRetries) {
+                    log.error(`Attempt ${attempt}: validation failed (${validationResult.errors.length} errors), retrying — ${errorSummary}`);
+                }
+                else {
+                    // Exhausted retries — graceful degradation (FR-8)
+                    log.error(`Attempt ${attempt}: validation failed after ${maxRetries} attempts — proceeding with partial evidence`);
+                    allMessages.push(`[evidence] Warning: Validation failed after ${maxRetries} retries: ${errorSummary}`);
                 }
             }
-            await recordPhaseEnd(timingId, durationMs, {
-                inputTokens: result.usage?.inputTokens,
-                outputTokens: result.usage?.outputTokens,
-                cacheCreationInputTokens: result.usage?.cacheCreationInputTokens,
-                cacheReadInputTokens: result.usage?.cacheReadInputTokens,
-                costUsd: result.usage?.costUsd,
-                numTurns: result.usage?.numTurns,
-                durationApiMs: result.usage?.durationApiMs,
-                exitCode: 'success',
-            });
-            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']
-                        : []),
-                    ...validationMessages,
-                ],
-                _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, {
-                exitCode: 'error',
-                errorMessage: message.slice(0, 1000),
-            });
-            throw new Error(`[evidence] ${message}`);
+            catch (err) {
+                const durationMs = Date.now() - attemptStart;
+                await recordPhaseEnd(timingId, durationMs, {
+                    exitCode: 'error',
+                    errorMessage: (err instanceof Error ? err.message : String(err)).slice(0, 1000),
+                });
+                // Re-throw LangGraph control-flow exceptions
+                if (isGraphBubbleUp(err))
+                    throw err;
+                // Non-retryable executor error — propagate immediately
+                const message = err instanceof Error ? err.message : String(err);
+                log.error(`Attempt ${attempt}: evidence collection failed: ${message}`);
+                throw new Error(`[evidence] ${message}`);
+            }
         }
+        markPhaseComplete(state.specDir, 'evidence', log);
+        allMessages.unshift(`[evidence] Complete — ${allEvidence.length} evidence record(s) captured in ${attempt} attempt(s)`, ...(allEvidence.length === 0
+            ? ['[evidence] Warning: no evidence records parsed from agent output']
+            : []));
+        return {
+            currentNode: 'evidence',
+            evidence: allEvidence,
+            evidenceRetries: attempt,
+            messages: allMessages,
+            _needsReexecution: false,
+        };
     };
 }

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;AAEpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAyErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAsP7E"}
+{"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;AAwErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAiQ7E"}

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

@@ -7,16 +7,15 @@
  * feature.yaml between phases.
  */
 import yaml from 'js-yaml';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { join } 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, updatePhasePrompt, } 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 { createEvidenceNode } from './evidence.node.js';
 import { hasSettings, getSettings } from '../../../settings.service.js';
 /**
  * Update feature.yaml with current implementation progress.
@@ -193,11 +192,16 @@ export function createImplementNode(executor) {
             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) {
+            let evidenceResult = {};
+            if (evidenceEnabled) {
+                const evidenceNode = createEvidenceNode(executor);
+                evidenceResult = await evidenceNode(state);
+                messages.push(`[implement] Evidence: ${(evidenceResult.evidence ?? []).length} record(s) captured`);
+            }
+            else {
                 log.info('Evidence collection disabled via settings — skipping');
+                messages.push('[implement] Evidence: 0 record(s) captured');
             }
-            messages.push(`[implement] Evidence: ${evidence.length} record(s) captured`);
             // Record top-level implement phase completion
             await recordPhaseEnd(implementTimingId, Date.now() - startTime, {
                 inputTokens: totalInputTokens || undefined,
@@ -215,7 +219,12 @@ export function createImplementNode(executor) {
                     message: `Implementation complete: ${totalTasks} tasks across ${totalPhases} phases. Approve to finish.`,
                 });
             }
-            return { currentNode: 'implement', evidence, messages };
+            return {
+                currentNode: 'implement',
+                evidence: evidenceResult.evidence ?? [],
+                evidenceRetries: evidenceResult.evidenceRetries ?? 0,
+                messages: [...messages, ...(evidenceResult.messages ?? [])],
+            };
         }
         catch (err) {
             if (isGraphBubbleUp(err))
@@ -240,58 +249,3 @@ 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/prompts/evidence-prompts.d.ts

@@ -11,9 +11,21 @@
  * graph state.
  */
 import type { FeatureAgentState } from '../../state.js';
+import type { ValidationError } from '../evidence-output-parser.js';
 export interface EvidencePromptOptions {
     /** Whether to commit evidence to the worktree / feature branch */
     commitEvidence: boolean;
 }
 export declare function buildEvidencePrompt(state: FeatureAgentState, options?: EvidencePromptOptions): string;
+/**
+ * Build a retry prompt for evidence collection that augments the base evidence
+ * prompt with structured validation feedback listing specific failures.
+ *
+ * Follows the repair.node.ts pattern of passing validation errors into the
+ * retry prompt so the agent can focus on fixing specific gaps rather than
+ * recollecting all evidence blindly.
+ *
+ * When errors is empty, returns the base prompt without a feedback section.
+ */
+export declare function buildEvidenceRetryPrompt(state: FeatureAgentState, errors: ValidationError[], options?: EvidencePromptOptions): string;
 //# sourceMappingURL=evidence-prompts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"evidence-prompts.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/evidence-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,qBAAiD,GACzD,MAAM,CA0MR"}
+{"version":3,"file":"evidence-prompts.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/evidence-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,qBAAiD,GACzD,MAAM,CA0MR;AAgCD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,eAAe,EAAE,EACzB,OAAO,GAAE,qBAAiD,GACzD,MAAM,CAqBR"}

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

@@ -208,3 +208,53 @@ If no evidence can be captured (e.g., no UI to screenshot, no tests to run), out
 - Do NOT capture evidence for documentation-only changes or spec files
 ${commitSection}`;
 }
+function formatValidationErrors(errors) {
+    if (errors.length === 0)
+        return '';
+    const uiErrors = errors.filter((e) => e.type === 'ui');
+    const completenessErrors = errors.filter((e) => e.type === 'completeness');
+    const fileErrors = errors.filter((e) => e.type === 'fileExistence');
+    const sections = [];
+    if (uiErrors.length > 0) {
+        sections.push(`### Missing App-Level Screenshots\n\n${uiErrors.map((e) => `- ${e.message}`).join('\n')}`);
+    }
+    if (completenessErrors.length > 0) {
+        sections.push(`### Missing Evidence by Task Type\n\n${completenessErrors
+            .map((e) => `- ${e.message}`)
+            .join('\n')}`);
+    }
+    if (fileErrors.length > 0) {
+        sections.push(`### File Issues\n\n${fileErrors.map((e) => `- ${e.message}`).join('\n')}`);
+    }
+    return sections.join('\n\n');
+}
+/**
+ * Build a retry prompt for evidence collection that augments the base evidence
+ * prompt with structured validation feedback listing specific failures.
+ *
+ * Follows the repair.node.ts pattern of passing validation errors into the
+ * retry prompt so the agent can focus on fixing specific gaps rather than
+ * recollecting all evidence blindly.
+ *
+ * When errors is empty, returns the base prompt without a feedback section.
+ */
+export function buildEvidenceRetryPrompt(state, errors, options = { commitEvidence: false }) {
+    const basePrompt = buildEvidencePrompt(state, options);
+    if (errors.length === 0)
+        return basePrompt;
+    const feedbackSection = `
+
+## VALIDATION FEEDBACK
+
+The previous evidence collection attempt was insufficient. Address the following missing evidence. Focus ONLY on fixing the listed gaps — do NOT recollect evidence that was already captured successfully.
+
+${formatValidationErrors(errors)}
+
+### Instructions
+
+- Review the issues above and capture the missing evidence
+- Focus on the specific gaps listed — do not re-capture evidence that already exists
+- Ensure new evidence files are saved to the correct paths
+- Output ALL evidence records (both previously captured and newly captured) in the JSON output block`;
+    return basePrompt + feedbackSection;
+}

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

@@ -49,6 +49,7 @@ export declare const FeatureAgentAnnotation: import("@langchain/langgraph").Anno
     push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
     evidence: import("@langchain/langgraph").BinaryOperatorAggregate<Evidence[], Evidence[]>;
+    evidenceRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     resumeReason: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<CiFixRecord[], CiFixRecord[]>;

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

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgGjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoGjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}

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

@@ -84,6 +84,10 @@ export const FeatureAgentAnnotation = Annotation.Root({
         reducer: (prev, next) => [...prev, ...next],
         default: () => [],
     }),
+    evidenceRetries: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => 0,
+    }),
     // --- Resume context (set when resuming from error/crash/stop) ---
     resumeReason: Annotation({
         reducer: (_prev, next) => next ?? _prev,