@syntesseraai/opencode-feature-factory 0.10.0 → 0.10.1

package/README.md

@@ -119,35 +119,36 @@ Both `ff_pipeline` and `ff_mini_loop` tools run asynchronously with real-time pr
 - **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.
+- **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

@@ -79,6 +79,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}`;
@@ -165,10 +167,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 +182,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`);
                         return;
                     }
                     // REWORK continues the loop
@@ -187,6 +191,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 +203,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`);
                     return;
                 }
                 // ===================================================================
@@ -208,6 +214,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 +303,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 +314,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 +330,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`);
             }; // 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`);
             });
             // Return immediately with acknowledgment
             const summary = requirements.length > 120 ? requirements.slice(0, 120) + '...' : requirements;

package/dist/tools/pipeline.js

@@ -108,6 +108,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 +199,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 +215,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`);
                         return;
                     }
                     // REWORK continues the loop
@@ -219,8 +224,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 +236,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`);
                     return;
                 }
                 // ===================================================================
@@ -239,6 +244,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: {
@@ -296,8 +303,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 +313,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 +444,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 +459,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`);
                         return;
                     }
                 }
@@ -456,6 +467,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 +479,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`);
                     return;
                 }
                 // ===================================================================
@@ -477,6 +490,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 +582,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 +594,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 +613,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`);
             }; // 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`);
             });
             // Return immediately with acknowledgment
             const summary = requirements.length > 120 ? requirements.slice(0, 120) + '...' : requirements;

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.1",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",