@syntesseraai/opencode-feature-factory 0.10.6 → 0.10.8

package/dist/tools/mini-loop.js

@@ -9,15 +9,40 @@
  * to the parent session via `promptAsync(noReply: true)`.
  */
 import { tool } from '@opencode-ai/plugin/tool';
+import { randomUUID } from 'node:crypto';
 import { promptSession, notifyParent, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, parseModelString, } from '../workflow/orchestrator.js';
-import { miniBuildPrompt, miniReviewPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, } from './prompts.js';
-import { parseMiniReview, parseDocReview } from './parsers.js';
+import { miniBuildPrompt, miniReviewPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, runNamePrompt, actionFirstReworkPrompt, } from './prompts.js';
+import { parseMiniReview, parseDocReview, parseImplementationReport, formatImplementationReportForHandoff } from './parsers.js';
 import { ciScriptExists, runCI } from '../workflow/ci-runner.js';
 import { cleanupWorktree, resolveRunDirectory } from '../workflow/run-isolation.js';
 // ---------------------------------------------------------------------------
 // Tool factory
 // ---------------------------------------------------------------------------
 const formatElapsed = (startMs, endMs) => `${((endMs - startMs) / 1000).toFixed(1)}s`;
+const normalizeRunName = (raw, fallback) => {
+    const normalized = raw
+        .trim()
+        .replace(/^[-#*\s]+/, '')
+        .replace(/\s+/g, ' ')
+        .slice(0, 80);
+    return normalized.length > 0 ? normalized : fallback;
+};
+const asBulletList = (items, empty) => {
+    if (items.length === 0) {
+        return `- ${empty}`;
+    }
+    return items.map((item) => `- ${item}`).join('\n');
+};
+const formatStructuredStage = (stage, includeActionItems) => {
+    const base = `STATUS: ${stage.status}\n` +
+        `SUMMARY: ${stage.summary}\n` +
+        `CHECKLIST:\n${asBulletList(stage.checklist, 'No checklist provided.')}\n` +
+        `ISSUES:\n${asBulletList(stage.issues, 'No issues reported.')}`;
+    if (!includeActionItems) {
+        return base;
+    }
+    return `${base}\nACTION_ITEMS:\n${asBulletList(stage.actionItems, 'No action items required.')}`;
+};
 export function createMiniLoopTool(client) {
     return tool({
         description: 'Run the Feature Factory mini-loop: build → review (with rework loop) → documentation. ' +
@@ -56,6 +81,8 @@ export function createMiniLoopTool(client) {
             const callerSessionId = context.sessionID;
             const agent = context.agent;
             const { requirements } = args;
+            const runId = randomUUID();
+            let runName = normalizeRunName(requirements.split('\n')[0] || '', 'Mini-Loop Workflow');
             // Resolve models — use provided overrides or undefined (inherit session model)
             const buildModel = args.build_model
                 ? parseModelString(args.build_model)
@@ -79,6 +106,18 @@ export function createMiniLoopTool(client) {
                 sessionId: callerSessionId,
                 directory: runDirectoryContext.runDirectory,
             };
+            try {
+                const runNameRaw = await promptSession(client, runContext, runNamePrompt('Mini-Loop', requirements), {
+                    model: buildModel,
+                    agent: 'building',
+                    title: 'ff-mini-run-name',
+                });
+                runName = normalizeRunName(runNameRaw, runName);
+            }
+            catch {
+                // Keep fallback name derived from requirements when name generation fails.
+            }
+            const runHeader = `Mini-Loop: ${runName} (${runId})`;
             // Fire-and-forget: run orchestration in background
             let lastPhase = 'init';
             const asyncOrchestration = async () => {
@@ -89,7 +128,7 @@ export function createMiniLoopTool(client) {
                         report.push(`## ${phase}\n${msg}`);
                     };
                     // Notify helper bound to this session
-                    const notify = (message, options) => notifyParent(client, runContext, agent, message, options);
+                    const notify = (message, options) => notifyParent(client, runContext, agent, `# ${runHeader}\n\n${message}`, options);
                     // ===================================================================
                     // PHASE 1: IMPLEMENTATION LOOP (build → review → gate, up to 10)
                     // ===================================================================
@@ -98,6 +137,8 @@ export function createMiniLoopTool(client) {
                     const implementationIterationDetails = [];
                     let implGate = { decision: 'REWORK', feedback: requirements };
                     let lastImplRaw = '';
+                    let lastImplementationHandoff = '';
+                    let nextImplementationDirective;
                     // Phase start notification
                     await notify(`# Mini-Loop: Building started\n\nStarting implementation phase...\n`);
                     for (let implIter = 0; implIter < 10 && implGate.decision === 'REWORK'; implIter++) {
@@ -106,7 +147,7 @@ export function createMiniLoopTool(client) {
                         const reviewTitle = `ff-mini-review-${iteration}`;
                         const buildInput = implIter === 0
                             ? requirements
-                            : `${requirements}\n\nPrevious review feedback:\n${implGate.feedback}`;
+                            : `${requirements}\n\nPrevious implementation handoff for context:\n${lastImplementationHandoff || lastImplRaw}`;
                         context.metadata({
                             title: `⏳ Building (iteration ${iteration}/10)...`,
                             metadata: {
@@ -118,7 +159,7 @@ export function createMiniLoopTool(client) {
                         });
                         // Build
                         const buildStartMs = Date.now();
-                        lastImplRaw = await promptSession(client, runContext, miniBuildPrompt(buildInput, implIter > 0 ? implGate.feedback : undefined), { model: buildModel, agent: 'building', title: buildTitle });
+                        lastImplRaw = await promptSession(client, runContext, miniBuildPrompt(buildInput, nextImplementationDirective), { model: buildModel, agent: 'building', title: buildTitle });
                         const buildEndMs = Date.now();
                         // ---------------------------------------------------------------
                         // CI validation (deterministic subprocess — not an LLM prompt)
@@ -141,14 +182,32 @@ export function createMiniLoopTool(client) {
                                         maxCiAttempts,
                                     },
                                 });
-                                await notify(`# Mini-Loop: CI validation — attempt ${ciAttempt}/${maxCiAttempts}\n`);
                                 const ciResult = await runCI(ciDir);
                                 if (ciResult.passed) {
-                                    await notify(`# Mini-Loop: CI passed (attempt ${ciAttempt}/${maxCiAttempts})\n`);
+                                    const ciStageOutput = {
+                                        status: 'APPROVED',
+                                        summary: `CI validation passed on attempt ${ciAttempt}/${maxCiAttempts}.`,
+                                        checklist: ['ff-ci.sh executed in run directory', 'No failing lint/typecheck/test/build checks'],
+                                        issues: [],
+                                        actionItems: [],
+                                        raw: 'CI passed',
+                                    };
+                                    await notify(`Stage: CI Validation — attempt ${ciAttempt}/${maxCiAttempts}\n` +
+                                        `${formatStructuredStage(ciStageOutput, false)}`);
                                     break;
                                 }
                                 // CI failed
-                                await notify(`# Mini-Loop: CI failed (attempt ${ciAttempt}/${maxCiAttempts})\n\n\`\`\`\n${ciResult.output}\n\`\`\`\n`);
+                                const ciFailureStage = {
+                                    status: 'REWORK',
+                                    summary: `CI failed on attempt ${ciAttempt}/${maxCiAttempts}.`,
+                                    checklist: ['ff-ci.sh executed in run directory'],
+                                    issues: ['CI reported failing checks.'],
+                                    actionItems: ['Fix CI failures before continuing to the next attempt.'],
+                                    raw: ciResult.output,
+                                };
+                                await notify(`Stage: CI Validation — attempt ${ciAttempt}/${maxCiAttempts}\n` +
+                                    `${formatStructuredStage(ciFailureStage, true)}\n\n` +
+                                    `\`\`\`\n${ciResult.output}\n\`\`\`\n`);
                                 if (ciAttempt < maxCiAttempts) {
                                     // Ask build model to fix the CI failures
                                     context.metadata({
@@ -187,6 +246,20 @@ export function createMiniLoopTool(client) {
                                 }
                             }
                         }
+                        const implementation = parseImplementationReport(lastImplRaw);
+                        const implementationHandoff = formatImplementationReportForHandoff(implementation);
+                        lastImplementationHandoff = implementationHandoff;
+                        const buildStageOutput = {
+                            ...implementation.stageOutput,
+                            status: implementation.stageOutput.status ||
+                                (implementation.testsPassed && implementation.openIssues.length === 0
+                                    ? 'APPROVED'
+                                    : 'REWORK_REQUIRED'),
+                        };
+                        await notify(`Stage: Build Output — iteration ${iteration}/10\n` +
+                            `${formatStructuredStage(buildStageOutput, buildStageOutput.actionItems.length > 0)}\n` +
+                            `Files Changed: ${implementation.filesChanged.length}\n` +
+                            `Tests Passed: ${implementation.testsPassed}`);
                         context.metadata({
                             title: `⏳ Reviewing (iteration ${iteration}/10)...`,
                             metadata: {
@@ -198,7 +271,7 @@ export function createMiniLoopTool(client) {
                         });
                         // Review
                         const reviewStartMs = Date.now();
-                        const reviewRaw = await promptSession(client, runContext, miniReviewPrompt(lastImplRaw), {
+                        const reviewRaw = await promptSession(client, runContext, miniReviewPrompt(implementationHandoff), {
                             model: reviewModel,
                             agent: 'reviewing',
                             title: reviewTitle,
@@ -207,6 +280,15 @@ export function createMiniLoopTool(client) {
                         const review = parseMiniReview(reviewRaw);
                         // Gate (deterministic)
                         implGate = evaluateMiniLoopImplGate(review, iteration);
+                        if (implGate.decision === 'REWORK') {
+                            nextImplementationDirective = actionFirstReworkPrompt({
+                                ...review.stageOutput,
+                                status: implGate.decision,
+                            }, `${requirements}\n\nPrevious implementation handoff for context:\n${implementationHandoff}\n\nReview feedback:\n${implGate.feedback || review.reworkInstructions || review.raw}`, implGate.feedback || review.reworkInstructions || review.raw);
+                        }
+                        else {
+                            nextImplementationDirective = undefined;
+                        }
                         if (implGate.decision === 'APPROVED') {
                             context.metadata({
                                 title: `✅ Implementation APPROVED (confidence: ${review.confidence}, iteration: ${iteration})`,
@@ -246,14 +328,21 @@ export function createMiniLoopTool(client) {
                                 },
                             });
                         }
-                        const feedback = review.reworkInstructions || implGate.feedback || review.raw;
+                        const implementationStageOutput = {
+                            ...review.stageOutput,
+                            status: implGate.decision,
+                        };
                         implementationIterationDetails.push(`### Iteration ${iteration}\n` +
                             `- **Build**: ${buildTitle} (${formatElapsed(buildStartMs, buildEndMs)})\n` +
                             `- **Review**: ${reviewTitle} (${formatElapsed(reviewStartMs, reviewEndMs)})\n` +
                             `- **Gate**: ${implGate.decision} (confidence: ${review.confidence}, change requested: ${review.changeRequested ? 'yes' : 'no'}, unresolved: ${review.unresolvedIssues})\n` +
-                            `- **Feedback**: ${feedback}`);
+                            `${formatStructuredStage(implementationStageOutput, implGate.decision === 'REWORK')}`);
                         // Notify each implementation iteration gate decision
-                        await notify(`# Mini-Loop: Building — Iteration ${iteration}/10\n\nStatus: ${implGate.decision}\nConfidence: ${review.confidence}%\nUnresolved Issues: ${review.unresolvedIssues}\nDuration: ${formatElapsed(implementationStartMs, Date.now())}\nFeedback: ${feedback}\n`);
+                        await notify(`Stage: Building — iteration ${iteration}/10\n` +
+                            `${formatStructuredStage(implementationStageOutput, implGate.decision === 'REWORK')}\n` +
+                            `Confidence: ${review.confidence}%\n` +
+                            `Unresolved Issues: ${review.unresolvedIssues}\n` +
+                            `Duration: ${formatElapsed(implementationStartMs, Date.now())}`);
                         if (implGate.decision === 'ESCALATE') {
                             const implementationEndMs = Date.now();
                             addReport('Implementation', `${implementationIterationDetails.join('\n\n')}\n\n**Outcome**: ESCALATE: ${implGate.reason}\n**Phase time**: ${formatElapsed(implementationStartMs, implementationEndMs)}`);
@@ -298,7 +387,7 @@ export function createMiniLoopTool(client) {
                     lastPhase = 'Documentation';
                     const documentationStartMs = Date.now();
                     const documentationIterationDetails = [];
-                    let docInput = lastImplRaw;
+                    let docInput = lastImplementationHandoff || lastImplRaw;
                     let docGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Mini-Loop: Documentation started\n\nStarting documentation phase...\n`);
@@ -382,16 +471,26 @@ export function createMiniLoopTool(client) {
                                 },
                             });
                         }
-                        const feedback = docReview.reworkInstructions || docGate.feedback || docReview.raw;
+                        const docStageOutput = {
+                            ...docReview.stageOutput,
+                            status: docGate.decision,
+                        };
                         documentationIterationDetails.push(`### Iteration ${iteration}\n` +
                             `- **Write**: ${writeTitle} (${formatElapsed(writeStartMs, writeEndMs)})\n` +
                             `- **Review**: ${reviewTitle} (${formatElapsed(reviewStartMs, reviewEndMs)})\n` +
                             `- **Gate**: ${docGate.decision} (confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
-                            `- **Feedback**: ${feedback}`);
+                            `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}`);
                         // Notify each documentation iteration gate decision
-                        await notify(`# Mini-Loop: Documentation — Iteration ${iteration}/5\n\nStatus: ${docGate.decision}\nConfidence: ${docReview.confidence}%\nUnresolved Issues: ${docReview.unresolvedIssues}\nDuration: ${formatElapsed(documentationStartMs, Date.now())}\nFeedback: ${feedback}\n`);
+                        await notify(`Stage: Documentation — iteration ${iteration}/5\n` +
+                            `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}\n` +
+                            `Confidence: ${docReview.confidence}%\n` +
+                            `Unresolved Issues: ${docReview.unresolvedIssues}\n` +
+                            `Duration: ${formatElapsed(documentationStartMs, Date.now())}`);
                         if (docGate.decision === 'REWORK') {
-                            docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
+                            docInput = actionFirstReworkPrompt({
+                                ...docReview.stageOutput,
+                                status: docGate.decision,
+                            }, `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback || docReview.reworkInstructions || docReview.raw}`, docGate.feedback || docReview.reworkInstructions || docReview.raw);
                         }
                     }
                     const documentationEndMs = Date.now();
@@ -425,11 +524,11 @@ export function createMiniLoopTool(client) {
             // Launch orchestration in background — fire-and-forget
             void asyncOrchestration().catch(async (err) => {
                 const message = err instanceof Error ? err.message : String(err);
-                await notifyParent(client, runContext, agent, `# Mini-Loop: Error\n\nPhase: ${lastPhase}\nError: ${message}\n`, { noReply: false });
+                await notifyParent(client, runContext, agent, `# Mini-Loop: ${runName} (${runId})\n\nStage: Error\nSTATUS: FAILED\nSUMMARY: Workflow terminated during ${lastPhase}.\nCHECKLIST:\n- Captured terminal error\nISSUES:\n- ${message}\n`, { noReply: false });
             });
             // Return immediately with acknowledgment
             const summary = requirements.length > 120 ? requirements.slice(0, 120) + '...' : requirements;
-            return `Mini-loop started for: ${summary}\n\nRun directory: ${runDirectoryContext.runDirectory}\nWorktree isolation: ${runDirectoryContext.worktreeEnabled ? 'enabled' : 'disabled'}\nYou will receive progress updates as each phase completes.`;
+            return `Mini-loop started for: ${summary}\n\nRun: ${runName} (${runId})\nRun directory: ${runDirectoryContext.runDirectory}\nWorktree isolation: ${runDirectoryContext.worktreeEnabled ? 'enabled' : 'disabled'}\nYou will receive progress updates as each phase completes.`;
         },
     });
 }

package/dist/tools/parsers.d.ts

@@ -5,13 +5,15 @@
  * structured sections cannot be found. The gate evaluators work on
  * the parsed numbers/booleans, not on freeform text.
  */
-import type { PlanProposal, ConsensusPlan, ReviewReport, ReviewSynthesis, DocReview, ImplementationReport, DocUpdate } from '../workflow/types.js';
+import type { PlanProposal, ConsensusPlan, ReviewReport, ReviewSynthesis, DocReview, ImplementationReport, DocUpdate, StageOutput, MiniLoopReview } from '../workflow/types.js';
 /** Extract the first integer found after a label in the text. */
 export declare function extractNumber(text: string, label: string, fallback?: number): number;
 /** Extract text between two section headers (markdown-style). */
 export declare function extractSection(text: string, heading: string): string;
 /** Check if a YES/NO field is YES. */
 export declare function isYes(text: string, label: string): boolean;
+export declare function parseStageOutput(raw: string, defaults?: Partial<Pick<StageOutput, 'status' | 'summary'>>): StageOutput;
+export declare function formatActionItems(actionItems: string[]): string;
 export declare function parsePlanProposal(tag: string, raw: string): PlanProposal;
 export declare function parseConsensusPlan(raw: string): ConsensusPlan;
 export declare function parseReviewReport(tag: string, raw: string): ReviewReport;
@@ -19,10 +21,5 @@ export declare function parseReviewSynthesis(raw: string): ReviewSynthesis;
 export declare function parseDocUpdate(raw: string): DocUpdate;
 export declare function parseDocReview(raw: string): DocReview;
 export declare function parseImplementationReport(raw: string): ImplementationReport;
-export declare function parseMiniReview(raw: string): {
-    confidence: number;
-    changeRequested: boolean;
-    unresolvedIssues: number;
-    reworkInstructions?: string;
-    raw: string;
-};
+export declare function formatImplementationReportForHandoff(report: ImplementationReport): string;
+export declare function parseMiniReview(raw: string): MiniLoopReview;

package/dist/tools/parsers.js

@@ -41,6 +41,100 @@ export function isYes(text, label) {
     const m = text.match(new RegExp(`${label}[=:\\s]*(YES|NO)`, 'i'));
     return m ? m[1].toUpperCase() === 'YES' : false;
 }
+function fallbackSummary(raw) {
+    const firstNonEmpty = raw
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return firstNonEmpty || 'No summary provided.';
+}
+function extractDelimitedField(text, label) {
+    const pattern = new RegExp(`(?:^|\\n)(?:\\d+\\.\\s*)?\\*{0,2}${label}\\*{0,2}[=:]?[\\t ]*\\n?([\\s\\S]*?)(?=\\n(?:\\d+\\.\\s*)?\\*{0,2}(?:STATUS|SUMMARY|CHECKLIST|ISSUES|ACTION_ITEMS|VERDICT|CONFIDENCE|CHANGE_REQUESTED|UNRESOLVED(?:_BLOCKING_ISSUES|_DOCUMENTATION_ISSUES)?|UNRESOLVED_ISSUES)\\*{0,2}[=:]?|$)`, 'i');
+    const match = text.match(pattern);
+    return match ? match[1].trim() : '';
+}
+function parseListField(value) {
+    return value
+        .split('\n')
+        .map((line) => line.trim())
+        .map((line) => line.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter((line) => line.length > 0);
+}
+function fallbackBulletLines(raw) {
+    return raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !/^(STATUS|SUMMARY|CHECKLIST|ISSUES|ACTION_ITEMS|VERDICT|CONFIDENCE|CHANGE_REQUESTED|UNRESOLVED)/i.test(line))
+        .slice(0, 4)
+        .map((line) => line.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter((line) => line.length > 0);
+}
+function fallbackIssueLines(raw) {
+    const issueLike = raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => /\b(issue|error|fail|missing|regression|risk|bug|broken)\b/i.test(line))
+        .map((line) => line.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter((line) => line.length > 0)
+        .slice(0, 4);
+    return issueLike;
+}
+function isNoneLike(value) {
+    return /^(none|none\.|no\b.*|n\/a|not applicable|nil)$/i.test(value.trim());
+}
+function normalizeOptionalList(items) {
+    return items.filter((item) => !isNoneLike(item));
+}
+function asBullets(items, empty) {
+    if (items.length === 0) {
+        return `- ${empty}`;
+    }
+    return items.map((item) => `- ${item}`).join('\n');
+}
+export function parseStageOutput(raw, defaults) {
+    const status = extractDelimitedField(raw, 'STATUS') ||
+        extractDelimitedField(raw, 'VERDICT') ||
+        defaults?.status ||
+        'UNKNOWN';
+    const summary = extractDelimitedField(raw, 'SUMMARY') || defaults?.summary || fallbackSummary(raw);
+    const checklistField = parseListField(extractDelimitedField(raw, 'CHECKLIST'));
+    const issuesField = parseListField(extractDelimitedField(raw, 'ISSUES'));
+    const actionItemsField = parseListField(extractDelimitedField(raw, 'ACTION_ITEMS'));
+    const fallbackChecklist = fallbackBulletLines(raw);
+    const fallbackIssues = fallbackIssueLines(raw);
+    const normalizedStatus = status.toUpperCase();
+    const isReworkStatus = normalizedStatus.includes('REWORK') || normalizedStatus === 'ESCALATE';
+    const checklist = checklistField.length > 0
+        ? checklistField
+        : fallbackChecklist.length > 0
+            ? fallbackChecklist
+            : ['No checklist provided.'];
+    const issues = issuesField.length > 0
+        ? issuesField
+        : fallbackIssues.length > 0
+            ? fallbackIssues
+            : [];
+    const actionItems = actionItemsField.length > 0
+        ? actionItemsField
+        : isReworkStatus && issues.length > 0
+            ? issues.map((issue) => `Resolve: ${issue}`)
+            : [];
+    return {
+        status,
+        summary,
+        checklist,
+        issues,
+        actionItems,
+        raw,
+    };
+}
+export function formatActionItems(actionItems) {
+    if (actionItems.length === 0) {
+        return 'No explicit ACTION_ITEMS were provided.';
+    }
+    return actionItems.map((item, idx) => `${idx + 1}. ${item}`).join('\n');
+}
 // ---------------------------------------------------------------------------
 // Planning parsers
 // ---------------------------------------------------------------------------
@@ -81,13 +175,19 @@ export function parseReviewSynthesis(raw) {
     const unresolvedIssues = extractNumber(raw, 'unresolved');
     const verdictMatch = raw.match(/verdict[=:\s]*(APPROVED|REWORK_REQUIRED)/i);
     const verdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
-    const reworkSection = extractSection(raw, 'rework');
+    const stageOutput = parseStageOutput(raw, {
+        status: verdict,
+        summary: `Review confidence ${confidence}/100 with ${unresolvedIssues} unresolved issues.`,
+    });
     return {
         overallConfidence: confidence,
         consolidatedFindings: raw,
         unresolvedIssues,
         verdict,
-        reworkInstructions: reworkSection || undefined,
+        reworkInstructions: stageOutput.actionItems.length > 0
+            ? formatActionItems(stageOutput.actionItems)
+            : extractSection(raw, 'rework') || undefined,
+        stageOutput,
         raw,
     };
 }
@@ -106,12 +206,18 @@ export function parseDocReview(raw) {
     const unresolvedIssues = extractNumber(raw, 'unresolved');
     const verdictMatch = raw.match(/verdict[=:\s]*(APPROVED|REWORK_REQUIRED)/i);
     const verdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
-    const reworkSection = extractSection(raw, 'rework');
+    const stageOutput = parseStageOutput(raw, {
+        status: verdict,
+        summary: `Documentation confidence ${confidence}/100 with ${unresolvedIssues} unresolved issues.`,
+    });
     return {
         verdict,
         unresolvedIssues,
         confidence,
-        reworkInstructions: reworkSection || undefined,
+        reworkInstructions: stageOutput.actionItems.length > 0
+            ? formatActionItems(stageOutput.actionItems)
+            : extractSection(raw, 'rework') || undefined,
+        stageOutput,
         raw,
     };
 }
@@ -119,24 +225,98 @@ export function parseDocReview(raw) {
 // Implementation parsers
 // ---------------------------------------------------------------------------
 export function parseImplementationReport(raw) {
+    const implementedTasks = parseListField(extractSection(raw, 'IMPLEMENTED_TASKS'));
+    const filesChanged = normalizeOptionalList(parseListField(extractSection(raw, 'FILES_CHANGED')));
+    const testResults = normalizeOptionalList(parseListField(extractSection(raw, 'TEST_RESULTS')));
+    const openIssues = normalizeOptionalList(parseListField(extractSection(raw, 'OPEN_ISSUES')));
+    const assumptionsMade = normalizeOptionalList(parseListField(extractSection(raw, 'ASSUMPTIONS_MADE')));
+    const testsRun = testResults;
+    const testsPassed = testResults.length > 0
+        ? testResults.every((result) => !/\b(fail|failed|failing|error|errors|broken|regression)\b/i.test(result) ||
+            /\b(no issues|no errors|not fail|resolved)\b/i.test(result))
+        : !/\b(test|lint|typecheck|build)\b[\s\S]{0,60}\b(fail|failed|error|errors)\b/i.test(raw);
+    const explicitStatus = extractDelimitedField(raw, 'STATUS').toUpperCase();
+    const fallbackStatus = testsPassed && openIssues.length === 0 ? 'APPROVED' : 'REWORK_REQUIRED';
+    const status = explicitStatus || fallbackStatus;
+    const explicitSummary = extractDelimitedField(raw, 'SUMMARY');
+    const summary = explicitSummary || implementedTasks[0] || fallbackSummary(raw);
+    const checklistField = parseListField(extractDelimitedField(raw, 'CHECKLIST'));
+    const issuesField = parseListField(extractDelimitedField(raw, 'ISSUES'));
+    const actionItemsField = parseListField(extractDelimitedField(raw, 'ACTION_ITEMS'));
+    const checklist = checklistField.length > 0
+        ? checklistField
+        : [
+            `Implemented tasks recorded: ${implementedTasks.length}`,
+            `Files changed recorded: ${filesChanged.length}`,
+            testResults.length > 0
+                ? `Test results recorded: ${testResults.length}`
+                : 'No explicit test results were reported.',
+        ];
+    const issues = issuesField.length > 0 ? issuesField : openIssues;
+    const actionItems = actionItemsField.length > 0
+        ? actionItemsField
+        : issues.length > 0
+            ? issues.map((issue) => `Resolve: ${issue}`)
+            : [];
+    const stageOutput = {
+        status,
+        summary,
+        checklist,
+        issues,
+        actionItems,
+        raw,
+    };
     return {
-        filesChanged: [],
-        testsRun: [],
-        testsPassed: !raw.toLowerCase().includes('failed'),
-        openIssues: [],
+        implementedTasks,
+        filesChanged,
+        testResults,
+        testsRun,
+        testsPassed,
+        openIssues,
+        assumptionsMade,
+        stageOutput,
         raw,
     };
 }
+export function formatImplementationReportForHandoff(report) {
+    return [
+        `STATUS: ${report.stageOutput.status}`,
+        `SUMMARY: ${report.stageOutput.summary}`,
+        `CHECKLIST:\n${asBullets(report.stageOutput.checklist, 'No checklist provided.')}`,
+        `ISSUES:\n${asBullets(report.stageOutput.issues, 'No issues reported.')}`,
+        `ACTION_ITEMS:\n${asBullets(report.stageOutput.actionItems, 'No action items required.')}`,
+        '',
+        `IMPLEMENTED_TASKS\n${asBullets(report.implementedTasks, 'No tasks recorded.')}`,
+        `FILES_CHANGED\n${asBullets(report.filesChanged, 'No file list provided.')}`,
+        `TEST_RESULTS\n${asBullets(report.testResults, 'No test results provided.')}`,
+        `OPEN_ISSUES\n${asBullets(report.openIssues, 'No open issues.')}`,
+        `ASSUMPTIONS_MADE\n${asBullets(report.assumptionsMade, 'No assumptions listed.')}`,
+        '',
+        `RAW_IMPLEMENTATION_CONTEXT\n${report.raw.trim()}`,
+    ].join('\n');
+}
 // ---------------------------------------------------------------------------
 // Mini-loop review parser
 // ---------------------------------------------------------------------------
 export function parseMiniReview(raw) {
+    const confidence = extractNumber(raw, 'CONFIDENCE');
+    const changeRequested = isYes(raw, 'CHANGE_REQUESTED') || /verdict[=:\s]*REWORK_REQUIRED/i.test(raw);
+    const unresolvedIssues = extractNumber(raw, 'UNRESOLVED_BLOCKING_ISSUES') ||
+        extractNumber(raw, 'UNRESOLVED_DOCUMENTATION_ISSUES') ||
+        extractNumber(raw, 'UNRESOLVED_ISSUES');
+    const status = changeRequested ? 'REWORK_REQUIRED' : 'APPROVED';
+    const stageOutput = parseStageOutput(raw, {
+        status,
+        summary: `Mini-loop review confidence ${confidence}/100 with ${unresolvedIssues} unresolved issues.`,
+    });
     return {
-        confidence: extractNumber(raw, 'CONFIDENCE'),
-        changeRequested: isYes(raw, 'CHANGE_REQUESTED'),
-        unresolvedIssues: extractNumber(raw, 'UNRESOLVED_BLOCKING_ISSUES') ||
-            extractNumber(raw, 'UNRESOLVED_DOCUMENTATION_ISSUES'),
-        reworkInstructions: extractSection(raw, 'rework') || undefined,
+        confidence,
+        changeRequested,
+        unresolvedIssues,
+        reworkInstructions: stageOutput.actionItems.length > 0
+            ? formatActionItems(stageOutput.actionItems)
+            : extractSection(raw, 'rework') || undefined,
+        stageOutput,
         raw,
     };
 }