@syntesseraai/opencode-feature-factory 0.10.8 → 0.10.9

package/dist/tools/mini-loop.js

@@ -138,6 +138,7 @@ export function createMiniLoopTool(client) {
                     let implGate = { decision: 'REWORK', feedback: requirements };
                     let lastImplRaw = '';
                     let lastImplementationHandoff = '';
+                    let implementationStageHandoff = '';
                     let nextImplementationDirective;
                     // Phase start notification
                     await notify(`# Mini-Loop: Building started\n\nStarting implementation phase...\n`);
@@ -147,7 +148,7 @@ export function createMiniLoopTool(client) {
                         const reviewTitle = `ff-mini-review-${iteration}`;
                         const buildInput = implIter === 0
                             ? requirements
-                            : `${requirements}\n\nPrevious implementation handoff for context:\n${lastImplementationHandoff || lastImplRaw}`;
+                            : `${requirements}\n\nPrevious implementation/review/rework handoff:\n${implementationStageHandoff || lastImplementationHandoff || lastImplRaw}`;
                         context.metadata({
                             title: `⏳ Building (iteration ${iteration}/10)...`,
                             metadata: {
@@ -284,11 +285,25 @@ export function createMiniLoopTool(client) {
                             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);
+                            }, `${requirements}\n\n` +
+                                `Latest implementation handoff:\n${implementationHandoff}\n\n` +
+                                `Prior implementation/review/rework handoff:\n${implementationStageHandoff || 'No prior handoff recorded.'}\n\n` +
+                                `Review raw output:\n${reviewRaw}\n\n` +
+                                `Review feedback:\n${implGate.feedback || review.reworkInstructions || review.raw}`, implGate.feedback || review.reworkInstructions || review.raw);
                         }
                         else {
                             nextImplementationDirective = undefined;
                         }
+                        const implementationIterationHandoff = `### Implementation Iteration ${iteration}\n\n` +
+                            `BUILD_OUTPUT:\n${lastImplRaw}\n\n` +
+                            `IMPLEMENTATION_HANDOFF:\n${implementationHandoff}\n\n` +
+                            `REVIEW_OUTPUT:\n${reviewRaw}\n\n` +
+                            `GATE_DECISION: ${implGate.decision}\n` +
+                            `GATE_FEEDBACK:\n${implGate.feedback || review.reworkInstructions || review.raw}\n\n` +
+                            `NEXT_REWORK_DIRECTIVE:\n${nextImplementationDirective || 'No rework directive for this iteration.'}`;
+                        implementationStageHandoff = implementationStageHandoff
+                            ? `${implementationStageHandoff}\n\n${implementationIterationHandoff}`
+                            : implementationIterationHandoff;
                         if (implGate.decision === 'APPROVED') {
                             context.metadata({
                                 title: `✅ Implementation APPROVED (confidence: ${review.confidence}, iteration: ${iteration})`,
@@ -296,6 +311,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'implementation',
                                     step: 'gate',
                                     decision: implGate.decision,
+                                    changeRequested: review.changeRequested,
                                     confidence: review.confidence,
                                     iteration,
                                     maxIterations: 10,
@@ -309,6 +325,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'implementation',
                                     step: 'gate',
                                     decision: implGate.decision,
+                                    changeRequested: review.changeRequested,
                                     confidence: review.confidence,
                                     iteration,
                                     maxIterations: 10,
@@ -322,6 +339,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'implementation',
                                     step: 'gate',
                                     decision: implGate.decision,
+                                    changeRequested: review.changeRequested,
                                     confidence: review.confidence,
                                     iteration,
                                     maxIterations: 10,
@@ -340,6 +358,7 @@ export function createMiniLoopTool(client) {
                         // Notify each implementation iteration gate decision
                         await notify(`Stage: Building — iteration ${iteration}/10\n` +
                             `${formatStructuredStage(implementationStageOutput, implGate.decision === 'REWORK')}\n` +
+                            `Change Requested: ${review.changeRequested ? 'YES' : 'NO'}\n` +
                             `Confidence: ${review.confidence}%\n` +
                             `Unresolved Issues: ${review.unresolvedIssues}\n` +
                             `Duration: ${formatElapsed(implementationStartMs, Date.now())}`);
@@ -387,7 +406,8 @@ export function createMiniLoopTool(client) {
                     lastPhase = 'Documentation';
                     const documentationStartMs = Date.now();
                     const documentationIterationDetails = [];
-                    let docInput = lastImplementationHandoff || lastImplRaw;
+                    let docInput = `Latest implementation handoff:\n${lastImplementationHandoff || lastImplRaw}\n\n` +
+                        `Implementation/review/rework handoff history:\n${implementationStageHandoff || 'No implementation handoff history captured.'}`;
                     let docGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Mini-Loop: Documentation started\n\nStarting documentation phase...\n`);
@@ -439,6 +459,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'documentation',
                                     step: 'gate',
                                     decision: docGate.decision,
+                                    changeRequested: docReview.changeRequested,
                                     confidence: docReview.confidence,
                                     iteration,
                                     maxIterations: 5,
@@ -452,6 +473,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'documentation',
                                     step: 'gate',
                                     decision: docGate.decision,
+                                    changeRequested: docReview.changeRequested,
                                     confidence: docReview.confidence,
                                     iteration,
                                     maxIterations: 5,
@@ -465,6 +487,7 @@ export function createMiniLoopTool(client) {
                                     phase: 'documentation',
                                     step: 'gate',
                                     decision: docGate.decision,
+                                    changeRequested: docReview.changeRequested,
                                     confidence: docReview.confidence,
                                     iteration,
                                     maxIterations: 5,
@@ -478,19 +501,24 @@ export function createMiniLoopTool(client) {
                         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` +
+                            `- **Gate**: ${docGate.decision} (change requested: ${docReview.changeRequested ? 'yes' : 'no'}, confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
                             `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}`);
                         // Notify each documentation iteration gate decision
                         await notify(`Stage: Documentation — iteration ${iteration}/5\n` +
                             `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}\n` +
+                            `Change Requested: ${docReview.changeRequested ? 'YES' : 'NO'}\n` +
                             `Confidence: ${docReview.confidence}%\n` +
                             `Unresolved Issues: ${docReview.unresolvedIssues}\n` +
                             `Duration: ${formatElapsed(documentationStartMs, Date.now())}`);
                         if (docGate.decision === 'REWORK') {
+                            const docIterationHandoff = `Documentation write output:\n${docRaw}\n\n` +
+                                `Documentation review output:\n${docRevRaw}\n\n` +
+                                `Documentation gate decision: ${docGate.decision}\n` +
+                                `Documentation gate feedback:\n${docGate.feedback || docReview.reworkInstructions || docReview.raw}`;
                             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);
+                            }, `${docInput}\n\n${docIterationHandoff}`, docGate.feedback || docReview.reworkInstructions || docReview.raw);
                         }
                     }
                     const documentationEndMs = Date.now();

package/dist/tools/parsers.js

@@ -174,7 +174,9 @@ export function parseReviewSynthesis(raw) {
     const confidence = extractNumber(raw, 'confidence');
     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 parsedVerdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
+    const changeRequested = isYes(raw, 'CHANGE_REQUESTED') || parsedVerdict === 'REWORK_REQUIRED';
+    const verdict = changeRequested ? 'REWORK_REQUIRED' : 'APPROVED';
     const stageOutput = parseStageOutput(raw, {
         status: verdict,
         summary: `Review confidence ${confidence}/100 with ${unresolvedIssues} unresolved issues.`,
@@ -183,6 +185,7 @@ export function parseReviewSynthesis(raw) {
         overallConfidence: confidence,
         consolidatedFindings: raw,
         unresolvedIssues,
+        changeRequested,
         verdict,
         reworkInstructions: stageOutput.actionItems.length > 0
             ? formatActionItems(stageOutput.actionItems)
@@ -205,7 +208,9 @@ export function parseDocReview(raw) {
     const confidence = extractNumber(raw, 'confidence');
     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 parsedVerdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
+    const changeRequested = isYes(raw, 'CHANGE_REQUESTED') || parsedVerdict === 'REWORK_REQUIRED';
+    const verdict = changeRequested ? 'REWORK_REQUIRED' : 'APPROVED';
     const stageOutput = parseStageOutput(raw, {
         status: verdict,
         summary: `Documentation confidence ${confidence}/100 with ${unresolvedIssues} unresolved issues.`,
@@ -214,6 +219,7 @@ export function parseDocReview(raw) {
         verdict,
         unresolvedIssues,
         confidence,
+        changeRequested,
         reworkInstructions: stageOutput.actionItems.length > 0
             ? formatActionItems(stageOutput.actionItems)
             : extractSection(raw, 'rework') || undefined,

package/dist/tools/pipeline.js

@@ -45,6 +45,12 @@ const formatStructuredStage = (stage, includeActionItems) => {
     }
     return `${base}\nACTION_ITEMS:\n${asBulletList(stage.actionItems, 'No action items required.')}`;
 };
+const formatFanOutOutputs = (outputs) => {
+    if (outputs.length === 0) {
+        return 'No fan-out outputs captured.';
+    }
+    return outputs.map((output) => `--- ${output.tag} ---\n${output.raw}`).join('\n\n');
+};
 export function createPipelineTool(client) {
     return tool({
         description: 'Run the full Feature Factory pipeline: multi-model planning → build → review → documentation. ' +
@@ -500,6 +506,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                     const reviewStartMs = Date.now();
                     const reviewIterationDetails = [];
                     let reviewInput = implementationHandoff;
+                    let reviewStageHandoff = '';
                     let reviewGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Pipeline: Reviewing started\n\nStarting review phase with ${revModels.length} models...\n`);
@@ -526,6 +533,8 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                             title: triageTitle,
                         });
                         const triageEndMs = Date.now();
+                        const reviewContextForIteration = `Latest implementation handoff:\n${reviewInput}\n\n` +
+                            `Prior review/rework handoff:\n${reviewStageHandoff || 'No prior review handoff recorded.'}`;
                         context.metadata({
                             title: `⏳ Review fan-out (iteration ${iteration}/10)...`,
                             metadata: {
@@ -537,8 +546,9 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                         });
                         // Fan-out review
                         const fanOutStartMs = Date.now();
-                        const reviewResults = await fanOut(client, runContext, revModels, (tag) => reviewPrompt(brief, tag), 'reviewing');
+                        const reviewResults = await fanOut(client, runContext, revModels, (tag) => reviewPrompt(brief, tag, reviewContextForIteration), 'reviewing');
                         const fanOutEndMs = Date.now();
+                        const reviewFanOutOutput = formatFanOutOutputs(reviewResults);
                         context.metadata({
                             title: '⏳ Synthesizing reviews...',
                             metadata: {
@@ -567,6 +577,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: reviewGate.decision,
                                     confidence: synthesis.overallConfidence,
+                                    changeRequested: synthesis.changeRequested,
                                     unresolvedIssues: synthesis.unresolvedIssues,
                                     iteration,
                                     maxIterations: 10,
@@ -581,6 +592,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: reviewGate.decision,
                                     confidence: synthesis.overallConfidence,
+                                    changeRequested: synthesis.changeRequested,
                                     unresolvedIssues: synthesis.unresolvedIssues,
                                     iteration,
                                     maxIterations: 10,
@@ -595,6 +607,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: reviewGate.decision,
                                     confidence: synthesis.overallConfidence,
+                                    changeRequested: synthesis.changeRequested,
                                     unresolvedIssues: synthesis.unresolvedIssues,
                                     iteration,
                                     maxIterations: 10,
@@ -602,6 +615,8 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                             });
                         }
                         let reworkLine = '- **Rework**: not required';
+                        let reworkRaw = '';
+                        let reworkHandoff = '';
                         if (reviewGate.decision === 'REWORK') {
                             context.metadata({
                                 title: `⏳ Applying rework (iteration ${iteration}/10)...`,
@@ -617,16 +632,32 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                             const reworkSecondaryContext = `Original requirements:\n${requirements}\n\n` +
                                 `Original batches:\n${batchesRaw}\n\n` +
                                 `Latest implementation handoff:\n${reviewInput}\n\n` +
-                                `Prior synthesis raw output:\n${synthRaw}`;
+                                `Triage output:\n${brief}\n\n` +
+                                `Review fan-out outputs:\n${reviewFanOutOutput}\n\n` +
+                                `Latest synthesis output:\n${synthRaw}\n\n` +
+                                `Gate feedback:\n${reviewGate.feedback || synthesis.reworkInstructions || 'No gate feedback provided.'}\n\n` +
+                                `Prior review/rework handoff:\n${reviewStageHandoff || 'No prior review handoff recorded.'}`;
                             const reworkDirective = actionFirstReworkPrompt({
                                 ...synthesis.stageOutput,
                                 status: reviewGate.decision,
                             }, reworkSecondaryContext, reviewGate.feedback || synthesis.reworkInstructions || synthRaw);
-                            const fixRaw = await promptSession(client, runContext, pipelineReworkPrompt(reworkDirective, reworkSecondaryContext), { model: buildModel, agent: 'building', title: reworkTitle });
+                            reworkRaw = await promptSession(client, runContext, pipelineReworkPrompt(reworkDirective, reworkSecondaryContext), { model: buildModel, agent: 'building', title: reworkTitle });
                             const reworkEndMs = Date.now();
                             reworkLine = `- **Rework**: ${reworkTitle} (${formatElapsed(reworkStartMs, reworkEndMs)})`;
-                            reviewInput = formatImplementationReportForHandoff(parseImplementationReport(fixRaw));
+                            reworkHandoff = formatImplementationReportForHandoff(parseImplementationReport(reworkRaw));
+                            reviewInput = reworkHandoff;
                         }
+                        const reviewIterationHandoff = `### Review Iteration ${iteration}\n\n` +
+                            `TRIAGE_OUTPUT:\n${brief}\n\n` +
+                            `FAN_OUT_OUTPUTS:\n${reviewFanOutOutput}\n\n` +
+                            `SYNTHESIS_OUTPUT:\n${synthRaw}\n\n` +
+                            `GATE_DECISION: ${reviewGate.decision}\n` +
+                            `GATE_FEEDBACK:\n${reviewGate.feedback || synthesis.reworkInstructions || 'No gate feedback provided.'}\n\n` +
+                            `REWORK_OUTPUT:\n${reworkRaw || 'No rework output for this iteration.'}\n\n` +
+                            `REWORK_HANDOFF:\n${reworkHandoff || 'No rework handoff for this iteration.'}`;
+                        reviewStageHandoff = reviewStageHandoff
+                            ? `${reviewStageHandoff}\n\n${reviewIterationHandoff}`
+                            : reviewIterationHandoff;
                         const reviewStageOutput = {
                             ...synthesis.stageOutput,
                             status: reviewGate.decision,
@@ -637,12 +668,13 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                             `- **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` +
+                            `- **Gate**: ${reviewGate.decision} (change requested: ${synthesis.changeRequested ? 'yes' : 'no'}, confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues})\n` +
                             `${reworkLine}\n` +
                             `${formatStructuredStage(reviewStageOutput, reviewGate.decision === 'REWORK')}`);
                         // Notify each review iteration gate decision
                         await notify(`Stage: Reviewing — iteration ${iteration}/10\n` +
                             `${formatStructuredStage(reviewStageOutput, reviewGate.decision === 'REWORK')}\n` +
+                            `Change Requested: ${synthesis.changeRequested ? 'YES' : 'NO'}\n` +
                             `Confidence: ${synthesis.overallConfidence}%\n` +
                             `Unresolved Issues: ${synthesis.unresolvedIssues}\n` +
                             `Duration: ${formatElapsed(reviewStartMs, Date.now())}`);
@@ -691,7 +723,9 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                     lastPhase = 'Documentation';
                     const documentationStartMs = Date.now();
                     const documentationIterationDetails = [];
-                    let docInput = `Implementation handoff:\n${implementationHandoff}\n\nLatest implementation handoff after review loop:\n${reviewInput}`;
+                    let docInput = `Implementation handoff (initial build):\n${implementationHandoff}\n\n` +
+                        `Implementation handoff (latest after review loop):\n${reviewInput}\n\n` +
+                        `Review and rework handoff history:\n${reviewStageHandoff || 'No review handoff captured.'}`;
                     let docGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Pipeline: Documentation started\n\nStarting documentation phase...\n`);
@@ -744,6 +778,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: docGate.decision,
                                     confidence: docReview.confidence,
+                                    changeRequested: docReview.changeRequested,
                                     unresolvedIssues: docReview.unresolvedIssues,
                                     iteration,
                                     maxIterations: 5,
@@ -758,6 +793,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: docGate.decision,
                                     confidence: docReview.confidence,
+                                    changeRequested: docReview.changeRequested,
                                     unresolvedIssues: docReview.unresolvedIssues,
                                     iteration,
                                     maxIterations: 5,
@@ -772,6 +808,7 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                                     step: 'gate',
                                     decision: docGate.decision,
                                     confidence: docReview.confidence,
+                                    changeRequested: docReview.changeRequested,
                                     unresolvedIssues: docReview.unresolvedIssues,
                                     iteration,
                                     maxIterations: 5,
@@ -785,20 +822,25 @@ Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
                         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` +
+                            `- **Gate**: ${docGate.decision} (change requested: ${docReview.changeRequested ? 'yes' : 'no'}, confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
                             `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}`);
                         // Notify each documentation iteration gate decision
                         await notify(`Stage: Documentation — iteration ${iteration}/5\n` +
                             `${formatStructuredStage(docStageOutput, docGate.decision === 'REWORK')}\n` +
+                            `Change Requested: ${docReview.changeRequested ? 'YES' : 'NO'}\n` +
                             `Confidence: ${docReview.confidence}%\n` +
                             `Unresolved Issues: ${docReview.unresolvedIssues}\n` +
                             `Duration: ${formatElapsed(documentationStartMs, Date.now())}`);
                         if (docGate.decision === 'REWORK') {
                             // Feed feedback into the next iteration
+                            const docIterationHandoff = `Documentation write output:\n${docRaw}\n\n` +
+                                `Documentation review output:\n${docRevRaw}\n\n` +
+                                `Documentation gate decision: ${docGate.decision}\n` +
+                                `Documentation gate feedback:\n${docGate.feedback || docReview.reworkInstructions || docReview.raw}`;
                             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);
+                            }, `${docInput}\n\n${docIterationHandoff}`, docGate.feedback || docReview.reworkInstructions || docReview.raw);
                         }
                     }
                     const documentationEndMs = Date.now();

package/dist/tools/prompts.d.ts

@@ -21,7 +21,7 @@ export declare function validateBatchPrompt(tasks: string): string;
 export declare function implementBatchPrompt(batches: string): string;
 export declare function pipelineReworkPrompt(primaryDirective: string, secondaryContext: string): string;
 export declare function triagePrompt(implementationReport: string): string;
-export declare function reviewPrompt(brief: string, modelTag: string): string;
+export declare function reviewPrompt(brief: string, modelTag: string, fullContext: string): string;
 export declare function reviewSynthesisPrompt(reviews: Array<{
     tag: string;
     raw: string;

package/dist/tools/prompts.js

@@ -154,13 +154,17 @@ Include:
 
 Return a structured REVIEW_BRIEF output.`;
 }
-export function reviewPrompt(brief, modelTag) {
+export function reviewPrompt(brief, modelTag, fullContext) {
     return `[MODEL_TAG:${modelTag}]
 
-Review the current task from the triage brief below for correctness, quality, architecture validity, testing, security, and edge cases.
+Review the current task using both the triage brief and the full upstream context below for correctness, quality, architecture validity, testing, security, and edge cases.
 
+TRIAGE_BRIEF:
 ${brief}
 
+FULL_UPSTREAM_CONTEXT:
+${fullContext}
+
 Classify findings as critical/high/medium/low and include a confidence score (0-100).
 
 Return a structured review report.`;
@@ -178,8 +182,9 @@ Required output fields (strict):
 4. ISSUES
 5. ACTION_ITEMS (required when verdict is REWORK_REQUIRED)
 6. CONFIDENCE (0-100)
-7. UNRESOLVED_ISSUES (integer)
-8. VERDICT (APPROVED or REWORK_REQUIRED)
+7. CHANGE_REQUESTED=YES|NO
+8. UNRESOLVED_ISSUES (integer)
+9. VERDICT (APPROVED or REWORK_REQUIRED)
 
 When rework is needed, ACTION_ITEMS must be concrete, testable, and ordered by dependency.`;
 }
@@ -215,9 +220,10 @@ Required output fields (strict):
 3. CHECKLIST
 4. ISSUES
 5. ACTION_ITEMS (required when verdict is REWORK_REQUIRED)
-6. VERDICT (APPROVED or REWORK_REQUIRED)
-7. UNRESOLVED_DOCUMENTATION_ISSUES (integer)
-8. CONFIDENCE (0-100)`;
+6. CHANGE_REQUESTED=YES|NO
+7. VERDICT (APPROVED or REWORK_REQUIRED)
+8. UNRESOLVED_DOCUMENTATION_ISSUES (integer)
+9. CONFIDENCE (0-100)`;
 }
 // ---------------------------------------------------------------------------
 // Mini-loop specific

package/dist/workflow/gate-evaluator.d.ts

@@ -17,28 +17,25 @@ export declare function evaluatePlanningGate(consensus: ConsensusPlan): GateResu
 /**
  * Evaluate the review approval gate.
  *
- * - confidence >=95 AND unresolvedIssues == 0 → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export declare function evaluateReviewGate(synthesis: ReviewSynthesis, iteration: number, maxIterations?: number): GateResult;
 /**
  * Evaluate the documentation approval gate.
  *
- * - confidence >95, no change requested, 0 unresolved → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export declare function evaluateDocGate(review: DocReview, iteration: number, maxIterations?: number): GateResult;
 /**
  * Evaluate the mini-loop implementation gate.
  *
- * - confidence >95, no change requested, 0 blocking issues → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export declare function evaluateMiniLoopImplGate(review: MiniLoopReview, iteration: number, maxIterations?: number): GateResult;
 /**

package/dist/workflow/gate-evaluator.js

@@ -5,28 +5,29 @@
  * threshold logic directly. The LLM still produces the synthesis; the
  * gate decision is computed here.
  */
+const REWORK_CONFIDENCE_THRESHOLD = 90;
+function asBulletList(items, empty) {
+    if (items.length === 0) {
+        return `- ${empty}`;
+    }
+    return items.map((item) => `- ${item}`).join('\n');
+}
 function formatActionItems(actionItems) {
     if (actionItems.length === 0) {
-        return '';
+        return '- No explicit action items provided.';
     }
     return actionItems.map((item, index) => `${index + 1}. ${item}`).join('\n');
 }
-// ---------------------------------------------------------------------------
-// Vacuous review detection
-// ---------------------------------------------------------------------------
-/**
- * Detect whether a review is "vacuous" — the reviewer produced no
- * substantive feedback.  This happens when the LLM returns no
- * structured fields or an empty review: confidence falls back to 0,
- * unresolvedIssues is 0, and there are no real action items.
- *
- * When a review is vacuous the gate should auto-approve rather than
- * triggering an infinite rework loop with no actionable feedback.
- */
-function isVacuousReview(unresolvedIssues, stageOutput) {
-    return (unresolvedIssues === 0 &&
-        stageOutput.actionItems.length === 0 &&
-        stageOutput.issues.length === 0);
+function formatFullStageFeedback(stageOutput, rawOutput) {
+    const normalizedRaw = rawOutput.trim().length > 0 ? rawOutput.trim() : stageOutput.raw.trim();
+    return [
+        `STATUS: ${stageOutput.status}`,
+        `SUMMARY: ${stageOutput.summary}`,
+        `CHECKLIST:\n${asBulletList(stageOutput.checklist, 'No checklist provided.')}`,
+        `ISSUES:\n${asBulletList(stageOutput.issues, 'No issues reported.')}`,
+        `ACTION_ITEMS:\n${formatActionItems(stageOutput.actionItems)}`,
+        `RAW_STAGE_OUTPUT:\n${normalizedRaw || 'No raw output provided.'}`,
+    ].join('\n\n');
 }
 // ---------------------------------------------------------------------------
 // Planning gate
@@ -59,32 +60,25 @@ export function evaluatePlanningGate(consensus) {
 /**
  * Evaluate the review approval gate.
  *
- * - confidence >=95 AND unresolvedIssues == 0 → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export function evaluateReviewGate(synthesis, iteration, maxIterations = 10) {
-    if (synthesis.overallConfidence >= 95 && synthesis.unresolvedIssues === 0) {
-        return { decision: 'APPROVED' };
-    }
-    if (isVacuousReview(synthesis.unresolvedIssues, synthesis.stageOutput)) {
+    const needsRework = synthesis.changeRequested || synthesis.overallConfidence < REWORK_CONFIDENCE_THRESHOLD;
+    if (!needsRework) {
         return { decision: 'APPROVED' };
     }
     if (iteration >= maxIterations) {
         return {
             decision: 'ESCALATE',
-            reason: `Max review iterations reached (${maxIterations}). Confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues}`,
+            reason: `Max review iterations reached (${maxIterations}). ` +
+                `Change requested: ${synthesis.changeRequested}, confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues}`,
         };
     }
-    const actionFirstFeedback = synthesis.stageOutput.actionItems.length > 0
-        ? `ACTION_ITEMS:\n${formatActionItems(synthesis.stageOutput.actionItems)}\n\nSUMMARY:\n${synthesis.stageOutput.summary}`
-        : undefined;
     return {
         decision: 'REWORK',
-        feedback: actionFirstFeedback ??
-            synthesis.reworkInstructions ??
-            `Confidence ${synthesis.overallConfidence}/100 with ${synthesis.unresolvedIssues} unresolved issues.`,
+        feedback: formatFullStageFeedback(synthesis.stageOutput, synthesis.raw),
     };
 }
 // ---------------------------------------------------------------------------
@@ -93,32 +87,25 @@ export function evaluateReviewGate(synthesis, iteration, maxIterations = 10) {
 /**
  * Evaluate the documentation approval gate.
  *
- * - confidence >95, no change requested, 0 unresolved → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export function evaluateDocGate(review, iteration, maxIterations = 5) {
-    if (review.verdict === 'APPROVED' && review.unresolvedIssues === 0 && review.confidence > 95) {
-        return { decision: 'APPROVED' };
-    }
-    if (isVacuousReview(review.unresolvedIssues, review.stageOutput)) {
+    const needsRework = review.changeRequested || review.confidence < REWORK_CONFIDENCE_THRESHOLD;
+    if (!needsRework) {
         return { decision: 'APPROVED' };
     }
     if (iteration >= maxIterations) {
         return {
             decision: 'ESCALATE',
-            reason: `Max doc iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+            reason: `Max doc iterations reached (${maxIterations}). ` +
+                `Change requested: ${review.changeRequested}, confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
         };
     }
-    const actionFirstFeedback = review.stageOutput.actionItems.length > 0
-        ? `ACTION_ITEMS:\n${formatActionItems(review.stageOutput.actionItems)}\n\nSUMMARY:\n${review.stageOutput.summary}`
-        : undefined;
     return {
         decision: 'REWORK',
-        feedback: actionFirstFeedback ??
-            review.reworkInstructions ??
-            `Documentation review verdict: ${review.verdict}. ${review.unresolvedIssues} unresolved issues.`,
+        feedback: formatFullStageFeedback(review.stageOutput, review.raw),
     };
 }
 // ---------------------------------------------------------------------------
@@ -127,32 +114,25 @@ export function evaluateDocGate(review, iteration, maxIterations = 5) {
 /**
  * Evaluate the mini-loop implementation gate.
  *
- * - confidence >95, no change requested, 0 blocking issues → APPROVED
- * - vacuous review (0 issues, 0 action items) → APPROVED (nothing to fix)
+ * - change requested OR confidence < 90 → REWORK
  * - iteration >= maxIterations → ESCALATE
- * - otherwise → REWORK
+ * - otherwise → APPROVED
  */
 export function evaluateMiniLoopImplGate(review, iteration, maxIterations = 10) {
-    if (review.confidence > 95 && !review.changeRequested && review.unresolvedIssues === 0) {
-        return { decision: 'APPROVED' };
-    }
-    if (isVacuousReview(review.unresolvedIssues, review.stageOutput)) {
+    const needsRework = review.changeRequested || review.confidence < REWORK_CONFIDENCE_THRESHOLD;
+    if (!needsRework) {
         return { decision: 'APPROVED' };
     }
     if (iteration >= maxIterations) {
         return {
             decision: 'ESCALATE',
-            reason: `Max mini-loop iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+            reason: `Max mini-loop iterations reached (${maxIterations}). ` +
+                `Change requested: ${review.changeRequested}, confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
         };
     }
-    const actionFirstFeedback = review.stageOutput.actionItems.length > 0
-        ? `ACTION_ITEMS:\n${formatActionItems(review.stageOutput.actionItems)}\n\nSUMMARY:\n${review.stageOutput.summary}`
-        : undefined;
     return {
         decision: 'REWORK',
-        feedback: actionFirstFeedback ??
-            review.reworkInstructions ??
-            `Change requested: ${review.changeRequested}, confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+        feedback: formatFullStageFeedback(review.stageOutput, review.raw),
     };
 }
 // ---------------------------------------------------------------------------

package/dist/workflow/types.d.ts

@@ -105,6 +105,7 @@ export interface ReviewSynthesis {
     overallConfidence: number;
     consolidatedFindings: string;
     unresolvedIssues: number;
+    changeRequested: boolean;
     verdict: 'APPROVED' | 'REWORK_REQUIRED';
     reworkInstructions?: string;
     stageOutput: StageOutput;
@@ -124,6 +125,7 @@ export interface DocReview {
     verdict: 'APPROVED' | 'REWORK_REQUIRED';
     unresolvedIssues: number;
     confidence: number;
+    changeRequested: boolean;
     reworkInstructions?: string;
     stageOutput: StageOutput;
     raw: string;

package/package.json

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