@syntesseraai/opencode-feature-factory 0.7.2 → 0.7.3

package/agents/building.md

@@ -1,5 +1,6 @@
 ---
 description: Implements features from approved plans and returns structured implementation outputs for pipeline handoff.
+mode: subagent
 color: '#22c55e'
 tools:
   read: true

package/agents/documenting.md

@@ -1,5 +1,6 @@
 ---
 description: Documentation implementation specialist for pipeline documentation stage.
+mode: subagent
 color: '#f97316'
 tools:
   read: true

package/agents/planning.md

@@ -1,5 +1,6 @@
 ---
 description: Creates implementation plans and planning gates for pipeline and ad-hoc work. Uses result-based handoff instead of file artifacts.
+mode: subagent
 color: '#3b82f6'
 tools:
   read: true

package/agents/reviewing.md

@@ -1,5 +1,6 @@
 ---
 description: Unified validation agent for code and documentation. Performs acceptance, quality, security, and architecture review with context-driven scope.
+mode: subagent
 color: '#8b5cf6'
 tools:
   read: true

package/dist/tools/mini-loop.js

@@ -11,6 +11,7 @@ import { parseMiniReview, parseDocReview } from './parsers.js';
 // ---------------------------------------------------------------------------
 // Tool factory
 // ---------------------------------------------------------------------------
