@syntesseraai/opencode-feature-factory 0.7.2 → 0.8.0

package/README.md

@@ -56,6 +56,20 @@ These colors are intentionally unique to avoid collisions in OpenCode agent UIs
 - Coordinator and synthesis model defaults to ChatGPT 5.4 via frontmatter `model:` declarations in orchestrator commands.
 - All orchestrator commands include an explicit **orchestrator constraint**: they must NOT directly read, edit, modify, write, or create any code/config/repository files — they only dispatch sub-commands, pass structured data via `{as:name}` / `$RESULT[name]`, and evaluate gate/loop conditions.
 
+## Tools
+
+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. |
+
+### Mini-Loop Model Inheritance
+
+When `ff_mini_loop` model parameters are omitted, child sessions inherit the parent session's model (the SDK `model` field is omitted entirely from the prompt body). The `doc_model` has a cascade: if `build_model` is explicitly set but `doc_model` is not, the documentation step uses the same model as build. Users can call `ff_list_models` to discover available `provider/model` strings before overriding.
+
 ## Command Tree
 
 - `/pipeline/start`

package/agents/building.md

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

package/agents/documenting.md

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

package/agents/feature-factory.md

@@ -11,6 +11,7 @@ tools:
   task: true
   ff_pipeline: true
   ff_mini_loop: true
+  ff_list_models: true
 permission:
   skill:
     '*': allow
@@ -64,7 +65,7 @@ Ask the user which workflow they prefer. If they are unsure, recommend one based
 
 Present the default models that will be used for the chosen workflow:
 
-**Pipeline defaults:**
+**Pipeline defaults:** (hardcoded per-role model assignments)
 - Planning fan-out: opus (anthropic/claude-opus-4-6), gemini (opencode/gemini-3.1-pro), codex (openai/gpt-5.3-codex)
 - Review fan-out: same as planning
 - Orchestrator (synthesis/triage): openai/gpt-5.4
@@ -73,13 +74,14 @@ Present the default models that will be used for the chosen workflow:
 - Documentation: openai/gpt-5.3-codex
 - Doc review: opencode/gemini-3.1-pro
 
-**Mini-loop defaults:**
-- Build: openai/gpt-5.3-codex
-- Review: openai/gpt-5.4
-- Documentation: openai/gpt-5.3-codex
-- Doc review: opencode/gemini-3.1-pro
+**Mini-loop defaults:** (inherits the current session model)
+- All roles (build, review, documentation, doc review) default to the **current session model** — no hardcoded model is forced.
+- This means the mini-loop automatically uses whatever model you're currently chatting with.
+- You can override any individual role if desired (e.g., use a different model for review).
+
+For the **Pipeline**, ask: "Would you like to use these default models, or would you like to override any of them?"
 
-Ask: "Would you like to use these default models, or would you like to override any of them?"
+For the **Mini-loop**, ask: "The mini-loop will use your current session model for all roles by default. Would you like to override any specific roles (build, review, doc, doc_review)? You can call `ff_list_models` to see available providers and models."
 
 If they want to override, collect the provider/model strings for each role they want to change.
 

package/agents/planning.md

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

package/agents/reviewing.md

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

package/dist/tools/index.d.ts

@@ -2,9 +2,9 @@
  * Tool registry for Feature Factory.
  *
  * Exports a function that creates all FF tools given the SDK client.
- * Only entrypoint tools (pipeline, mini-loop) are exposed to the LLM.
+ * Only entrypoint tools (pipeline, mini-loop) and discovery tools
  * Internal workflow steps are orchestrated programmatically, not as
- * individually callable tools.
+ * individually callable tools. The list-models tool is a read-only discovery helper.
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import type { Client } from '../workflow/fan-out.js';

package/dist/tools/index.js

@@ -2,12 +2,13 @@
  * Tool registry for Feature Factory.
  *
  * Exports a function that creates all FF tools given the SDK client.
