@syntesseraai/opencode-feature-factory 0.10.0 → 0.10.2

package/README.md

@@ -61,11 +61,11 @@ These colors are intentionally unique to avoid collisions in OpenCode agent UIs
 
 The plugin exposes three MCP tools via the `feature-factory` agent:
 
-| Tool             | Description                                                                                                                                       |
-| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ff_pipeline`    | Full multi-model pipeline: planning → build → review → documentation. Uses hardcoded per-role model defaults (see Model Routing below).           |
-| `ff_mini_loop`   | Lightweight build → review → documentation loop. **Does not hardcode model defaults** — all roles inherit the current session model when omitted. |
-| `ff_list_models` | Read-only discovery tool. Queries the OpenCode SDK to list all available providers, models, capability badges, connected status, and defaults.    |
+| Tool             | Description                                                                                                                                                                                                                       |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ff_pipeline`    | Full multi-model pipeline: planning → build → CI → review → documentation. Uses hardcoded per-role model defaults (see Model Routing below).                                                                                      |
+| `ff_mini_loop`   | Lightweight build → CI → review → documentation loop. **Does not hardcode model defaults** — all roles inherit the current session model when omitted. CI validation runs `ff-ci.sh` if present (up to 3 attempts with auto-fix). |
+| `ff_list_models` | Read-only discovery tool. Queries the OpenCode SDK to list all available providers, models, capability badges, connected status, and defaults.                                                                                    |
 
 ### Mini-Loop Model Inheritance
 
@@ -118,36 +118,37 @@ Both `ff_pipeline` and `ff_mini_loop` tools run asynchronously with real-time pr
 - **Immediate return**: Tools return instantly with a brief acknowledgment (e.g. `Pipeline started for: <summary>`), so the LLM can continue the conversation.
 - **Background orchestration**: The full pipeline or mini-loop runs in a detached `Promise`. All child session orchestration (fan-out, gates, loops) remains identical — it just executes after the tool returns.
 - **Progress updates via `promptAsync(noReply: true)`**: After each major phase completes, a structured notification is injected into the parent session as a visible chat message. These appear in the OpenCode TUI without triggering an LLM turn.
