@syntesseraai/opencode-feature-factory 0.10.6 → 0.10.7

package/dist/tools/pipeline.js

@@ -11,15 +11,40 @@
  * to the parent session via `promptAsync(noReply: true)`.
  */
 import { tool } from '@opencode-ai/plugin/tool';
+import { randomUUID } from 'node:crypto';
 import { fanOut, promptSession, notifyParent, evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, PLANNING_MODELS, REVIEW_MODELS, ORCHESTRATOR_MODEL, BUILD_MODEL, DOC_MODEL, VALIDATE_MODEL, DOC_REVIEW_MODEL, parseModelString, parseNamedModels, } from '../workflow/orchestrator.js';
-import { planningPrompt, synthesisPrompt, breakdownPrompt, validateBatchPrompt, implementBatchPrompt, triagePrompt, reviewPrompt, reviewSynthesisPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, } from './prompts.js';
+import { planningPrompt, synthesisPrompt, breakdownPrompt, validateBatchPrompt, implementBatchPrompt, pipelineReworkPrompt, triagePrompt, reviewPrompt, reviewSynthesisPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, runNamePrompt, actionFirstReworkPrompt, } from './prompts.js';
 import { ciScriptExists, runCI } from '../workflow/ci-runner.js';
 import { cleanupWorktree, resolveRunDirectory } from '../workflow/run-isolation.js';