- * Only entrypoint tools (pipeline, mini-loop) are exposed to the LLM.
+ * Only entrypoint tools (pipeline, mini-loop) and discovery tools
  * Internal workflow steps are orchestrated programmatically, not as
- * individually callable tools.
+ * individually callable tools. The list-models tool is a read-only discovery helper.
  */
 import { createPipelineTool } from './pipeline.js';
 import { createMiniLoopTool } from './mini-loop.js';
+import { createListModelsTool } from './list-models.js';
 /**
  * Build the tool map to be merged into the plugin's `Hooks.tool` output.
  *
@@ -17,5 +18,6 @@ export function createWorkflowTools(client) {
     return {
         ff_pipeline: createPipelineTool(client),
         ff_mini_loop: createMiniLoopTool(client),
+        ff_list_models: createListModelsTool(client),
     };
 }

package/dist/tools/list-models.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ff_list_models — Discovery tool for available providers and models.
+ *
+ * Read-only tool that queries the OpenCode SDK to list all available
+ * providers and their models, so users can see what's available before
+ * overriding mini-loop or pipeline model parameters.
+ */
+import type { Client } from '../workflow/fan-out.js';
+export declare function createListModelsTool(client: Client): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/list-models.js

@@ -0,0 +1,67 @@
+/**
+ * ff_list_models — Discovery tool for available providers and models.
+ *
+ * Read-only tool that queries the OpenCode SDK to list all available
+ * providers and their models, so users can see what's available before
+ * overriding mini-loop or pipeline model parameters.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+// ---------------------------------------------------------------------------
+// Tool factory
+// ---------------------------------------------------------------------------
+export function createListModelsTool(client) {
+    return tool({
+        description: 'List all available AI providers and their models. ' +
+            'Use this to discover which provider/model strings can be passed to ff_pipeline or ff_mini_loop.',
+        args: {},
+        async execute() {
+            const response = await client.provider.list();
+            const data = response.data;
+            if (!data) {
+                return 'Unable to retrieve provider list from the OpenCode SDK.';
+            }
+            const { all: providers, connected, default: defaults } = data;
+            const lines = ['# Available Providers and Models\n'];
+            // Show default model assignments
+            if (defaults && Object.keys(defaults).length > 0) {
+                lines.push('## Defaults\n');
+                for (const [role, model] of Object.entries(defaults)) {
+                    lines.push(`- **${role}**: ${model}`);
+                }
+                lines.push('');
+            }
+            // Show connected providers
+            if (connected.length > 0) {
+                lines.push(`## Connected Providers\n`);
+                lines.push(connected.map((p) => `\`${p}\``).join(', '));
+                lines.push('');
+            }
+            // List all providers and their models
+            for (const provider of providers) {
+                const isConnected = connected.includes(provider.id);
+                const statusBadge = isConnected ? '✅' : '⚠️ (not connected)';
+                lines.push(`## ${provider.name} ${statusBadge}\n`);
+                lines.push(`Provider ID: \`${provider.id}\`\n`);
+                const modelEntries = Object.entries(provider.models);
+                if (modelEntries.length === 0) {
+                    lines.push('_No models available._\n');
+                    continue;
+                }
+                lines.push('| Model ID | Name | Reasoning | Tool Calls | Attachments |');
+                lines.push('|----------|------|-----------|------------|-------------|');
+                for (const [, model] of modelEntries) {
+                    const flags = [
+                        model.reasoning ? '✅' : '—',
+                        model.tool_call ? '✅' : '—',
+                        model.attachment ? '✅' : '—',
+                    ];
+                    lines.push(`| \`${provider.id}/${model.id}\` | ${model.name} | ${flags[0]} | ${flags[1]} | ${flags[2]} |`);
+                }
+                lines.push('');
+            }
+            lines.push('---\n' +
+                'Use the `provider_id/model_id` format when overriding models in `ff_mini_loop` or `ff_pipeline`.');
+            return lines.join('\n');
+        },
+    });
+}

package/dist/tools/mini-loop.js

@@ -5,17 +5,18 @@
  * Implements a build/review loop, then a documentation loop.
  */
 import { tool } from '@opencode-ai/plugin/tool';