-- **Phase-by-phase visibility**: Users see updates for planning, building, each review iteration gate decision, each documentation iteration, and the final completion report.
-- **Error notifications**: If the background orchestration throws, a `<ff_pipeline_error>` or `<ff_mini_loop_error>` notification is sent with the last phase and error message.
+- **Phase-by-phase visibility**: Users see updates for planning, building, CI validation (when `ff-ci.sh` present), each review iteration gate decision, each documentation iteration, and the final completion report.
+- **Error notifications**: If the background orchestration throws, a `# Pipeline: Error` or `# Mini-Loop: Error` notification is sent with the last phase and error message.
 - **`context.metadata()` retained**: All existing metadata calls remain in place for future-proofing (when OpenCode's TUI renders tool metadata natively).
 
 ### Notification Format
 
-Pipeline updates use XML-style tags for structured parsing:
+Pipeline notifications use plain-text markdown headers with phase START/END bracketing and per-iteration gate details:
 
 ```
-<ff_pipeline_update>
-Phase: Planning
+# Pipeline: Reviewing — Iteration 2/10
+
 Status: APPROVED
-Duration: 45.2s
-Next Phase: Building
-</ff_pipeline_update>
+Confidence: 97%
+Unresolved Issues: 0
+Duration: 45.3s
+Feedback: N/A
 ```
 
-Mini-loop updates follow the same pattern:
+Mini-loop notifications follow the same pattern:
 
 ```
-<ff_mini_loop_update>
-Phase: Implementation
-Status: APPROVED
-Confidence: 97%
-Iteration: 2/10
-Duration: 32.1s
-</ff_mini_loop_update>
+# Mini-Loop: Building — Iteration 1/10
+
+Status: REWORK
+Confidence: 82%
+Unresolved Issues: 2
+Duration: 23.1s
+Feedback: Fix type errors in handler.ts
 ```
 
-Final reports are wrapped in `<ff_pipeline_complete>` or `<ff_mini_loop_complete>` tags containing the full markdown report.
+Final reports use `# Pipeline: Complete` or `# Mini-Loop: Complete` headers containing the full markdown report. Errors use `# Pipeline: Error` or `# Mini-Loop: Error`.
 
 ## Related Docs
 

package/agents/building.md

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

package/agents/documenting.md

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

package/agents/planning.md

@@ -1,6 +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
+mode: primary
 color: '#3b82f6'
 tools:
   read: true

package/agents/reviewing.md

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

package/dist/tools/mini-loop.js

@@ -10,8 +10,9 @@
  */
 import { tool } from '@opencode-ai/plugin/tool';
 import { promptSession, notifyParent, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, parseModelString, } from '../workflow/orchestrator.js';
-import { miniBuildPrompt, miniReviewPrompt, documentPrompt, docReviewPrompt } from './prompts.js';
+import { miniBuildPrompt, miniReviewPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, } from './prompts.js';
 import { parseMiniReview, parseDocReview } from './parsers.js';
+import { ciScriptExists, runCI } from '../workflow/ci-runner.js';
 // ---------------------------------------------------------------------------
 // Tool factory
 // ---------------------------------------------------------------------------
@@ -70,7 +71,7 @@ export function createMiniLoopTool(client) {
                     report.push(`## ${phase}\n${msg}`);
                 };
                 // Notify helper bound to this session
-                const notify = (message) => notifyParent(client, sessionId, agent, message);
+                const notify = (message, options) => notifyParent(client, sessionId, agent, message, options);
                 // ===================================================================
                 // PHASE 1: IMPLEMENTATION LOOP (build → review → gate, up to 10)
                 // ===================================================================
@@ -79,6 +80,8 @@ export function createMiniLoopTool(client) {
                 const implementationIterationDetails = [];
                 let implGate = { decision: 'REWORK', feedback: requirements };
                 let lastImplRaw = '';
+                // Phase start notification
+                await notify(`# Mini-Loop: Building started\n\nStarting implementation phase...\n`);
                 for (let implIter = 0; implIter < 10 && implGate.decision === 'REWORK'; implIter++) {
                     const iteration = implIter + 1;
                     const buildTitle = `ff-mini-build-${iteration}`;
@@ -99,6 +102,73 @@ export function createMiniLoopTool(client) {
                     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();
+                    // ---------------------------------------------------------------
+                    // CI validation (deterministic subprocess — not an LLM prompt)
+                    // ---------------------------------------------------------------
+                    const ciDir = process.cwd();
+                    const hasCiScript = await ciScriptExists(ciDir);
+                    if (!hasCiScript) {
+                        await notify(`# Mini-Loop: CI script (ff-ci.sh) not found, skipping CI validation\n`);
+                    }
+                    else {
+                        const maxCiAttempts = 3;
+                        for (let ciAttempt = 1; ciAttempt <= maxCiAttempts; ciAttempt++) {
+                            context.metadata({
+                                title: `⏳ Running CI (attempt ${ciAttempt}/${maxCiAttempts})...`,
+                                metadata: {
+                                    phase: 'implementation',
+                                    step: 'ci',
+                                    iteration,
+                                    ciAttempt,
+                                    maxCiAttempts,
+                                },
+                            });
+                            await notify(`# Mini-Loop: CI validation — attempt ${ciAttempt}/${maxCiAttempts}\n`);
+                            const ciResult = await runCI(ciDir);
+                            if (ciResult.passed) {
+                                await notify(`# Mini-Loop: CI passed (attempt ${ciAttempt}/${maxCiAttempts})\n`);
+                                break;
+                            }
+                            // CI failed
+                            await notify(`# Mini-Loop: CI failed (attempt ${ciAttempt}/${maxCiAttempts})\n\n\`\`\`\n${ciResult.output}\n\`\`\`\n`);
+                            if (ciAttempt < maxCiAttempts) {
+                                // Ask build model to fix the CI failures
+                                context.metadata({
+                                    title: `⏳ CI rework (attempt ${ciAttempt}/${maxCiAttempts})...`,
+                                    metadata: {
+                                        phase: 'implementation',
+                                        step: 'ci',
+                                        iteration,
+                                        ciAttempt,
+                                        maxCiAttempts,
+                                        action: 'rework',
+                                    },
+                                });
+                                lastImplRaw = await promptSession(client, sessionId, ciFixPrompt(requirements, ciResult.output), {
+                                    model: buildModel,
+                                    agent: 'building',
+                                    title: `ff-mini-ci-fix-${iteration}-${ciAttempt}`,
+                                });
+                            }
+                            else {
+                                // Terminal CI failure — exhausted all attempts
+                                addReport('CI Validation', `CI failed after ${maxCiAttempts} attempts.\n\n**Last output**:\n\`\`\`\n${ciResult.output}\n\`\`\`\n`);
+                                context.metadata({
+                                    title: '❌ CI validation failed (attempts exhausted)',
+                                    metadata: {
+                                        phase: 'implementation',
+                                        step: 'ci',
+                                        iteration,
+                                        ciAttempt,
+                                        maxCiAttempts,
+                                        outcome: 'failed',
+                                    },
+                                });
+                                await notify(`# Mini-Loop: CI validation failed\n\nCI checks failed after ${maxCiAttempts} attempts. Aborting.\n`, { noReply: false });
+                                return;
+                            }
+                        }
+                    }
                     context.metadata({
                         title: `⏳ Reviewing (iteration ${iteration}/10)...`,
                         metadata: {
@@ -165,10 +235,12 @@ export function createMiniLoopTool(client) {
                         `- **Gate**: ${implGate.decision} (confidence: ${review.confidence}, change requested: ${review.changeRequested ? 'yes' : 'no'}, unresolved: ${review.unresolvedIssues})\n` +
                         `- **Feedback**: ${feedback}`);
                     // Notify each implementation iteration gate decision
-                    await notify(`<ff_mini_loop_update>\nPhase: Implementation\nStatus: ${implGate.decision}\nConfidence: ${review.confidence}%\nIteration: ${iteration}/10\nDuration: ${formatElapsed(implementationStartMs, Date.now())}\n</ff_mini_loop_update>`);
+                    await notify(`# Mini-Loop: Building — Iteration ${iteration}/10\n\nStatus: ${implGate.decision}\nConfidence: ${review.confidence}%\nUnresolved Issues: ${review.unresolvedIssues}\nDuration: ${formatElapsed(implementationStartMs, Date.now())}\nFeedback: ${feedback}\n`);
                     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)}`);
+                        // Phase end notification
+                        await notify(`# Mini-Loop: Building ended\n\nOutcome: ESCALATE\nReason: ${implGate.reason}\nIterations: ${iteration}\nPhase time: ${formatElapsed(implementationStartMs, implementationEndMs)}\n`);
                         context.metadata({
                             title: '⚠️ Mini-loop finished with issues',
                             metadata: {
@@ -178,7 +250,7 @@ export function createMiniLoopTool(client) {
                             },
                         });
                         addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                        await notify(`<ff_mini_loop_complete>\n${report.join('\n\n')}\n</ff_mini_loop_complete>`);
+                        await notify(`# Mini-Loop: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                         return;
                     }
                     // REWORK continues the loop
@@ -187,6 +259,8 @@ export function createMiniLoopTool(client) {
                 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)}`);
+                // Phase end notification
+                await notify(`# Mini-Loop: Building ended\n\nOutcome: ${implGate.decision}\nIterations: ${implGate.decision === 'APPROVED' ? 'converged' : '10 (exhausted)'}\nPhase time: ${formatElapsed(implementationStartMs, implementationEndMs)}\n`);
                 if (implGate.decision !== 'APPROVED') {
                     context.metadata({
                         title: '⚠️ Mini-loop finished with issues',
@@ -197,7 +271,7 @@ export function createMiniLoopTool(client) {
                         },
                     });
                     addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                    await notify(`<ff_mini_loop_complete>\n${report.join('\n\n')}\n</ff_mini_loop_complete>`);
+                    await notify(`# Mini-Loop: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                     return;
                 }
                 // ===================================================================
@@ -208,6 +282,8 @@ export function createMiniLoopTool(client) {
                 const documentationIterationDetails = [];
                 let docInput = lastImplRaw;
                 let docGate = { decision: 'REWORK' };
+                // Phase start notification
+                await notify(`# Mini-Loop: Documentation started\n\nStarting documentation phase...\n`);
                 for (let docIter = 0; docIter < 5 && docGate.decision === 'REWORK'; docIter++) {
                     const iteration = docIter + 1;
                     const writeTitle = `ff-mini-doc-write-${iteration}`;
@@ -295,7 +371,7 @@ export function createMiniLoopTool(client) {
                         `- **Gate**: ${docGate.decision} (confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
                         `- **Feedback**: ${feedback}`);
                     // Notify each documentation iteration gate decision
-                    await notify(`<ff_mini_loop_update>\nPhase: Documentation\nStatus: ${docGate.decision}\nConfidence: ${docReview.confidence}%\nIteration: ${iteration}/5\nDuration: ${formatElapsed(documentationStartMs, Date.now())}\n</ff_mini_loop_update>`);
+                    await notify(`# Mini-Loop: Documentation — Iteration ${iteration}/5\n\nStatus: ${docGate.decision}\nConfidence: ${docReview.confidence}%\nUnresolved Issues: ${docReview.unresolvedIssues}\nDuration: ${formatElapsed(documentationStartMs, Date.now())}\nFeedback: ${feedback}\n`);
                     if (docGate.decision === 'REWORK') {
                         docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
                     }
@@ -306,6 +382,8 @@ export function createMiniLoopTool(client) {
                     : docGate.decision === 'ESCALATE'
                         ? `ESCALATE: ${docGate.reason}`
                         : `REWORK exhausted (5 iterations). Last feedback: ${docGate.feedback}`}\n**Phase time**: ${formatElapsed(documentationStartMs, documentationEndMs)}`);
+                // Phase end notification
+                await notify(`# Mini-Loop: Documentation ended\n\nOutcome: ${docGate.decision}\nConfidence: ${docGate.decision === 'APPROVED' ? 'converged' : 'N/A'}\nPhase time: ${formatElapsed(documentationStartMs, documentationEndMs)}\n`);
                 const totalEndMs = Date.now();
                 const completedWithoutIssues = docGate.decision === 'APPROVED';
                 context.metadata({
@@ -320,12 +398,12 @@ export function createMiniLoopTool(client) {
                 });
                 addReport('Complete', `${completedWithoutIssues ? 'Mini-loop finished successfully.' : 'Mini-loop finished with issues.'}\n**Total time**: ${formatElapsed(totalStartMs, totalEndMs)}`);
                 // Send final completion report as notification
-                await notify(`<ff_mini_loop_complete>\n${report.join('\n\n')}\n</ff_mini_loop_complete>`);
+                await notify(`# Mini-Loop: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
             }; // end asyncOrchestration
             // Launch orchestration in background — fire-and-forget
             void asyncOrchestration().catch(async (err) => {
                 const message = err instanceof Error ? err.message : String(err);
-                await notifyParent(client, sessionId, agent, `<ff_mini_loop_error>\nPhase: ${lastPhase}\nError: ${message}\nDuration: N/A\n</ff_mini_loop_error>`);
+                await notifyParent(client, sessionId, agent, `# Mini-Loop: Error\n\nPhase: ${lastPhase}\nError: ${message}\n`, { noReply: false });
             });
             // Return immediately with acknowledgment
             const summary = requirements.length > 120 ? requirements.slice(0, 120) + '...' : requirements;

package/dist/tools/pipeline.js

@@ -12,7 +12,8 @@
  */
 import { tool } from '@opencode-ai/plugin/tool';
 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, } from './prompts.js';
+import { planningPrompt, synthesisPrompt, breakdownPrompt, validateBatchPrompt, implementBatchPrompt, triagePrompt, reviewPrompt, reviewSynthesisPrompt, documentPrompt, docReviewPrompt, ciFixPrompt, } from './prompts.js';
+import { ciScriptExists, runCI } from '../workflow/ci-runner.js';
 import { parseConsensusPlan, parseReviewSynthesis, parseImplementationReport, parseDocReview, } from './parsers.js';
 // ---------------------------------------------------------------------------
 // Tool factory — needs the SDK client from plugin init
@@ -99,7 +100,7 @@ export function createPipelineTool(client) {
                     report.push(`## ${phase}\n${msg}`);
                 };
                 // Notify helper bound to this session
-                const notify = (message) => notifyParent(client, sessionId, agent, message);
+                const notify = (message, options) => notifyParent(client, sessionId, agent, message, options);
                 // ===================================================================
                 // PHASE 1: PLANNING (fan-out → synthesize → gate, loop up to 5)
                 // ===================================================================
@@ -108,6 +109,8 @@ export function createPipelineTool(client) {
                 const planningIterationDetails = [];
                 let planningGate = { decision: 'REWORK', feedback: requirements };
                 let finalPlan = '';
+                // Phase start notification
+                await notify(`# Pipeline: Planning started\n\nStarting planning phase with ${planModels.length} models...\n`);
                 for (let planIter = 0; planIter < 5 && planningGate.decision === 'REWORK'; planIter++) {
                     const iteration = planIter + 1;
                     const synthesisTitle = `ff-plan-synthesis-${iteration}`;
@@ -197,9 +200,13 @@ export function createPipelineTool(client) {
                         `- **Synthesis**: ${synthesisTitle} (${formatElapsed(synthesisStartMs, synthesisEndMs)})\n` +
                         `- **Gate**: ${planningGate.decision} (score: ${consensus.consensusScore})\n` +
                         `- **Feedback**: ${feedback}`);
+                    // 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`);
                     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)}`);
+                        // Phase end notification
+                        await notify(`# Pipeline: Planning ended\n\nOutcome: BLOCKED\nReason: ${planningGate.reason}\nConsensus Score: ${consensus.consensusScore}%\nIterations: ${iteration}/5\nPhase time: ${formatElapsed(planningStartMs, planningEndMs)}\n`);
                         context.metadata({
                             title: '⚠️ Pipeline finished with issues',
                             metadata: {
@@ -209,8 +216,7 @@ export function createPipelineTool(client) {
                             },
                         });
                         addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                        await notify(`<ff_pipeline_update>\nPhase: Planning\nStatus: BLOCKED\nConsensus Score: ${consensus.consensusScore}%\nIterations: ${iteration}/5\nDuration: ${formatElapsed(planningStartMs, planningEndMs)}\n</ff_pipeline_update>`);
-                        await notify(`<ff_pipeline_complete>\n${report.join('\n\n')}\n</ff_pipeline_complete>`);
+                        await notify(`# Pipeline: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                         return;
                     }
                     // REWORK continues the loop
@@ -219,8 +225,8 @@ export function createPipelineTool(client) {
                 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)}`);
-                // Notify planning phase complete
-                await notify(`<ff_pipeline_update>\nPhase: Planning\nStatus: ${planningGate.decision}\nDuration: ${formatElapsed(planningStartMs, planningEndMs)}\nNext Phase: ${planningGate.decision === 'APPROVED' ? 'Building' : 'Finished'}\n</ff_pipeline_update>`);
+                // Phase end notification
+                await notify(`# Pipeline: Planning ended\n\nOutcome: ${planningGate.decision}\nDuration: ${formatElapsed(planningStartMs, planningEndMs)}\nNext Phase: ${planningGate.decision === 'APPROVED' ? 'Building' : 'Finished'}\n`);
                 if (planningGate.decision !== 'APPROVED') {
                     context.metadata({
                         title: '⚠️ Pipeline finished with issues',
@@ -231,7 +237,7 @@ export function createPipelineTool(client) {
                         },
                     });
                     addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                    await notify(`<ff_pipeline_complete>\n${report.join('\n\n')}\n</ff_pipeline_complete>`);
+                    await notify(`# Pipeline: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                     return;
                 }
                 // ===================================================================
@@ -239,6 +245,8 @@ export function createPipelineTool(client) {
                 // ===================================================================
                 lastPhase = 'Building';
                 const buildingStartMs = Date.now();
+                // Phase start notification
+                await notify(`# Pipeline: Building started\n\nStarting build phase (breakdown → validate → implement)...\n`);
                 context.metadata({
                     title: '⏳ Breaking down tasks...',
                     metadata: {
@@ -288,6 +296,71 @@ export function createPipelineTool(client) {
                 });
                 const implementEndMs = Date.now();
                 const implementation = parseImplementationReport(implRaw);
+                // ---------------------------------------------------------------
+                // CI validation (deterministic subprocess — not an LLM prompt)
+                // ---------------------------------------------------------------
+                const ciDir = process.cwd();
+                const hasCiScript = await ciScriptExists(ciDir);
+                if (!hasCiScript) {
+                    await notify(`# Pipeline: CI script (ff-ci.sh) not found, skipping CI validation\n`);
+                }
+                else {
+                    const maxCiAttempts = 3;
+                    for (let ciAttempt = 1; ciAttempt <= maxCiAttempts; ciAttempt++) {
+                        context.metadata({
+                            title: `⏳ Running CI (attempt ${ciAttempt}/${maxCiAttempts})...`,
+                            metadata: {
+                                phase: 'building',
+                                step: 'ci',
+                                ciAttempt,
+                                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`);
+                            break;
+                        }
+                        // CI failed
+                        await notify(`# Pipeline: CI failed (attempt ${ciAttempt}/${maxCiAttempts})\n\n\`\`\`\n${ciResult.output}\n\`\`\`\n`);
+                        if (ciAttempt < maxCiAttempts) {
+                            // Ask build model to fix the CI failures
+                            context.metadata({
+                                title: `⏳ CI rework (attempt ${ciAttempt}/${maxCiAttempts})...`,
+                                metadata: {
+                                    phase: 'building',
+                                    step: 'ci',
+                                    ciAttempt,
+                                    maxCiAttempts,
+                                    action: 'rework',
+                                },
+                            });
+                            await promptSession(client, sessionId, ciFixPrompt(requirements, ciResult.output), {
+                                model: buildModel,
+                                agent: 'building',
+                                title: `ff-pipeline-ci-fix-${ciAttempt}`,
+                            });
+                        }
+                        else {
+                            // Terminal CI failure — exhausted all attempts
+                            addReport('CI Validation', `CI failed after ${maxCiAttempts} attempts.\n\n**Last output**:\n\`\`\`\n${ciResult.output}\n\`\`\`\n`);
+                            context.metadata({
+                                title: '❌ CI validation failed (attempts exhausted)',
+                                metadata: {
+                                    phase: 'building',
+                                    step: 'ci',
+                                    ciAttempt,
+                                    maxCiAttempts,
+                                    outcome: 'failed',
+                                },
+                            });
+                            addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
+                            await notify(`# Pipeline: CI validation failed\n\nCI checks failed after ${maxCiAttempts} attempts. Aborting.\n`, { noReply: false });
+                            return;
+                        }
+                    }
+                }
                 const buildingEndMs = Date.now();
                 addReport('Building', `### Execution\n` +
                     `- **Breakdown**: ${breakdownTitle} (${formatElapsed(breakdownStartMs, breakdownEndMs)})\n` +
@@ -296,8 +369,8 @@ export function createPipelineTool(client) {
                     `- **Tests passed**: ${implementation.testsPassed}\n` +
                     `- **Open issues**: ${implementation.openIssues.length > 0 ? implementation.openIssues.join('; ') : 'none'}\n\n` +
                     `**Phase time**: ${formatElapsed(buildingStartMs, buildingEndMs)}`);
-                // Notify building phase complete
-                await notify(`<ff_pipeline_update>\nPhase: Building\nStatus: COMPLETE\nFiles Changed: ${implementation.filesChanged.length}\nTests Passed: ${implementation.testsPassed}\nDuration: ${formatElapsed(buildingStartMs, buildingEndMs)}\nNext Phase: Reviewing\n</ff_pipeline_update>`);
+                // 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`);
                 // ===================================================================
                 // PHASE 3: REVIEWING (triage → fan-out review → synthesize → gate, loop up to 10)
                 // ===================================================================
@@ -306,6 +379,8 @@ export function createPipelineTool(client) {
                 const reviewIterationDetails = [];
                 let reviewInput = implRaw;
                 let reviewGate = { decision: 'REWORK' };
+                // Phase start notification
+                await notify(`# Pipeline: Reviewing started\n\nStarting review phase with ${revModels.length} models...\n`);
                 for (let revIter = 0; revIter < 10 && reviewGate.decision === 'REWORK'; revIter++) {
                     const iteration = revIter + 1;
                     const triageTitle = `ff-review-triage-${iteration}`;
@@ -435,10 +510,12 @@ export function createPipelineTool(client) {
                         `${reworkLine}\n` +
                         `- **Feedback**: ${feedback}`);
                     // Notify each review iteration gate decision
-                    await notify(`<ff_pipeline_update>\nPhase: Reviewing\nStatus: ${reviewGate.decision}\nConfidence: ${synthesis.overallConfidence}%\nUnresolved Issues: ${synthesis.unresolvedIssues}\nIteration: ${iteration}/10\nDuration: ${formatElapsed(reviewStartMs, Date.now())}\n</ff_pipeline_update>`);
+                    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`);
                     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)}`);
+                        // Phase end notification
+                        await notify(`# Pipeline: Reviewing ended\n\nOutcome: ESCALATE\nReason: ${reviewGate.reason}\nIterations: ${iteration}\nPhase time: ${formatElapsed(reviewStartMs, reviewEndMs)}\n`);
                         context.metadata({
                             title: '⚠️ Pipeline finished with issues',
                             metadata: {
@@ -448,7 +525,7 @@ export function createPipelineTool(client) {
                             },
                         });
                         addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                        await notify(`<ff_pipeline_complete>\n${report.join('\n\n')}\n</ff_pipeline_complete>`);
+                        await notify(`# Pipeline: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                         return;
                     }
                 }
@@ -456,6 +533,8 @@ export function createPipelineTool(client) {
                 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)}`);
+                // Phase end notification
+                await notify(`# Pipeline: Reviewing ended\n\nOutcome: ${reviewGate.decision}\nDuration: ${formatElapsed(reviewStartMs, reviewEndMs)}\n`);
                 if (reviewGate.decision !== 'APPROVED') {
                     context.metadata({
                         title: '⚠️ Pipeline finished with issues',
@@ -466,7 +545,7 @@ export function createPipelineTool(client) {
                         },
                     });
                     addReport('Complete', `Pipeline finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
-                    await notify(`<ff_pipeline_complete>\n${report.join('\n\n')}\n</ff_pipeline_complete>`);
+                    await notify(`# Pipeline: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
                     return;
                 }
                 // ===================================================================
@@ -477,6 +556,8 @@ export function createPipelineTool(client) {
                 const documentationIterationDetails = [];
                 let docInput = `Implementation report:\n${implRaw}\n\nReview synthesis:\n${reviewInput}`;
                 let docGate = { decision: 'REWORK' };
+                // Phase start notification
+                await notify(`# Pipeline: Documentation started\n\nStarting documentation phase...\n`);
                 for (let docIter = 0; docIter < 5 && docGate.decision === 'REWORK'; docIter++) {
                     const iteration = docIter + 1;
                     const writeTitle = `ff-doc-write-${iteration}`;
@@ -567,7 +648,7 @@ export function createPipelineTool(client) {
                         `- **Gate**: ${docGate.decision} (confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
                         `- **Feedback**: ${feedback}`);
                     // Notify each documentation iteration gate decision
-                    await notify(`<ff_pipeline_update>\nPhase: Documentation\nStatus: ${docGate.decision}\nConfidence: ${docReview.confidence}%\nIteration: ${iteration}/5\nDuration: ${formatElapsed(documentationStartMs, Date.now())}\n</ff_pipeline_update>`);
+                    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`);
                     if (docGate.decision === 'REWORK') {
                         // Feed feedback into the next iteration
                         docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
@@ -579,6 +660,8 @@ export function createPipelineTool(client) {
                     : docGate.decision === 'ESCALATE'
                         ? `ESCALATE: ${docGate.reason}`
                         : `REWORK exhausted (5 iterations). Last feedback: ${docGate.feedback}`}\n**Phase time**: ${formatElapsed(documentationStartMs, documentationEndMs)}`);
+                // Phase end notification
+                await notify(`# Pipeline: Documentation ended\n\nOutcome: ${docGate.decision}\nPhase time: ${formatElapsed(documentationStartMs, documentationEndMs)}\n`);
                 // ===================================================================
                 // FINAL REPORT
                 // ===================================================================
@@ -596,12 +679,12 @@ export function createPipelineTool(client) {
                 });
                 addReport('Complete', `${completedWithoutIssues ? 'Pipeline finished successfully.' : 'Pipeline finished with issues.'}\n**Total time**: ${formatElapsed(totalStartMs, totalEndMs)}`);
                 // Send final completion report as notification
-                await notify(`<ff_pipeline_complete>\n${report.join('\n\n')}\n</ff_pipeline_complete>`);
+                await notify(`# Pipeline: Complete\n\n${report.join('\n\n')}\n`, { noReply: false });
             }; // end asyncOrchestration
             // Launch orchestration in background — fire-and-forget
             void asyncOrchestration().catch(async (err) => {
                 const message = err instanceof Error ? err.message : String(err);
-                await notifyParent(client, sessionId, agent, `<ff_pipeline_error>\nPhase: ${lastPhase}\nError: ${message}\nDuration: N/A\n</ff_pipeline_error>`);
+                await notifyParent(client, sessionId, agent, `# Pipeline: Error\n\nPhase: ${lastPhase}\nError: ${message}\n`, { noReply: false });
             });
             // Return immediately with acknowledgment
             const summary = requirements.length > 120 ? requirements.slice(0, 120) + '...' : requirements;

package/dist/tools/prompts.d.ts

@@ -21,4 +21,5 @@ export declare function reviewSynthesisPrompt(reviews: Array<{
 export declare function documentPrompt(input: string): string;
 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;

package/dist/tools/prompts.js

@@ -169,6 +169,22 @@ Requirements:
 3. Run lint/typecheck/tests only for impacted scope.
 4. Return a concise implementation report with changed files, tests run, and known open issues.`;
 }
+export function ciFixPrompt(requirements, ciOutput) {
+    return `The CI checks (ff-ci.sh) failed after your implementation. Fix the issues identified below.
+
+Original requirements:
+${requirements}
+
+CI failure output:
+\`\`\`
+${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.`;
+}
 export function miniReviewPrompt(implementationReport) {
     return `Review the latest mini-loop implementation output below.
 

package/dist/workflow/ci-runner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CI runner utility for workflow tools.
+ *
+ * Executes `ff-ci.sh` in a subprocess and returns a structured result.
+ * Reuses sanitizeOutput / truncateOutput from stop-quality-gate.ts for
+ * consistent secret redaction and output trimming.
+ */
+export interface CIResult {
+    passed: boolean;
+    output: string;
+    timedOut: boolean;
+}
+/**
+ * Check whether `ff-ci.sh` exists at the given directory root.
+ * Never throws — returns `false` on any error.
+ */
+export declare function ciScriptExists(directory: string): Promise<boolean>;
+/**
+ * Execute `ff-ci.sh` from the given directory and return a structured result.
+ * Never throws — returns a failure result on any error.
+ */
+export declare function runCI(directory: string): Promise<CIResult>;

package/dist/workflow/ci-runner.js

@@ -0,0 +1,91 @@
+/**
+ * CI runner utility for workflow tools.
+ *
+ * Executes `ff-ci.sh` in a subprocess and returns a structured result.
+ * Reuses sanitizeOutput / truncateOutput from stop-quality-gate.ts for
+ * consistent secret redaction and output trimming.
+ */
+import { sanitizeOutput, truncateOutput } from '../stop-quality-gate.js';
+const CI_TIMEOUT_MS = 300_000; // 5 minutes
+/**
+ * Check whether `ff-ci.sh` exists at the given directory root.
+ * Never throws — returns `false` on any error.
+ */
+export async function ciScriptExists(directory) {
+    try {
+        const ciPath = `${directory}/ff-ci.sh`;
+        // eslint-disable-next-line no-undef
+        const proc = Bun.spawn(['test', '-f', ciPath], {
+            cwd: directory,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        await proc.exited;
+        return proc.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute `ff-ci.sh` from the given directory and return a structured result.
+ * Never throws — returns a failure result on any error.
+ */
+export async function runCI(directory) {
+    try {
+        const ciPath = `${directory}/ff-ci.sh`;
+        // eslint-disable-next-line no-undef
+        const proc = Bun.spawn(['bash', ciPath], {
+            cwd: directory,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        let timedOut = false;
+        let timeoutId = null;
+        let forceKillTimeoutId = null;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill('SIGTERM');
+                forceKillTimeoutId = setTimeout(() => {
+                    try {
+                        proc.kill('SIGKILL');
+                    }
+                    catch {
+                        // Process already terminated
+                    }
+                }, 5000);
+                resolve();
+            }, CI_TIMEOUT_MS);
+        });
+        await Promise.race([proc.exited, timeoutPromise]);
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        if (forceKillTimeoutId)
+            clearTimeout(forceKillTimeoutId);
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        let output;
+        let passed;
+        if (timedOut) {
+            output =
+                `CI execution timed out after ${CI_TIMEOUT_MS / 1000} seconds\n\n${stdout}\n${stderr}`.trim();
+            passed = false;
+        }
+        else {
+            output = stdout + (stderr ? `\n${stderr}` : '');
+            passed = proc.exitCode === 0;
+        }
+        // Sanitize secrets and truncate for prompt safety
+        output = truncateOutput(sanitizeOutput(output));
+        return { passed, output, timedOut };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            passed: false,
+            output: `CI runner error: ${message}`,
+            timedOut: false,
+        };
+    }
+}

package/dist/workflow/fan-out.d.ts

@@ -125,8 +125,12 @@ export declare function promptSession(client: Client, parentSessionId: string, p
 /**
  * Send a visible notification message to the parent session via `promptAsync`.
  *
- * Uses `noReply: true` so the message appears in the TUI as a chat message
- * without triggering an LLM turn. Errors are swallowed — notification
- * delivery must never break the pipeline.
+ * By default uses `noReply: true` so the message appears in the TUI as a chat
+ * message without triggering an LLM turn. Pass `noReply: false` for terminal
+ * messages (completion reports, errors) so the LLM can validate the outcome.
+ *
+ * Errors are swallowed — notification delivery must never break the pipeline.
  */
-export declare function notifyParent(client: Client, sessionId: string, agent: string | undefined, message: string): Promise<void>;
+export declare function notifyParent(client: Client, sessionId: string, agent: string | undefined, message: string, options?: {
+    noReply?: boolean;
+}): Promise<void>;

package/dist/workflow/fan-out.js

@@ -94,14 +94,16 @@ export async function promptSession(client, parentSessionId, prompt, options) {
 /**
  * Send a visible notification message to the parent session via `promptAsync`.
  *
- * Uses `noReply: true` so the message appears in the TUI as a chat message
- * without triggering an LLM turn. Errors are swallowed — notification
- * delivery must never break the pipeline.
+ * By default uses `noReply: true` so the message appears in the TUI as a chat
+ * message without triggering an LLM turn. Pass `noReply: false` for terminal
+ * messages (completion reports, errors) so the LLM can validate the outcome.
+ *
+ * Errors are swallowed — notification delivery must never break the pipeline.
  */
-export async function notifyParent(client, sessionId, agent, message) {
+export async function notifyParent(client, sessionId, agent, message, options) {
     try {
         const body = {
-            noReply: true,
+            noReply: options?.noReply ?? true,
             parts: [{ type: 'text', text: message }],
         };
         if (agent) {

package/dist/workflow/orchestrator.d.ts

@@ -6,4 +6,5 @@
  */
 export { fanOut, promptSession, extractText, notifyParent, type Client } from './fan-out.js';
 export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export { runCI, ciScriptExists } from './ci-runner.js';
 export * from './types.js';

package/dist/workflow/orchestrator.js

@@ -6,4 +6,5 @@
  */
 export { fanOut, promptSession, extractText, notifyParent } from './fan-out.js';
 export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export { runCI, ciScriptExists } from './ci-runner.js';
 export * from './types.js';

package/package.json

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