+const formatElapsed = (startMs, endMs) => `${((endMs - startMs) / 1000).toFixed(1)}s`;
 export function createMiniLoopTool(client) {
     return tool({
         description: 'Run the Feature Factory mini-loop: build → review (with rework loop) → documentation. ' +
@@ -38,6 +39,7 @@ export function createMiniLoopTool(client) {
                 .describe('provider/model for documentation review. Defaults to opencode/gemini-3.1-pro.'),
         },
         async execute(args, context) {
+            const totalStartMs = Date.now();
             const sessionId = context.sessionID;
             const { requirements } = args;
             // Resolve models — use provided overrides or fall back to defaults
@@ -62,71 +64,241 @@ export function createMiniLoopTool(client) {
             // ===================================================================
             // PHASE 1: IMPLEMENTATION LOOP (build → review → gate, up to 10)
             // ===================================================================
+            const implementationStartMs = Date.now();
+            const implementationIterationDetails = [];
             let implGate = { decision: 'REWORK', feedback: requirements };
             let lastImplRaw = '';
             for (let implIter = 0; implIter < 10 && implGate.decision === 'REWORK'; implIter++) {
+                const iteration = implIter + 1;
+                const buildTitle = `ff-mini-build-${iteration}`;
+                const reviewTitle = `ff-mini-review-${iteration}`;
                 const buildInput = implIter === 0
                     ? requirements
                     : `${requirements}\n\nPrevious review feedback:\n${implGate.feedback}`;
+                context.metadata({
+                    title: `⏳ Building (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'implementation',
+                        step: 'build',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Build
-                lastImplRaw = await promptSession(client, sessionId, miniBuildPrompt(buildInput, implIter > 0 ? implGate.feedback : undefined), { model: buildModel, agent: 'building', title: `ff-mini-build-${implIter + 1}` });
+                const buildStartMs = Date.now();
+                lastImplRaw = await promptSession(client, sessionId, miniBuildPrompt(buildInput, implIter > 0 ? implGate.feedback : undefined), { model: buildModel, agent: 'building', title: buildTitle });
+                const buildEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Reviewing (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'implementation',
+                        step: 'review',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Review
+                const reviewStartMs = Date.now();
                 const reviewRaw = await promptSession(client, sessionId, miniReviewPrompt(lastImplRaw), {
                     model: reviewModel,
                     agent: 'reviewing',
-                    title: `ff-mini-review-${implIter + 1}`,
+                    title: reviewTitle,
                 });
+                const reviewEndMs = Date.now();
                 const review = parseMiniReview(reviewRaw);
                 // Gate (deterministic)
-                implGate = evaluateMiniLoopImplGate(review, implIter + 1);
+                implGate = evaluateMiniLoopImplGate(review, iteration);
                 if (implGate.decision === 'APPROVED') {
-                    addReport('Implementation', `APPROVED (confidence: ${review.confidence}, iteration: ${implIter + 1})`);
+                    context.metadata({
+                        title: `✅ Implementation APPROVED (confidence: ${review.confidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
                 }
                 else if (implGate.decision === 'ESCALATE') {
-                    addReport('Implementation', `ESCALATE: ${implGate.reason}`);
+                    context.metadata({
+                        title: '⚠️ Implementation ESCALATED',
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
+                }
+                else {
+                    context.metadata({
+                        title: `🔄 Rework required (confidence: ${review.confidence}, iteration: ${iteration}/10)`,
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
+                }
+                const feedback = review.reworkInstructions || implGate.feedback || review.raw;
+                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}`);
+                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)}`);
+                    context.metadata({
+                        title: '⚠️ Mini-loop finished with issues',
+                        metadata: {
+                            phase: 'complete',
+                            outcome: 'issues',
+                            totalElapsedMs: Date.now() - totalStartMs,
+                        },
+                    });
+                    addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                     return report.join('\n\n');
                 }
                 // REWORK continues the loop
             }
+            const implementationEndMs = Date.now();
+            addReport('Implementation', `${implementationIterationDetails.join('\n\n')}\n\n**Outcome**: ${implGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : `REWORK exhausted (10 iterations). Last feedback: ${implGate.feedback}`}\n**Phase time**: ${formatElapsed(implementationStartMs, implementationEndMs)}`);
             if (implGate.decision !== 'APPROVED') {
-                addReport('Implementation', `REWORK exhausted (10 iterations). Last feedback:\n${implGate.feedback}`);
+                context.metadata({
+                    title: '⚠️ Mini-loop finished with issues',
+                    metadata: {
+                        phase: 'complete',
+                        outcome: 'issues',
+                        totalElapsedMs: Date.now() - totalStartMs,
+                    },
+                });
+                addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                 return report.join('\n\n');
             }
             // ===================================================================
             // PHASE 2: DOCUMENTATION LOOP (document → review → gate, up to 5)
             // ===================================================================
+            const documentationStartMs = Date.now();
+            const documentationIterationDetails = [];
             let docInput = lastImplRaw;
             let docGate = { decision: 'REWORK' };
             for (let docIter = 0; docIter < 5 && docGate.decision === 'REWORK'; docIter++) {
+                const iteration = docIter + 1;
+                const writeTitle = `ff-mini-doc-write-${iteration}`;
+                const reviewTitle = `ff-mini-doc-review-${iteration}`;
+                context.metadata({
+                    title: `⏳ Writing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'write',
+                        iteration,
+                        maxIterations: 5,
+                    },
+                });
                 // Write docs
+                const writeStartMs = Date.now();
                 const docRaw = await promptSession(client, sessionId, documentPrompt(docInput), {
                     model: docModel,
                     agent: 'documenting',
-                    title: `ff-mini-doc-write-${docIter + 1}`,
+                    title: writeTitle,
+                });
+                const writeEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Reviewing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'review',
+                        iteration,
+                        maxIterations: 5,
+                    },
                 });
                 // Review docs
+                const reviewStartMs = Date.now();
                 const docRevRaw = await promptSession(client, sessionId, docReviewPrompt(docRaw), {
                     model: docReviewModel,
                     agent: 'reviewing',
-                    title: `ff-mini-doc-review-${docIter + 1}`,
+                    title: reviewTitle,
                 });
+                const reviewEndMs = Date.now();
                 const docReview = parseDocReview(docRevRaw);
                 // Gate (deterministic)
-                docGate = evaluateMiniLoopDocGate(docReview, docIter + 1);
+                docGate = evaluateMiniLoopDocGate(docReview, iteration);
                 if (docGate.decision === 'APPROVED') {
-                    addReport('Documentation', `APPROVED (confidence: ${docReview.confidence}, iteration: ${docIter + 1})`);
+                    context.metadata({
+                        title: `✅ Documentation APPROVED (confidence: ${docReview.confidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else if (docGate.decision === 'ESCALATE') {
-                    addReport('Documentation', `ESCALATE: ${docGate.reason}`);
+                    context.metadata({
+                        title: '⚠️ Documentation ESCALATED',
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else {
+                    context.metadata({
+                        title: `🔄 Documentation rework required (confidence: ${docReview.confidence}, iteration: ${iteration}/5)`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
+                }
+                const feedback = docReview.reworkInstructions || docGate.feedback || docReview.raw;
+                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}`);
+                if (docGate.decision === 'REWORK') {
                     docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
                 }
             }
-            // ===================================================================
-            // FINAL REPORT
-            // ===================================================================
-            addReport('Complete', 'Mini-loop finished.');
+            const documentationEndMs = Date.now();
+            addReport('Documentation', `${documentationIterationDetails.join('\n\n')}\n\n**Outcome**: ${docGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : docGate.decision === 'ESCALATE'
+                    ? `ESCALATE: ${docGate.reason}`
+                    : `REWORK exhausted (5 iterations). Last feedback: ${docGate.feedback}`}\n**Phase time**: ${formatElapsed(documentationStartMs, documentationEndMs)}`);
+            const totalEndMs = Date.now();
+            const completedWithoutIssues = docGate.decision === 'APPROVED';
+            context.metadata({
+                title: completedWithoutIssues ? '✅ Mini-loop complete' : '⚠️ Mini-loop finished with issues',
+                metadata: {
+                    phase: 'complete',
+                    outcome: completedWithoutIssues ? 'success' : 'issues',
+                    totalElapsedMs: totalEndMs - totalStartMs,
+                },
+            });
+            addReport('Complete', `${completedWithoutIssues ? 'Mini-loop finished successfully.' : 'Mini-loop finished with issues.'}\n**Total time**: ${formatElapsed(totalStartMs, totalEndMs)}`);
             return report.join('\n\n');
         },
     });

package/dist/tools/pipeline.js

@@ -13,6 +13,7 @@ import { parseConsensusPlan, parseReviewSynthesis, parseImplementationReport, pa
 // ---------------------------------------------------------------------------
 // Tool factory — needs the SDK client from plugin init
 // ---------------------------------------------------------------------------
+const formatElapsed = (startMs, endMs) => `${((endMs - startMs) / 1000).toFixed(1)}s`;
 export function createPipelineTool(client) {
     return tool({
         description: 'Run the full Feature Factory pipeline: multi-model planning → build → review → documentation. ' +
@@ -54,6 +55,7 @@ export function createPipelineTool(client) {
                 .describe('provider/model for documentation review. Defaults to the validate model.'),
         },
         async execute(args, context) {
+            const totalStartMs = Date.now();
             const sessionId = context.sessionID;
             const { requirements } = args;
             // Resolve models — use provided overrides or fall back to defaults
@@ -91,136 +93,473 @@ export function createPipelineTool(client) {
             // ===================================================================
             // PHASE 1: PLANNING (fan-out → synthesize → gate, loop up to 5)
             // ===================================================================
+            const planningStartMs = Date.now();
+            const planningIterationDetails = [];
             let planningGate = { decision: 'REWORK', feedback: requirements };
             let finalPlan = '';
             for (let planIter = 0; planIter < 5 && planningGate.decision === 'REWORK'; planIter++) {
+                const iteration = planIter + 1;
+                const synthesisTitle = `ff-plan-synthesis-${iteration}`;
+                const fanOutTitles = planModels.map((model) => `ff-fanout-${model.tag}`);
                 const planInput = planIter === 0
                     ? requirements
                     : `${requirements}\n\nPrevious feedback:\n${planningGate.feedback}`;
+                context.metadata({
+                    title: `⏳ Planning fan-out (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'planning',
+                        step: 'fan_out',
+                        iteration,
+                        maxIterations: 5,
+                    },
+                });
                 // Fan-out: N models plan in parallel
+                const fanOutStartMs = Date.now();
                 const fanOutResults = await fanOut(client, sessionId, planModels, (tag) => planningPrompt(planInput, tag), 'planning');
+                const fanOutEndMs = Date.now();
+                context.metadata({
+                    title: '⏳ Synthesizing plans...',
+                    metadata: {
+                        phase: 'planning',
+                        step: 'synthesis',
+                        iteration,
+                        maxIterations: 5,
+                    },
+                });
                 // Synthesize consensus
+                const synthesisStartMs = Date.now();
                 const synthesisRaw = await promptSession(client, sessionId, synthesisPrompt(fanOutResults), {
                     model: orchestratorModel,
                     agent: 'planning',
-                    title: `ff-plan-synthesis-${planIter + 1}`,
+                    title: synthesisTitle,
                 });
+                const synthesisEndMs = Date.now();
                 const consensus = parseConsensusPlan(synthesisRaw);
                 // Gate (deterministic)
                 planningGate = evaluatePlanningGate(consensus);
                 if (planningGate.decision === 'APPROVED') {
+                    context.metadata({
+                        title: `✅ Planning APPROVED (score: ${consensus.consensusScore}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'planning',
+                            step: 'gate',
+                            decision: planningGate.decision,
+                            score: consensus.consensusScore,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                     finalPlan = consensus.synthesizedPlan || synthesisRaw;
-                    addReport('Planning', `APPROVED (score: ${consensus.consensusScore}, iteration: ${planIter + 1})`);
                 }
                 else if (planningGate.decision === 'BLOCKED') {
-                    addReport('Planning', `BLOCKED: ${planningGate.reason}`);
+                    context.metadata({
+                        title: `⚠️ Planning BLOCKED (score: ${consensus.consensusScore}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'planning',
+                            step: 'gate',
+                            decision: planningGate.decision,
+                            score: consensus.consensusScore,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
+                }
+                else {
+                    context.metadata({
+                        title: `🔄 Planning rework required (score: ${consensus.consensusScore}, iteration: ${iteration}/5)`,
+                        metadata: {
+                            phase: 'planning',
+                            step: 'gate',
+                            decision: planningGate.decision,
+                            score: consensus.consensusScore,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
+                }
+                const feedback = consensus.openQuestions || planningGate.feedback || consensus.divergentElements || 'N/A';
+                planningIterationDetails.push(`### Iteration ${iteration}\n` +
+                    `- **Fan-out**: ${fanOutTitles.join(', ')} (${formatElapsed(fanOutStartMs, fanOutEndMs)})\n` +
+                    `- **Synthesis**: ${synthesisTitle} (${formatElapsed(synthesisStartMs, synthesisEndMs)})\n` +
+                    `- **Gate**: ${planningGate.decision} (score: ${consensus.consensusScore})\n` +
+                    `- **Feedback**: ${feedback}`);
+                if (planningGate.decision === 'BLOCKED') {
+                    const planningEndMs = Date.now();
+                    addReport('Planning', `${planningIterationDetails.join('\n\n')}\n\n**Outcome**: BLOCKED: ${planningGate.reason}\n**Phase time**: ${formatElapsed(planningStartMs, planningEndMs)}`);
+                    context.metadata({
+                        title: '⚠️ Pipeline finished with issues',
+                        metadata: {
+                            phase: 'complete',
+                            outcome: 'issues',
+                            totalElapsedMs: Date.now() - totalStartMs,
+                        },
+                    });
+                    addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                     return report.join('\n\n');
                 }
                 // REWORK continues the loop
             }
+            const planningEndMs = Date.now();
+            addReport('Planning', `${planningIterationDetails.join('\n\n')}\n\n**Outcome**: ${planningGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : `REWORK exhausted (5 iterations). Last feedback: ${planningGate.feedback}`}\n**Phase time**: ${formatElapsed(planningStartMs, planningEndMs)}`);
             if (planningGate.decision !== 'APPROVED') {
-                addReport('Planning', `REWORK exhausted (5 iterations). Last feedback:\n${planningGate.feedback}`);
+                context.metadata({
+                    title: '⚠️ Pipeline finished with issues',
+                    metadata: {
+                        phase: 'complete',
+                        outcome: 'issues',
+                        totalElapsedMs: Date.now() - totalStartMs,
+                    },
+                });
+                addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                 return report.join('\n\n');
             }
             // ===================================================================
             // PHASE 2: BUILDING (breakdown → validate → implement)
             // ===================================================================
+            const buildingStartMs = Date.now();
+            context.metadata({
+                title: '⏳ Breaking down tasks...',
+                metadata: {
+                    phase: 'building',
+                    step: 'breakdown',
+                },
+            });
             // Breakdown
+            const breakdownTitle = 'ff-build-breakdown';
+            const breakdownStartMs = Date.now();
             const tasksRaw = await promptSession(client, sessionId, breakdownPrompt(finalPlan), {
                 model: buildModel,
                 agent: 'building',
-                title: 'ff-build-breakdown',
+                title: breakdownTitle,
+            });
+            const breakdownEndMs = Date.now();
+            context.metadata({
+                title: '⏳ Validating task batches...',
+                metadata: {
+                    phase: 'building',
+                    step: 'validate',
+                },
             });
             // Validate batches
+            const validateTitle = 'ff-build-validate';
+            const validateStartMs = Date.now();
             const batchesRaw = await promptSession(client, sessionId, validateBatchPrompt(tasksRaw), {
                 model: validateModel,
                 agent: 'building',
-                title: 'ff-build-validate',
+                title: validateTitle,
+            });
+            const validateEndMs = Date.now();
+            context.metadata({
+                title: '⏳ Implementing validated batches...',
+                metadata: {
+                    phase: 'building',
+                    step: 'implement',
+                },
             });
             // Implement
+            const implementTitle = 'ff-build-implement';
+            const implementStartMs = Date.now();
             const implRaw = await promptSession(client, sessionId, implementBatchPrompt(batchesRaw), {
                 model: buildModel,
                 agent: 'building',
-                title: 'ff-build-implement',
+                title: implementTitle,
             });
+            const implementEndMs = Date.now();
             const implementation = parseImplementationReport(implRaw);
-            addReport('Building', `Implementation completed. Tests passed: ${implementation.testsPassed}`);
+            const buildingEndMs = Date.now();
+            addReport('Building', `### Execution\n` +
+                `- **Breakdown**: ${breakdownTitle} (${formatElapsed(breakdownStartMs, breakdownEndMs)})\n` +
+                `- **Validate**: ${validateTitle} (${formatElapsed(validateStartMs, validateEndMs)})\n` +
+                `- **Implement**: ${implementTitle} (${formatElapsed(implementStartMs, implementEndMs)})\n` +
+                `- **Tests passed**: ${implementation.testsPassed}\n` +
+                `- **Open issues**: ${implementation.openIssues.length > 0 ? implementation.openIssues.join('; ') : 'none'}\n\n` +
+                `**Phase time**: ${formatElapsed(buildingStartMs, buildingEndMs)}`);
             // ===================================================================
             // PHASE 3: REVIEWING (triage → fan-out review → synthesize → gate, loop up to 10)
             // ===================================================================
+            const reviewStartMs = Date.now();
+            const reviewIterationDetails = [];
             let reviewInput = implRaw;
             let reviewGate = { decision: 'REWORK' };
             for (let revIter = 0; revIter < 10 && reviewGate.decision === 'REWORK'; revIter++) {
+                const iteration = revIter + 1;
+                const triageTitle = `ff-review-triage-${iteration}`;
+                const synthTitle = `ff-review-synthesis-${iteration}`;
+                const reworkTitle = `ff-review-rework-${iteration}`;
+                const fanOutTitles = revModels.map((model) => `ff-fanout-${model.tag}`);
+                context.metadata({
+                    title: `⏳ Reviewing triage (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'reviewing',
+                        step: 'triage',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Triage
+                const triageStartMs = Date.now();
                 const brief = await promptSession(client, sessionId, triagePrompt(reviewInput), {
                     model: orchestratorModel,
                     agent: 'reviewing',
-                    title: `ff-review-triage-${revIter + 1}`,
+                    title: triageTitle,
+                });
+                const triageEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Review fan-out (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'reviewing',
+                        step: 'fan_out',
+                        iteration,
+                        maxIterations: 10,
+                    },
                 });
                 // Fan-out review
+                const fanOutStartMs = Date.now();
                 const reviewResults = await fanOut(client, sessionId, revModels, (tag) => reviewPrompt(brief, tag), 'reviewing');
+                const fanOutEndMs = Date.now();
+                context.metadata({
+                    title: '⏳ Synthesizing reviews...',
+                    metadata: {
+                        phase: 'reviewing',
+                        step: 'synthesis',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Synthesize
+                const synthStartMs = Date.now();
                 const synthRaw = await promptSession(client, sessionId, reviewSynthesisPrompt(reviewResults), {
                     model: orchestratorModel,
                     agent: 'reviewing',
-                    title: `ff-review-synthesis-${revIter + 1}`,
+                    title: synthTitle,
                 });
+                const synthEndMs = Date.now();
                 const synthesis = parseReviewSynthesis(synthRaw);
                 // Gate (deterministic)
-                reviewGate = evaluateReviewGate(synthesis, revIter + 1);
+                reviewGate = evaluateReviewGate(synthesis, iteration);
                 if (reviewGate.decision === 'APPROVED') {
-                    addReport('Reviewing', `APPROVED (confidence: ${synthesis.overallConfidence}, iteration: ${revIter + 1})`);
+                    context.metadata({
+                        title: `✅ Review APPROVED (confidence: ${synthesis.overallConfidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'reviewing',
+                            step: 'gate',
+                            decision: reviewGate.decision,
+                            confidence: synthesis.overallConfidence,
+                            unresolvedIssues: synthesis.unresolvedIssues,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
                 }
                 else if (reviewGate.decision === 'ESCALATE') {
-                    addReport('Reviewing', `ESCALATE: ${reviewGate.reason}`);
-                    return report.join('\n\n');
+                    context.metadata({
+                        title: '⚠️ Review ESCALATED',
+                        metadata: {
+                            phase: 'reviewing',
+                            step: 'gate',
+                            decision: reviewGate.decision,
+                            confidence: synthesis.overallConfidence,
+                            unresolvedIssues: synthesis.unresolvedIssues,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
                 }
                 else {
+                    context.metadata({
+                        title: `🔄 Review rework required (confidence: ${synthesis.overallConfidence}, iteration: ${iteration}/10)`,
+                        metadata: {
+                            phase: 'reviewing',
+                            step: 'gate',
+                            decision: reviewGate.decision,
+                            confidence: synthesis.overallConfidence,
+                            unresolvedIssues: synthesis.unresolvedIssues,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
+                }
+                let reworkLine = '- **Rework**: not required';
+                let feedback = synthesis.reworkInstructions || reviewGate.feedback || synthesis.consolidatedFindings || 'N/A';
+                if (reviewGate.decision === 'REWORK') {
+                    context.metadata({
+                        title: `⏳ Applying rework (iteration ${iteration}/10)...`,
+                        metadata: {
+                            phase: 'reviewing',
+                            step: 'rework',
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
                     // REWORK — apply fixes, then re-review
-                    const fixRaw = await promptSession(client, sessionId, implementBatchPrompt(`Rework required:\n${reviewGate.feedback}\n\nOriginal batches:\n${batchesRaw}`), { model: buildModel, agent: 'building', title: `ff-review-rework-${revIter + 1}` });
+                    const reworkStartMs = Date.now();
+                    const fixRaw = await promptSession(client, sessionId, implementBatchPrompt(`Rework required:\n${reviewGate.feedback}\n\nOriginal batches:\n${batchesRaw}`), { model: buildModel, agent: 'building', title: reworkTitle });
+                    const reworkEndMs = Date.now();
+                    reworkLine = `- **Rework**: ${reworkTitle} (${formatElapsed(reworkStartMs, reworkEndMs)})`;
                     reviewInput = fixRaw;
+                    feedback = reviewGate.feedback || feedback;
+                }
+                reviewIterationDetails.push(`### Iteration ${iteration}\n` +
+                    `- **Triage**: ${triageTitle} (${formatElapsed(triageStartMs, triageEndMs)})\n` +
+                    `- **Fan-out**: ${fanOutTitles.join(', ')} (${formatElapsed(fanOutStartMs, fanOutEndMs)})\n` +
+                    `- **Synthesis**: ${synthTitle} (${formatElapsed(synthStartMs, synthEndMs)})\n` +
+                    `- **Gate**: ${reviewGate.decision} (confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues})\n` +
+                    `${reworkLine}\n` +
+                    `- **Feedback**: ${feedback}`);
+                if (reviewGate.decision === 'ESCALATE') {
+                    const reviewEndMs = Date.now();
+                    addReport('Reviewing', `${reviewIterationDetails.join('\n\n')}\n\n**Outcome**: ESCALATE: ${reviewGate.reason}\n**Phase time**: ${formatElapsed(reviewStartMs, reviewEndMs)}`);
+                    context.metadata({
+                        title: '⚠️ Pipeline finished with issues',
+                        metadata: {
+                            phase: 'complete',
+                            outcome: 'issues',
+                            totalElapsedMs: Date.now() - totalStartMs,
+                        },
+                    });
+                    addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
+                    return report.join('\n\n');
                 }
             }
+            const reviewEndMs = Date.now();
+            addReport('Reviewing', `${reviewIterationDetails.join('\n\n')}\n\n**Outcome**: ${reviewGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : `REWORK exhausted (10 iterations). Last feedback: ${reviewGate.feedback}`}\n**Phase time**: ${formatElapsed(reviewStartMs, reviewEndMs)}`);
             if (reviewGate.decision !== 'APPROVED') {
-                addReport('Reviewing', `REWORK exhausted (10 iterations). Last feedback:\n${reviewGate.feedback}`);
+                context.metadata({
+                    title: '⚠️ Pipeline finished with issues',
+                    metadata: {
+                        phase: 'complete',
+                        outcome: 'issues',
+                        totalElapsedMs: Date.now() - totalStartMs,
+                    },
+                });
+                addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                 return report.join('\n\n');
             }
             // ===================================================================
             // PHASE 4: DOCUMENTATION (document → review → gate, loop up to 5)
             // ===================================================================
+            const documentationStartMs = Date.now();
+            const documentationIterationDetails = [];
             let docInput = `Implementation report:\n${implRaw}\n\nReview synthesis:\n${reviewInput}`;
             let docGate = { decision: 'REWORK' };
             for (let docIter = 0; docIter < 5 && docGate.decision === 'REWORK'; docIter++) {
+                const iteration = docIter + 1;
+                const writeTitle = `ff-doc-write-${iteration}`;
+                const reviewTitle = `ff-doc-review-${iteration}`;
+                context.metadata({
+                    title: `⏳ Writing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'write',
+                        iteration,
+                        maxIterations: 5,
+                    },
+                });
                 // Write docs
+                const writeStartMs = Date.now();
                 const docRaw = await promptSession(client, sessionId, documentPrompt(docInput), {
                     model: docModel,
                     agent: 'documenting',
-                    title: `ff-doc-write-${docIter + 1}`,
+                    title: writeTitle,
+                });
+                const writeEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Reviewing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'review',
+                        iteration,
+                        maxIterations: 5,
+                    },
                 });
                 // Review docs
+                const reviewDocStartMs = Date.now();
                 const docRevRaw = await promptSession(client, sessionId, docReviewPrompt(docRaw), {
                     model: docReviewModel,
                     agent: 'reviewing',
-                    title: `ff-doc-review-${docIter + 1}`,
+                    title: reviewTitle,
                 });
+                const reviewDocEndMs = Date.now();
                 const docReview = parseDocReview(docRevRaw);
                 // Gate (deterministic)
-                docGate = evaluateDocGate(docReview, docIter + 1);
+                docGate = evaluateDocGate(docReview, iteration);
                 if (docGate.decision === 'APPROVED') {
-                    addReport('Documentation', `APPROVED (confidence: ${docReview.confidence}, iteration: ${docIter + 1})`);
+                    context.metadata({
+                        title: `✅ Documentation APPROVED (confidence: ${docReview.confidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            unresolvedIssues: docReview.unresolvedIssues,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else if (docGate.decision === 'ESCALATE') {
-                    addReport('Documentation', `ESCALATE: ${docGate.reason}`);
+                    context.metadata({
+                        title: '⚠️ Documentation ESCALATED',
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            unresolvedIssues: docReview.unresolvedIssues,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else {
+                    context.metadata({
+                        title: `🔄 Documentation rework required (confidence: ${docReview.confidence}, iteration: ${iteration}/5)`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            unresolvedIssues: docReview.unresolvedIssues,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
+                }
+                const feedback = docReview.reworkInstructions || docGate.feedback || docReview.raw;
+                documentationIterationDetails.push(`### Iteration ${iteration}\n` +
+                    `- **Write**: ${writeTitle} (${formatElapsed(writeStartMs, writeEndMs)})\n` +
+                    `- **Review**: ${reviewTitle} (${formatElapsed(reviewDocStartMs, reviewDocEndMs)})\n` +
+                    `- **Gate**: ${docGate.decision} (confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
+                    `- **Feedback**: ${feedback}`);
+                if (docGate.decision === 'REWORK') {
                     // Feed feedback into the next iteration
                     docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
                 }
             }
+            const documentationEndMs = Date.now();
+            addReport('Documentation', `${documentationIterationDetails.join('\n\n')}\n\n**Outcome**: ${docGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : docGate.decision === 'ESCALATE'
+                    ? `ESCALATE: ${docGate.reason}`
+                    : `REWORK exhausted (5 iterations). Last feedback: ${docGate.feedback}`}\n**Phase time**: ${formatElapsed(documentationStartMs, documentationEndMs)}`);
             // ===================================================================
             // FINAL REPORT
             // ===================================================================
-            addReport('Complete', 'Pipeline finished.');
+            const totalEndMs = Date.now();
+            const completedWithoutIssues = docGate.decision === 'APPROVED';
+            context.metadata({
+                title: completedWithoutIssues ? '✅ Pipeline complete' : '⚠️ Pipeline finished with issues',
+                metadata: {
+                    phase: 'complete',
+                    outcome: completedWithoutIssues ? 'success' : 'issues',
+                    totalElapsedMs: totalEndMs - totalStartMs,
+                },
+            });
+            addReport('Complete', `${completedWithoutIssues ? 'Pipeline finished successfully.' : 'Pipeline finished with issues.'}\n**Total time**: ${formatElapsed(totalStartMs, totalEndMs)}`);
             return report.join('\n\n');
         },
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",