-import { parseConsensusPlan, parseReviewSynthesis, parseImplementationReport, parseDocReview, } from './parsers.js';
+import { parseConsensusPlan, parseReviewSynthesis, parseImplementationReport, formatImplementationReportForHandoff, parseDocReview, } from './parsers.js';
 // ---------------------------------------------------------------------------
 // Tool factory — needs the SDK client from plugin init
 // ---------------------------------------------------------------------------
 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 createPipelineTool(client) {
     return tool({
         description: 'Run the full Feature Factory pipeline: multi-model planning → build → review → documentation. ' +
@@ -72,6 +97,8 @@ export function createPipelineTool(client) {
             const callerSessionId = context.sessionID;
             const agent = context.agent;
             const { requirements } = args;
+            const runId = randomUUID();
+            let runName = normalizeRunName(requirements.split('\n')[0] || '', 'Pipeline Workflow');
             // Resolve models — use provided overrides or fall back to defaults
             const planModels = args.planning_models
                 ? parseNamedModels(args.planning_models)
@@ -108,6 +135,18 @@ export function createPipelineTool(client) {
                 sessionId: callerSessionId,
                 directory: runDirectoryContext.runDirectory,
             };
+            try {
+                const runNameRaw = await promptSession(client, runContext, runNamePrompt('Pipeline', requirements), {
+                    model: orchestratorModel,
+                    agent: 'planning',
+                    title: 'ff-pipeline-run-name',
+                });
+                runName = normalizeRunName(runNameRaw, runName);
+            }
+            catch {
+                // Keep fallback name derived from requirements when name generation fails.
+            }
+            const runHeader = `Pipeline: ${runName} (${runId})`;
             // Fire-and-forget: run full orchestration in background
             let lastPhase = 'init';
             const asyncOrchestration = async () => {
@@ -118,7 +157,7 @@ export function createPipelineTool(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: PLANNING (fan-out → synthesize → gate, loop up to 5)
                     // ===================================================================
@@ -213,13 +252,30 @@ export function createPipelineTool(client) {
                             planningGate.feedback ||
                             consensus.divergentElements ||
                             'N/A';
+                        const planningStageOutput = {
+                            status: planningGate.decision,
+                            summary: `Planning iteration ${iteration} produced consensus score ${consensus.consensusScore}%.`,
+                            checklist: [
+                                `Fan-out models: ${fanOutTitles.join(', ')}`,
+                                `Synthesis session: ${synthesisTitle}`,
+                                `Gate decision: ${planningGate.decision}`,
+                            ],
+                            issues: planningGate.decision === 'APPROVED'
+                                ? []
+                                : [feedback],
+                            actionItems: planningGate.decision === 'REWORK'
+                                ? [feedback]
+                                : [],
+                            raw: feedback,
+                        };
                         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}`);
+                            `${formatStructuredStage(planningStageOutput, planningGate.decision === 'REWORK')}`);
                         // Notify each planning iteration gate decision
-                        await notify(`# Pipeline: Planning — Iteration ${iteration}/5\n\nStatus: ${planningGate.decision}\nConsensus Score: ${consensus.consensusScore}%\nDuration: ${formatElapsed(planningStartMs, Date.now())}\nFeedback: ${feedback}\n`);
+                        await notify(`Stage: Planning — iteration ${iteration}/5\n` +
+                            `${formatStructuredStage(planningStageOutput, planningGate.decision === 'REWORK')}\n` +
+                            `Duration: ${formatElapsed(planningStartMs, Date.now())}`);
                         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)}`);
@@ -314,6 +370,18 @@ export function createPipelineTool(client) {
                     });
                     const implementEndMs = Date.now();
                     const implementation = parseImplementationReport(implRaw);
+                    const implementationHandoff = formatImplementationReportForHandoff(implementation);
+                    const buildingStageOutput = {
+                        ...implementation.stageOutput,
+                        status: implementation.stageOutput.status ||
+                            (implementation.testsPassed && implementation.openIssues.length === 0
+                                ? 'APPROVED'
+                                : 'REWORK_REQUIRED'),
+                    };
+                    await notify(`Stage: Building — implementation handoff
+${formatStructuredStage(buildingStageOutput, buildingStageOutput.actionItems.length > 0)}
+Files Changed: ${implementation.filesChanged.length}
+Tests Passed: ${implementation.testsPassed}`);
                     // ---------------------------------------------------------------
                     // CI validation (deterministic subprocess — not an LLM prompt)
                     // ---------------------------------------------------------------
@@ -334,14 +402,32 @@ export function createPipelineTool(client) {
                                     maxCiAttempts,
                                 },
                             });
-                            await notify(`# Pipeline: CI validation — attempt ${ciAttempt}/${maxCiAttempts}\n`);
                             const ciResult = await runCI(ciDir);
                             if (ciResult.passed) {
-                                await notify(`# Pipeline: 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(`# Pipeline: 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({
@@ -380,22 +466,40 @@ export function createPipelineTool(client) {
                         }
                     }
                     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` +
+                    addReport('Building', `### Execution
+` +
+                        `- **Breakdown**: ${breakdownTitle} (${formatElapsed(breakdownStartMs, breakdownEndMs)})
+` +
+                        `- **Validate**: ${validateTitle} (${formatElapsed(validateStartMs, validateEndMs)})
+` +
+                        `- **Implement**: ${implementTitle} (${formatElapsed(implementStartMs, implementEndMs)})
+` +
+                        `- **Tests passed**: ${implementation.testsPassed}
+` +
+                        `- **Open issues**: ${implementation.openIssues.length > 0 ? implementation.openIssues.join('; ') : 'none'}
+
+` +
+                        `${formatStructuredStage(buildingStageOutput, buildingStageOutput.actionItems.length > 0)}
+
+` +
                         `**Phase time**: ${formatElapsed(buildingStartMs, buildingEndMs)}`);
                     // Phase end notification
-                    await notify(`# Pipeline: Building ended\n\nOutcome: COMPLETE\nFiles Changed: ${implementation.filesChanged.length}\nTests Passed: ${implementation.testsPassed}\nOpen Issues: ${implementation.openIssues.length > 0 ? implementation.openIssues.join('; ') : 'none'}\nPhase time: ${formatElapsed(buildingStartMs, buildingEndMs)}\n`);
+                    await notify(`# Pipeline: Building ended
+
+Outcome: COMPLETE
+${formatStructuredStage(buildingStageOutput, buildingStageOutput.actionItems.length > 0)}
+Files Changed: ${implementation.filesChanged.length}
+Tests Passed: ${implementation.testsPassed}
+Open Issues: ${implementation.openIssues.length > 0 ? implementation.openIssues.join('; ') : 'none'}
+Phase time: ${formatElapsed(buildingStartMs, buildingEndMs)}
+`);
                     // ===================================================================
                     // PHASE 3: REVIEWING (triage → fan-out review → synthesize → gate, loop up to 10)
                     // ===================================================================
                     lastPhase = 'Reviewing';
                     const reviewStartMs = Date.now();
                     const reviewIterationDetails = [];
-                    let reviewInput = implRaw;
+                    let reviewInput = implementationHandoff;
                     let reviewGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Pipeline: Reviewing started\n\nStarting review phase with ${revModels.length} models...\n`);
@@ -498,10 +602,6 @@ export function createPipelineTool(client) {
                             });
                         }
                         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)...`,
@@ -514,21 +614,38 @@ export function createPipelineTool(client) {
                             });
                             // REWORK — apply fixes, then re-review
                             const reworkStartMs = Date.now();
-                            const fixRaw = await promptSession(client, runContext, implementBatchPrompt(`Rework required:\n${reviewGate.feedback}\n\nOriginal batches:\n${batchesRaw}`), { model: buildModel, agent: 'building', title: reworkTitle });
+                            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}`;
+                            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 });
                             const reworkEndMs = Date.now();
                             reworkLine = `- **Rework**: ${reworkTitle} (${formatElapsed(reworkStartMs, reworkEndMs)})`;
-                            reviewInput = fixRaw;
-                            feedback = reviewGate.feedback || feedback;
+                            reviewInput = formatImplementationReportForHandoff(parseImplementationReport(fixRaw));
                         }
+                        const reviewStageOutput = {
+                            ...synthesis.stageOutput,
+                            status: reviewGate.decision,
+                            summary: synthesis.stageOutput.summary ||
+                                `Review confidence ${synthesis.overallConfidence}% with ${synthesis.unresolvedIssues} unresolved issues.`,
+                        };
                         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}`);
+                            `${formatStructuredStage(reviewStageOutput, reviewGate.decision === 'REWORK')}`);
                         // Notify each review iteration gate decision
-                        await notify(`# Pipeline: Reviewing — Iteration ${iteration}/10\n\nStatus: ${reviewGate.decision}\nConfidence: ${synthesis.overallConfidence}%\nUnresolved Issues: ${synthesis.unresolvedIssues}\nDuration: ${formatElapsed(reviewStartMs, Date.now())}\nFeedback: ${feedback}\n`);
+                        await notify(`Stage: Reviewing — iteration ${iteration}/10\n` +
+                            `${formatStructuredStage(reviewStageOutput, reviewGate.decision === 'REWORK')}\n` +
+                            `Confidence: ${synthesis.overallConfidence}%\n` +
+                            `Unresolved Issues: ${synthesis.unresolvedIssues}\n` +
+                            `Duration: ${formatElapsed(reviewStartMs, Date.now())}`);
                         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)}`);
@@ -550,7 +667,9 @@ export function createPipelineTool(client) {
                     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)}`);