-import { promptSession, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, BUILD_MODEL, DOC_MODEL, DOC_REVIEW_MODEL, ORCHESTRATOR_MODEL, parseModelString, } from '../workflow/orchestrator.js';
+import { promptSession, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, parseModelString, } from '../workflow/orchestrator.js';
 import { miniBuildPrompt, miniReviewPrompt, documentPrompt, docReviewPrompt } from './prompts.js';
 import { parseMiniReview, parseDocReview } from './parsers.js';
 // ---------------------------------------------------------------------------
 // Tool factory
 // ---------------------------------------------------------------------------
+const formatElapsed = (startMs, endMs) => `${((endMs - startMs) / 1000).toFixed(1)}s`;
 export function createMiniLoopTool(client) {
     return tool({
         description: 'Run the Feature Factory mini-loop: build → review (with rework loop) → documentation. ' +
             'Lighter weight than the full pipeline — no multi-model planning phase. ' +
-            'All model parameters are optional and use sensible defaults.',
+            'All model parameters are optional — when omitted, child sessions inherit the current session model.',
         args: {
             requirements: tool.schema
                 .string()
@@ -23,38 +24,39 @@ export function createMiniLoopTool(client) {
             build_model: tool.schema
                 .string()
                 .optional()
-                .describe('provider/model for building and implementation. Defaults to openai/gpt-5.3-codex.'),
+                .describe('provider/model for building and implementation. When omitted, inherits the session model.'),
             review_model: tool.schema
                 .string()
                 .optional()
-                .describe('provider/model for implementation review. Defaults to openai/gpt-5.4.'),
+                .describe('provider/model for implementation review. When omitted, inherits the session model.'),
             doc_model: tool.schema
                 .string()
                 .optional()
-                .describe('provider/model for documentation writing. Defaults to the build model.'),
+                .describe('provider/model for documentation writing. When omitted, defaults to build_model if provided, otherwise inherits the session model.'),
             doc_review_model: tool.schema
                 .string()
                 .optional()
-                .describe('provider/model for documentation review. Defaults to opencode/gemini-3.1-pro.'),
+                .describe('provider/model for documentation review. When omitted, inherits the session model.'),
         },
         async execute(args, context) {
+            const totalStartMs = Date.now();
             const sessionId = context.sessionID;
             const { requirements } = args;
-            // Resolve models — use provided overrides or fall back to defaults
+            // Resolve models — use provided overrides or undefined (inherit session model)
             const buildModel = args.build_model
                 ? parseModelString(args.build_model)
-                : BUILD_MODEL;
+                : undefined;
             const reviewModel = args.review_model
                 ? parseModelString(args.review_model)
-                : ORCHESTRATOR_MODEL;
+                : undefined;
             const docModel = args.doc_model
                 ? parseModelString(args.doc_model)
                 : args.build_model
                     ? buildModel
-                    : DOC_MODEL;
+                    : undefined;
             const docReviewModel = args.doc_review_model
                 ? parseModelString(args.doc_review_model)
-                : DOC_REVIEW_MODEL;
+                : undefined;
             const report = [];
             const addReport = (phase, msg) => {
                 report.push(`## ${phase}\n${msg}`);
@@ -62,71 +64,241 @@ export function createMiniLoopTool(client) {
             // ===================================================================
             // PHASE 1: IMPLEMENTATION LOOP (build → review → gate, up to 10)
             // ===================================================================
+            const implementationStartMs = Date.now();
+            const implementationIterationDetails = [];
             let implGate = { decision: 'REWORK', feedback: requirements };
             let lastImplRaw = '';
             for (let implIter = 0; implIter < 10 && implGate.decision === 'REWORK'; implIter++) {
+                const iteration = implIter + 1;
+                const buildTitle = `ff-mini-build-${iteration}`;
+                const reviewTitle = `ff-mini-review-${iteration}`;
                 const buildInput = implIter === 0
                     ? requirements
                     : `${requirements}\n\nPrevious review feedback:\n${implGate.feedback}`;
+                context.metadata({
+                    title: `⏳ Building (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'implementation',
+                        step: 'build',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Build
-                lastImplRaw = await promptSession(client, sessionId, miniBuildPrompt(buildInput, implIter > 0 ? implGate.feedback : undefined), { model: buildModel, agent: 'building', title: `ff-mini-build-${implIter + 1}` });
+                const buildStartMs = Date.now();
+                lastImplRaw = await promptSession(client, sessionId, miniBuildPrompt(buildInput, implIter > 0 ? implGate.feedback : undefined), { model: buildModel, agent: 'building', title: buildTitle });
+                const buildEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Reviewing (iteration ${iteration}/10)...`,
+                    metadata: {
+                        phase: 'implementation',
+                        step: 'review',
+                        iteration,
+                        maxIterations: 10,
+                    },
+                });
                 // Review
+                const reviewStartMs = Date.now();
                 const reviewRaw = await promptSession(client, sessionId, miniReviewPrompt(lastImplRaw), {
                     model: reviewModel,
                     agent: 'reviewing',
-                    title: `ff-mini-review-${implIter + 1}`,
+                    title: reviewTitle,
                 });
+                const reviewEndMs = Date.now();
                 const review = parseMiniReview(reviewRaw);
                 // Gate (deterministic)
-                implGate = evaluateMiniLoopImplGate(review, implIter + 1);
+                implGate = evaluateMiniLoopImplGate(review, iteration);
                 if (implGate.decision === 'APPROVED') {
-                    addReport('Implementation', `APPROVED (confidence: ${review.confidence}, iteration: ${implIter + 1})`);
+                    context.metadata({
+                        title: `✅ Implementation APPROVED (confidence: ${review.confidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
                 }
                 else if (implGate.decision === 'ESCALATE') {
-                    addReport('Implementation', `ESCALATE: ${implGate.reason}`);
+                    context.metadata({
+                        title: '⚠️ Implementation ESCALATED',
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
+                }
+                else {
+                    context.metadata({
+                        title: `🔄 Rework required (confidence: ${review.confidence}, iteration: ${iteration}/10)`,
+                        metadata: {
+                            phase: 'implementation',
+                            step: 'gate',
+                            decision: implGate.decision,
+                            confidence: review.confidence,
+                            iteration,
+                            maxIterations: 10,
+                        },
+                    });
+                }
+                const feedback = review.reworkInstructions || implGate.feedback || review.raw;
+                implementationIterationDetails.push(`### Iteration ${iteration}\n` +
+                    `- **Build**: ${buildTitle} (${formatElapsed(buildStartMs, buildEndMs)})\n` +
+                    `- **Review**: ${reviewTitle} (${formatElapsed(reviewStartMs, reviewEndMs)})\n` +
+                    `- **Gate**: ${implGate.decision} (confidence: ${review.confidence}, change requested: ${review.changeRequested ? 'yes' : 'no'}, unresolved: ${review.unresolvedIssues})\n` +
+                    `- **Feedback**: ${feedback}`);
+                if (implGate.decision === 'ESCALATE') {
+                    const implementationEndMs = Date.now();
+                    addReport('Implementation', `${implementationIterationDetails.join('\n\n')}\n\n**Outcome**: ESCALATE: ${implGate.reason}\n**Phase time**: ${formatElapsed(implementationStartMs, implementationEndMs)}`);
+                    context.metadata({
+                        title: '⚠️ Mini-loop finished with issues',
+                        metadata: {
+                            phase: 'complete',
+                            outcome: 'issues',
+                            totalElapsedMs: Date.now() - totalStartMs,
+                        },
+                    });
+                    addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                     return report.join('\n\n');
                 }
                 // REWORK continues the loop
             }
+            const implementationEndMs = Date.now();
+            addReport('Implementation', `${implementationIterationDetails.join('\n\n')}\n\n**Outcome**: ${implGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : `REWORK exhausted (10 iterations). Last feedback: ${implGate.feedback}`}\n**Phase time**: ${formatElapsed(implementationStartMs, implementationEndMs)}`);
             if (implGate.decision !== 'APPROVED') {
-                addReport('Implementation', `REWORK exhausted (10 iterations). Last feedback:\n${implGate.feedback}`);
+                context.metadata({
+                    title: '⚠️ Mini-loop finished with issues',
+                    metadata: {
+                        phase: 'complete',
+                        outcome: 'issues',
+                        totalElapsedMs: Date.now() - totalStartMs,
+                    },
+                });
+                addReport('Complete', `Mini-loop finished with issues.\n**Total time**: ${formatElapsed(totalStartMs, Date.now())}`);
                 return report.join('\n\n');
             }
             // ===================================================================
             // PHASE 2: DOCUMENTATION LOOP (document → review → gate, up to 5)
             // ===================================================================
+            const documentationStartMs = Date.now();
+            const documentationIterationDetails = [];
             let docInput = lastImplRaw;
             let docGate = { decision: 'REWORK' };
             for (let docIter = 0; docIter < 5 && docGate.decision === 'REWORK'; docIter++) {
+                const iteration = docIter + 1;
+                const writeTitle = `ff-mini-doc-write-${iteration}`;
+                const reviewTitle = `ff-mini-doc-review-${iteration}`;
+                context.metadata({
+                    title: `⏳ Writing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'write',
+                        iteration,
+                        maxIterations: 5,
+                    },
+                });
                 // Write docs
+                const writeStartMs = Date.now();
                 const docRaw = await promptSession(client, sessionId, documentPrompt(docInput), {
                     model: docModel,
                     agent: 'documenting',
-                    title: `ff-mini-doc-write-${docIter + 1}`,
+                    title: writeTitle,
+                });
+                const writeEndMs = Date.now();
+                context.metadata({
+                    title: `⏳ Reviewing documentation (iteration ${iteration}/5)...`,
+                    metadata: {
+                        phase: 'documentation',
+                        step: 'review',
+                        iteration,
+                        maxIterations: 5,
+                    },
                 });
                 // Review docs
+                const reviewStartMs = Date.now();
                 const docRevRaw = await promptSession(client, sessionId, docReviewPrompt(docRaw), {
                     model: docReviewModel,
                     agent: 'reviewing',
-                    title: `ff-mini-doc-review-${docIter + 1}`,
+                    title: reviewTitle,
                 });
+                const reviewEndMs = Date.now();
                 const docReview = parseDocReview(docRevRaw);
                 // Gate (deterministic)
-                docGate = evaluateMiniLoopDocGate(docReview, docIter + 1);
+                docGate = evaluateMiniLoopDocGate(docReview, iteration);
                 if (docGate.decision === 'APPROVED') {
-                    addReport('Documentation', `APPROVED (confidence: ${docReview.confidence}, iteration: ${docIter + 1})`);
+                    context.metadata({
+                        title: `✅ Documentation APPROVED (confidence: ${docReview.confidence}, iteration: ${iteration})`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else if (docGate.decision === 'ESCALATE') {
-                    addReport('Documentation', `ESCALATE: ${docGate.reason}`);
+                    context.metadata({
+                        title: '⚠️ Documentation ESCALATED',
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
                 }
                 else {
+                    context.metadata({
+                        title: `🔄 Documentation rework required (confidence: ${docReview.confidence}, iteration: ${iteration}/5)`,
+                        metadata: {
+                            phase: 'documentation',
+                            step: 'gate',
+                            decision: docGate.decision,
+                            confidence: docReview.confidence,
+                            iteration,
+                            maxIterations: 5,
+                        },
+                    });
+                }
+                const feedback = docReview.reworkInstructions || docGate.feedback || docReview.raw;
+                documentationIterationDetails.push(`### Iteration ${iteration}\n` +
+                    `- **Write**: ${writeTitle} (${formatElapsed(writeStartMs, writeEndMs)})\n` +
+                    `- **Review**: ${reviewTitle} (${formatElapsed(reviewStartMs, reviewEndMs)})\n` +
+                    `- **Gate**: ${docGate.decision} (confidence: ${docReview.confidence}, unresolved: ${docReview.unresolvedIssues})\n` +
+                    `- **Feedback**: ${feedback}`);
+                if (docGate.decision === 'REWORK') {
                     docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
                 }
             }
-            // ===================================================================
-            // FINAL REPORT
-            // ===================================================================
-            addReport('Complete', 'Mini-loop finished.');
+            const documentationEndMs = Date.now();
+            addReport('Documentation', `${documentationIterationDetails.join('\n\n')}\n\n**Outcome**: ${docGate.decision === 'APPROVED'
+                ? 'APPROVED'
+                : docGate.decision === 'ESCALATE'
+                    ? `ESCALATE: ${docGate.reason}`
+                    : `REWORK exhausted (5 iterations). Last feedback: ${docGate.feedback}`}\n**Phase time**: ${formatElapsed(documentationStartMs, documentationEndMs)}`);
+            const totalEndMs = Date.now();
+            const completedWithoutIssues = docGate.decision === 'APPROVED';
+            context.metadata({
+                title: completedWithoutIssues ? '✅ Mini-loop complete' : '⚠️ Mini-loop finished with issues',
+                metadata: {
+                    phase: 'complete',
+                    outcome: completedWithoutIssues ? 'success' : 'issues',
+                    totalElapsedMs: totalEndMs - totalStartMs,
+                },
+            });
+            addReport('Complete', `${completedWithoutIssues ? 'Mini-loop finished successfully.' : 'Mini-loop finished with issues.'}\n**Total time**: ${formatElapsed(totalStartMs, totalEndMs)}`);
             return report.join('\n\n');
         },
     });

package/dist/tools/pipeline.js

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

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

@@ -12,7 +12,7 @@
 import type { NamedModel, ModelId } from './types.js';
 /**
  * Opaque client type — the plugin receives `ReturnType<typeof createOpencodeClient>`
- * but we only need `.session.create` and `.session.prompt`.
+ * but we only need a subset of the SDK surface.
  * We keep it loosely typed so this module doesn't import the full SDK.
  */
 export type Client = {
@@ -53,6 +53,33 @@ export type Client = {
             };
         }>;
     };
+    provider: {
+        list(options?: {
+            query?: {
+                directory?: string;
+            };
+        }): Promise<{
+            data?: {
+                all: Array<{
+                    id: string;
+                    name: string;
+                    models: {
+                        [key: string]: {
+                            id: string;
+                            name: string;
+                            attachment: boolean;
+                            reasoning: boolean;
+                            tool_call: boolean;
+                        };
+                    };
+                }>;
+                connected: Array<string>;
+                default: {
+                    [key: string]: string;
+                };
+            };
+        }>;
+    };
 };
 /** Extract all text parts from an SDK prompt response. */
 export declare function extractText(parts: Array<{

package/dist/workflow/fan-out.js

@@ -41,13 +41,20 @@ async function promptInChildSession(client, parentSessionId, prompt, options) {
         throw new Error('Failed to create child session');
     }
     // 2. Send the prompt to the child session
+    //    When model is undefined, omit it entirely so the child session
+    //    inherits the parent session's model (SDK default behavior).
+    const body = {
+        parts: [{ type: 'text', text: prompt }],
+    };
+    if (options?.model) {
+        body.model = options.model;
+    }
+    if (options?.agent) {
+        body.agent = options.agent;
+    }
     const response = await client.session.prompt({
         path: { id: childId },
-        body: {
-            model: options?.model,
-            agent: options?.agent,
-            parts: [{ type: 'text', text: prompt }],
-        },
+        body,
     });
     // 3. Extract and return the text
     return extractText(response.data?.parts ?? []);

package/package.json

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