+                        : reviewGate.decision === 'ESCALATE'
+                            ? `ESCALATE: ${reviewGate.reason}`
+                            : `REWORK exhausted (10 iterations). Last feedback: ${reviewGate.feedback}`}\n**Phase time**: ${formatElapsed(reviewStartMs, reviewEndMs)}`);
                     // Phase end notification
                     await notify(`# Pipeline: Reviewing ended\n\nOutcome: ${reviewGate.decision}\nDuration: ${formatElapsed(reviewStartMs, reviewEndMs)}\n`);
                     if (reviewGate.decision !== 'APPROVED') {
@@ -572,7 +691,7 @@ export function createPipelineTool(client) {
                     lastPhase = 'Documentation';
                     const documentationStartMs = Date.now();
                     const documentationIterationDetails = [];
-                    let docInput = `Implementation report:\n${implRaw}\n\nReview synthesis:\n${reviewInput}`;
+                    let docInput = `Implementation handoff:\n${implementationHandoff}\n\nLatest implementation handoff after review loop:\n${reviewInput}`;
                     let docGate = { decision: 'REWORK' };
                     // Phase start notification
                     await notify(`# Pipeline: Documentation started\n\nStarting documentation phase...\n`);
@@ -659,17 +778,27 @@ export function createPipelineTool(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(reviewDocStartMs, reviewDocEndMs)})\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(`# Pipeline: 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') {
                             // Feed feedback into the next iteration
-                            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();
@@ -706,11 +835,11 @@ export function createPipelineTool(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, `# Pipeline: Error\n\nPhase: ${lastPhase}\nError: ${message}\n`, { noReply: false });
+                await notifyParent(client, runContext, agent, `# Pipeline: ${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 `Pipeline started for: ${summary}\n\nRun directory: ${runDirectoryContext.runDirectory}\nWorktree isolation: ${runDirectoryContext.worktreeEnabled ? 'enabled' : 'disabled'}\nYou will receive progress updates as each phase completes.`;
+            return `Pipeline 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/prompts.d.ts

@@ -4,6 +4,13 @@
  * Centralised here so that tools stay lean and prompts are easy to review
  * and tune independently.
  */
+type ReworkStageContract = {
+    status: string;
+    summary: string;
+    checklist: string[];
+    issues: string[];
+    actionItems: string[];
+};
 export declare function planningPrompt(requirements: string, modelTag: string): string;
 export declare function synthesisPrompt(proposals: Array<{
     tag: string;
@@ -12,6 +19,7 @@ export declare function synthesisPrompt(proposals: Array<{
 export declare function breakdownPrompt(finalPlan: string): string;
 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 reviewSynthesisPrompt(reviews: Array<{
@@ -23,3 +31,6 @@ export declare function docReviewPrompt(docUpdate: string): string;
 export declare function miniBuildPrompt(requirements: string, reworkFeedback?: string): string;
 export declare function ciFixPrompt(requirements: string, ciOutput: string): string;
 export declare function miniReviewPrompt(implementationReport: string): string;
+export declare function runNamePrompt(workflowLabel: 'Pipeline' | 'Mini-Loop', requirements: string): string;
+export declare function actionFirstReworkPrompt(stage: ReworkStageContract, secondaryContext: string, gateFeedback?: string): string;
+export {};

package/dist/tools/prompts.js

@@ -4,6 +4,23 @@
  * Centralised here so that tools stay lean and prompts are easy to review
  * and tune independently.
  */
+function asNumberedList(items, empty) {
+    if (items.length === 0) {
+        return `1. ${empty}`;
+    }
+    return items.map((item, index) => `${index + 1}. ${item}`).join('\n');
+}
+function extractActionItemsFromFeedback(feedback) {
+    const explicitActionBlock = feedback.match(/ACTION_ITEMS?[\s:=]*\n([\s\S]*)/i)?.[1] || '';
+    const source = explicitActionBlock || feedback;
+    return source
+        .split('\n')
+        .map((line) => line.trim())
+        .map((line) => line.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !/^(STATUS|SUMMARY|CHECKLIST|ISSUES|ACTION_ITEMS|VERDICT|CONFIDENCE|UNRESOLVED)/i.test(line))
+        .slice(0, 8);
+}
 // ---------------------------------------------------------------------------
 // Planning
 // ---------------------------------------------------------------------------
@@ -84,7 +101,43 @@ For each task:
 3. run lint/typecheck/tests for impacted scope
 4. return a structured completion report
 
-After all batches complete, merge the per-task completion reports into a single IMPLEMENTATION_REPORT output.`;
+After all batches complete, return a final implementation handoff using this exact section schema:
+- STATUS
+- SUMMARY
+- CHECKLIST
+- ISSUES
+- ACTION_ITEMS (required if unresolved issues remain)
+- IMPLEMENTED_TASKS
+- FILES_CHANGED
+- TEST_RESULTS
+- OPEN_ISSUES
+- ASSUMPTIONS_MADE`;
+}
+export function pipelineReworkPrompt(primaryDirective, secondaryContext) {
+    return `Apply review-requested rework for the current pipeline iteration.
+
+PRIMARY DIRECTIVE (must execute first):
+${primaryDirective}
+
+SECONDARY CONTEXT (for reference only):
+${secondaryContext}
+
+Requirements:
+1. Execute ACTION_ITEMS in dependency order and verify each item is resolved.
+2. Keep original requirements/spec/history as contextual reference only.
+3. Add or update tests for behavioral changes.
+4. Run lint/typecheck/tests only for impacted scope.
+5. Return a structured implementation handoff using this exact section schema:
+   - STATUS
+   - SUMMARY
+   - CHECKLIST
+   - ISSUES
+   - ACTION_ITEMS (required if unresolved issues remain)
+   - IMPLEMENTED_TASKS
+   - FILES_CHANGED
+   - TEST_RESULTS
+   - OPEN_ISSUES
+   - ASSUMPTIONS_MADE`;
 }
 // ---------------------------------------------------------------------------
 // Reviewing
@@ -118,12 +171,17 @@ export function reviewSynthesisPrompt(reviews) {
 
 ${formatted}
 
-Required output:
-1. overall confidence (0-100)
-2. consolidated deduplicated findings
-3. unresolved issues list (count)
-4. verdict APPROVED or REWORK_REQUIRED
-5. explicit rework instructions when needed`;
+Required output fields (strict):
+1. STATUS
+2. SUMMARY
+3. CHECKLIST
+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)
+
+When rework is needed, ACTION_ITEMS must be concrete, testable, and ordered by dependency.`;
 }
 // ---------------------------------------------------------------------------
 // Documentation
@@ -136,38 +194,61 @@ ${input}
 Requirements:
 1. Use the latest approved review outputs and implementation artifacts as source of truth.
 2. Update all affected docs so behavior and operational steps match shipped code.
-3. If this is a rework iteration, incorporate documentation reviewer feedback from the previous documentation review.
+3. If this is a rework iteration, treat ACTION_ITEMS as the primary instructions and treat prior requirements/spec text as secondary context.
 4. Summarize what docs were changed and why.
 
-Return a structured documentation update summary.`;
+Return a structured documentation update summary with sections:
+- STATUS
+- SUMMARY
+- CHECKLIST
+- ISSUES
+- ACTION_ITEMS (required if documentation rework remains).`;
 }
 export function docReviewPrompt(docUpdate) {
     return `Review the latest documentation pass for completeness, correctness, and repository doc consistency.
 
 ${docUpdate}
 
-Required output:
-1. verdict APPROVED or REWORK_REQUIRED
-2. unresolved documentation issues (count, integer)
-3. explicit rework instructions
-4. confidence score (0-100)`;
+Required output fields (strict):
+1. STATUS
+2. SUMMARY
+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)`;
 }
 // ---------------------------------------------------------------------------
 // Mini-loop specific
 // ---------------------------------------------------------------------------
 export function miniBuildPrompt(requirements, reworkFeedback) {
     const rework = reworkFeedback
-        ? `\n\nPrevious review feedback to address:\n${reworkFeedback}`
+        ? `\n\nACTION-FIRST REWORK DIRECTIVE (primary):\n${reworkFeedback}`
         : '';
     return `Implement the current mini-loop requirements below.
 
-${requirements}${rework}
+Primary directive:
+${rework || 'No rework directive for this iteration.'}
+
+Secondary context:
+${requirements}
 
 Requirements:
 1. Apply requested code rework when present.
 2. Add or update tests for behavioral changes.
 3. Run lint/typecheck/tests only for impacted scope.
-4. Return a concise implementation report with changed files, tests run, and known open issues.`;
+4. Return a structured implementation handoff using this exact section schema:
+   - STATUS
+   - SUMMARY
+   - CHECKLIST
+   - ISSUES
+   - ACTION_ITEMS (required if unresolved issues remain)
+   - IMPLEMENTED_TASKS
+   - FILES_CHANGED
+   - TEST_RESULTS
+   - OPEN_ISSUES
+   - ASSUMPTIONS_MADE`;
 }
 export function ciFixPrompt(requirements, ciOutput) {
     return `The CI checks (ff-ci.sh) failed after your implementation. Fix the issues identified below.
@@ -183,16 +264,75 @@ ${ciOutput}
 Requirements:
 1. Fix all failing checks (lint, typecheck, build, tests).
 2. Do not remove or skip tests — fix the underlying issues.
-3. Return a concise implementation report with changed files and what was fixed.`;
+3. Return a structured implementation handoff using this exact section schema:
+   - STATUS
+   - SUMMARY
+   - CHECKLIST
+   - ISSUES
+   - ACTION_ITEMS (required if unresolved issues remain)
+   - IMPLEMENTED_TASKS
+   - FILES_CHANGED
+   - TEST_RESULTS
+   - OPEN_ISSUES
+   - ASSUMPTIONS_MADE`;
 }
 export function miniReviewPrompt(implementationReport) {
     return `Review the latest mini-loop implementation output below.
 
 ${implementationReport}
 
-Required output fields:
-1. CHANGE_REQUESTED=YES|NO
-2. UNRESOLVED_BLOCKING_ISSUES=<integer>
-3. CONFIDENCE=<0-100>
-4. concise rework instructions when change is requested`;
+Required output fields (strict):
+1. STATUS
+2. SUMMARY
+3. CHECKLIST
+4. ISSUES
+5. ACTION_ITEMS (required when CHANGE_REQUESTED=YES)
+6. CHANGE_REQUESTED=YES|NO
+7. UNRESOLVED_BLOCKING_ISSUES=<integer>
+8. CONFIDENCE=<0-100>`;
+}
+export function runNamePrompt(workflowLabel, requirements) {
+    return `Generate a concise descriptive run name for this ${workflowLabel} orchestration run.
+
+Requirements context:
+${requirements}
+
+Constraints:
+1. 3-7 words.
+2. Imperative or outcome-focused.
+3. No punctuation other than spaces and hyphens.
+4. Return only the run name text with no labels.`;
+}
+export function actionFirstReworkPrompt(stage, secondaryContext, gateFeedback) {
+    const fallbackActionItems = gateFeedback ? extractActionItemsFromFeedback(gateFeedback) : [];
+    const actionItems = stage.actionItems.length > 0
+        ? stage.actionItems
+        : fallbackActionItems.length > 0
+            ? fallbackActionItems
+            : stage.issues.map((issue) => `Resolve: ${issue}`);
+    const checklist = stage.checklist.length > 0
+        ? stage.checklist
+        : ['No explicit checklist was provided; verify acceptance criteria and impacted tests.'];
+    const issues = stage.issues.length > 0
+        ? stage.issues
+        : ['No explicit issues listed; confirm no regressions remain.'];
+    const additionalFeedback = gateFeedback ? `\n\nADDITIONAL_GATE_FEEDBACK:\n${gateFeedback}` : '';
+    return `ACTION-FIRST REWORK DIRECTIVE (primary):
+STATUS:
+${stage.status}
+
+SUMMARY:
+${stage.summary}
+
+CHECKLIST:
+${asNumberedList(checklist, 'No checklist provided.')}
+
+ISSUES:
+${asNumberedList(issues, 'No issues reported.')}
+
+ACTION_ITEMS:
+${asNumberedList(actionItems, 'No explicit action items were provided; resolve the listed issues and verify acceptance criteria.')}${additionalFeedback}
+
+SECONDARY CONTEXT (history/spec):
+${secondaryContext}`;
 }

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

@@ -5,7 +5,7 @@
  * threshold logic directly. The LLM still produces the synthesis; the
  * gate decision is computed here.
  */
-import type { GateResult, ConsensusPlan, ReviewSynthesis, DocReview } from './types.js';
+import type { GateResult, ConsensusPlan, ReviewSynthesis, DocReview, MiniLoopReview } from './types.js';
 /**
  * Evaluate the planning consensus gate.
  *
@@ -37,12 +37,7 @@ export declare function evaluateDocGate(review: DocReview, iteration: number, ma
  * - iteration >= maxIterations → ESCALATE
  * - otherwise → REWORK
  */
-export declare function evaluateMiniLoopImplGate(review: {
-    confidence: number;
-    changeRequested: boolean;
-    unresolvedIssues: number;
-    reworkInstructions?: string;
-}, iteration: number, maxIterations?: number): GateResult;
+export declare function evaluateMiniLoopImplGate(review: MiniLoopReview, iteration: number, maxIterations?: number): GateResult;
 /**
  * Evaluate the mini-loop documentation gate.
  * Same thresholds as the pipeline doc gate.