@syntesseraai/opencode-feature-factory 0.6.20 → 0.7.0

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

@@ -0,0 +1,84 @@
+/**
+ * Fan-out helpers for multi-model parallel invocation.
+ *
+ * Every sub-step runs in an **isolated child session** so that
+ * intermediate prompts and responses stay off the main context window.
+ * Only the final tool return value surfaces in the parent conversation.
+ *
+ * Because tools execute synchronously in OpenCode (the tool blocks until
+ * `execute()` resolves), we can safely `Promise.all` the SDK calls inside
+ * a single tool invocation.
+ */
+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`.
+ * We keep it loosely typed so this module doesn't import the full SDK.
+ */
+export type Client = {
+    session: {
+        create(options: {
+            body?: {
+                parentID?: string;
+                title?: string;
+            };
+        }): Promise<{
+            data?: {
+                id: string;
+            };
+        }>;
+        prompt(options: {
+            path: {
+                id: string;
+            };
+            body: {
+                model?: {
+                    providerID: string;
+                    modelID: string;
+                };
+                agent?: string;
+                parts: Array<{
+                    type: 'text';
+                    text: string;
+                }>;
+            };
+        }): Promise<{
+            data?: {
+                info: unknown;
+                parts: Array<{
+                    type: string;
+                    text?: string;
+                    [k: string]: unknown;
+                }>;
+            };
+        }>;
+    };
+};
+/** Extract all text parts from an SDK prompt response. */
+export declare function extractText(parts: Array<{
+    type: string;
+    text?: string;
+    [k: string]: unknown;
+}>): string;
+export interface FanOutResult {
+    tag: string;
+    raw: string;
+}
+/**
+ * Create one isolated child session per model (in parallel), prompt each,
+ * and return the collected text outputs tagged by model.
+ *
+ * Each model's work runs in its own child session so none of the
+ * intermediate outputs pollute the parent context window.
+ */
+export declare function fanOut(client: Client, parentSessionId: string, models: readonly NamedModel[], buildPrompt: (tag: string) => string, agent?: string): Promise<FanOutResult[]>;
+/**
+ * Prompt in an isolated child session and return the raw text response.
+ *
+ * This keeps the sub-step off the parent's context window.
+ */
+export declare function promptSession(client: Client, parentSessionId: string, prompt: string, options?: {
+    model?: ModelId;
+    agent?: string;
+    title?: string;
+}): Promise<string>;

package/dist/workflow/fan-out.js

@@ -0,0 +1,83 @@
+/**
+ * Fan-out helpers for multi-model parallel invocation.
+ *
+ * Every sub-step runs in an **isolated child session** so that
+ * intermediate prompts and responses stay off the main context window.
+ * Only the final tool return value surfaces in the parent conversation.
+ *
+ * Because tools execute synchronously in OpenCode (the tool blocks until
+ * `execute()` resolves), we can safely `Promise.all` the SDK calls inside
+ * a single tool invocation.
+ */
+// ---------------------------------------------------------------------------
+// Text extraction helper
+// ---------------------------------------------------------------------------
+/** Extract all text parts from an SDK prompt response. */
+export function extractText(parts) {
+    return parts
+        .filter((p) => p.type === 'text' && typeof p.text === 'string')
+        .map((p) => p.text)
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// Isolated session helper
+// ---------------------------------------------------------------------------
+/**
+ * Create an isolated child session, send a prompt, and return the text.
+ *
+ * The child session is parented to `parentSessionId` so it appears in the
+ * session tree but its messages do **not** pollute the parent context window.
+ */
+async function promptInChildSession(client, parentSessionId, prompt, options) {
+    // 1. Create an isolated child session
+    const session = await client.session.create({
+        body: {
+            parentID: parentSessionId,
+            title: options?.title,
+        },
+    });
+    const childId = session.data?.id;
+    if (!childId) {
+        throw new Error('Failed to create child session');
+    }
+    // 2. Send the prompt to the child session
+    const response = await client.session.prompt({
+        path: { id: childId },
+        body: {
+            model: options?.model,
+            agent: options?.agent,
+            parts: [{ type: 'text', text: prompt }],
+        },
+    });
+    // 3. Extract and return the text
+    return extractText(response.data?.parts ?? []);
+}
+/**
+ * Create one isolated child session per model (in parallel), prompt each,
+ * and return the collected text outputs tagged by model.
+ *
+ * Each model's work runs in its own child session so none of the
+ * intermediate outputs pollute the parent context window.
+ */
+export async function fanOut(client, parentSessionId, models, buildPrompt, agent) {
+    const results = await Promise.all(models.map(async (nm) => {
+        const raw = await promptInChildSession(client, parentSessionId, buildPrompt(nm.tag), {
+            model: nm.model,
+            agent,
+            title: `ff-fanout-${nm.tag}`,
+        });
+        return { tag: nm.tag, raw };
+    }));
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Single prompt helper (isolated)
+// ---------------------------------------------------------------------------
+/**
+ * Prompt in an isolated child session and return the raw text response.
+ *
+ * This keeps the sub-step off the parent's context window.
+ */
+export async function promptSession(client, parentSessionId, prompt, options) {
+    return promptInChildSession(client, parentSessionId, prompt, options);
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Deterministic gate evaluation functions.
+ *
+ * These replace the LLM-evaluated gate commands with code that applies
+ * threshold logic directly. The LLM still produces the synthesis; the
+ * gate decision is computed here.
+ */
+import type { GateResult, ConsensusPlan, ReviewSynthesis, DocReview } from './types.js';
+/**
+ * Evaluate the planning consensus gate.
+ *
+ * - `>=75` consensus score → APPROVED
+ * - `50-74` → REWORK
+ * - `<50`   → BLOCKED
+ */
+export declare function evaluatePlanningGate(consensus: ConsensusPlan): GateResult;
+/**
+ * Evaluate the review approval gate.
+ *
+ * - confidence >=95 AND unresolvedIssues == 0 → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export declare function evaluateReviewGate(synthesis: ReviewSynthesis, iteration: number, maxIterations?: number): GateResult;
+/**
+ * Evaluate the documentation approval gate.
+ *
+ * - confidence >95, no change requested, 0 unresolved → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export declare function evaluateDocGate(review: DocReview, iteration: number, maxIterations?: number): GateResult;
+/**
+ * Evaluate the mini-loop implementation gate.
+ *
+ * - confidence >95, no change requested, 0 blocking issues → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export declare function evaluateMiniLoopImplGate(review: {
+    confidence: number;
+    changeRequested: boolean;
+    unresolvedIssues: number;
+    reworkInstructions?: string;
+}, iteration: number, maxIterations?: number): GateResult;
+/**
+ * Evaluate the mini-loop documentation gate.
+ * Same thresholds as the pipeline doc gate.
+ */
+export declare const evaluateMiniLoopDocGate: typeof evaluateDocGate;

package/dist/workflow/gate-evaluator.js

@@ -0,0 +1,118 @@
+/**
+ * Deterministic gate evaluation functions.
+ *
+ * These replace the LLM-evaluated gate commands with code that applies
+ * threshold logic directly. The LLM still produces the synthesis; the
+ * gate decision is computed here.
+ */
+// ---------------------------------------------------------------------------
+// Planning gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the planning consensus gate.
+ *
+ * - `>=75` consensus score → APPROVED
+ * - `50-74` → REWORK
+ * - `<50`   → BLOCKED
+ */
+export function evaluatePlanningGate(consensus) {
+    if (consensus.consensusScore >= 75) {
+        return { decision: 'APPROVED' };
+    }
+    if (consensus.consensusScore >= 50) {
+        return {
+            decision: 'REWORK',
+            feedback: `Consensus score ${consensus.consensusScore}/100. Divergent elements:\n${consensus.divergentElements}\nOpen questions:\n${consensus.openQuestions}`,
+        };
+    }
+    return {
+        decision: 'BLOCKED',
+        reason: `Consensus score too low (${consensus.consensusScore}/100). Open questions:\n${consensus.openQuestions}`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Review gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the review approval gate.
+ *
+ * - confidence >=95 AND unresolvedIssues == 0 → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateReviewGate(synthesis, iteration, maxIterations = 10) {
+    if (synthesis.overallConfidence >= 95 && synthesis.unresolvedIssues === 0) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max review iterations reached (${maxIterations}). Confidence: ${synthesis.overallConfidence}, unresolved: ${synthesis.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: synthesis.reworkInstructions ??
+            `Confidence ${synthesis.overallConfidence}/100 with ${synthesis.unresolvedIssues} unresolved issues.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Documentation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the documentation approval gate.
+ *
+ * - confidence >95, no change requested, 0 unresolved → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateDocGate(review, iteration, maxIterations = 5) {
+    if (review.verdict === 'APPROVED' && review.unresolvedIssues === 0 && review.confidence > 95) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max doc iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: review.reworkInstructions ??
+            `Documentation review verdict: ${review.verdict}. ${review.unresolvedIssues} unresolved issues.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mini-loop implementation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the mini-loop implementation gate.
+ *
+ * - confidence >95, no change requested, 0 blocking issues → APPROVED
+ * - iteration >= maxIterations → ESCALATE
+ * - otherwise → REWORK
+ */
+export function evaluateMiniLoopImplGate(review, iteration, maxIterations = 10) {
+    if (review.confidence > 95 && !review.changeRequested && review.unresolvedIssues === 0) {
+        return { decision: 'APPROVED' };
+    }
+    if (iteration >= maxIterations) {
+        return {
+            decision: 'ESCALATE',
+            reason: `Max mini-loop iterations reached (${maxIterations}). Confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+        };
+    }
+    return {
+        decision: 'REWORK',
+        feedback: review.reworkInstructions ??
+            `Change requested: ${review.changeRequested}, confidence: ${review.confidence}, unresolved: ${review.unresolvedIssues}`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mini-loop documentation gate
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate the mini-loop documentation gate.
+ * Same thresholds as the pipeline doc gate.
+ */
+export const evaluateMiniLoopDocGate = evaluateDocGate;

package/dist/workflow/orchestrator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared workflow orchestration utilities.
+ *
+ * Re-exports the fan-out, gate, and type modules as a single convenient
+ * entry-point for tool implementations.
+ */
+export { fanOut, promptSession, extractText, type Client } from './fan-out.js';
+export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export * from './types.js';

package/dist/workflow/orchestrator.js

@@ -0,0 +1,9 @@
+/**
+ * Shared workflow orchestration utilities.
+ *
+ * Re-exports the fan-out, gate, and type modules as a single convenient
+ * entry-point for tool implementations.
+ */
+export { fanOut, promptSession, extractText } from './fan-out.js';
+export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export * from './types.js';

package/dist/workflow/types.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Workflow type definitions for the Feature Factory pipeline and mini-loop.
+ *
+ * These types represent the structured data that flows between phases
+ * of the workflow, replacing the untyped $RESULT[name] string interpolation
+ * used by the subtask2 command approach.
+ */
+/** A model identifier split into provider and model parts. */
+export interface ModelId {
+    providerID: string;
+    modelID: string;
+}
+/** Named model configuration used for fan-out. */
+export interface NamedModel {
+    /** Human label used in prompts and logs (e.g. "opus", "gemini", "codex") */
+    tag: string;
+    /** Provider/model split consumed by the SDK. */
+    model: ModelId;
+}
+export declare const PLANNING_MODELS: readonly NamedModel[];
+export declare const REVIEW_MODELS: readonly NamedModel[];
+export declare const ORCHESTRATOR_MODEL: ModelId;
+export declare const BUILD_MODEL: ModelId;
+export declare const DOC_MODEL: ModelId;
+export declare const VALIDATE_MODEL: ModelId;
+export declare const DOC_REVIEW_MODEL: ModelId;
+export type GateDecision = 'APPROVED' | 'REWORK' | 'BLOCKED' | 'ESCALATE';
+export interface GateResult {
+    decision: GateDecision;
+    /** Feedback for the next loop iteration when decision is REWORK. */
+    feedback?: string;
+    /** Reason the gate blocked or escalated. */
+    reason?: string;
+}
+export interface PlanProposal {
+    tag: string;
+    requirementsSummary: string;
+    architectureValidation: string;
+    implementationSteps: string;
+    risksAndMitigations: string;
+    testingStrategy: string;
+    /** The full raw text returned by the model (kept for transparency). */
+    raw: string;
+}
+export interface ConsensusPlan {
+    consensusScore: number;
+    agreedElements: string;
+    divergentElements: string;
+    synthesizedPlan: string;
+    openQuestions: string;
+    raw: string;
+}
+export interface PlanningPhaseResult {
+    proposals: PlanProposal[];
+    consensus: ConsensusPlan;
+    gate: GateResult;
+    /** The final plan text accepted by the gate (only set when APPROVED). */
+    finalPlan?: string;
+}
+export interface TaskBreakdown {
+    taskId: string;
+    title: string;
+    description: string;
+    targetFiles: string[];
+    dependencies: string[];
+    acceptanceCriteria: string;
+}
+export interface ValidatedBatch {
+    batchId: string;
+    tasks: TaskBreakdown[];
+    parallelizable: boolean;
+    architecturalRisks: string[];
+}
+export interface ImplementationReport {
+    filesChanged: string[];
+    testsRun: string[];
+    testsPassed: boolean;
+    openIssues: string[];
+    raw: string;
+}
+export interface BuildPhaseResult {
+    tasks: TaskBreakdown[];
+    batches: ValidatedBatch[];
+    implementation: ImplementationReport;
+}
+export interface ReviewReport {
+    tag: string;
+    findings: string;
+    confidence: number;
+    raw: string;
+}
+export interface ReviewSynthesis {
+    overallConfidence: number;
+    consolidatedFindings: string;
+    unresolvedIssues: number;
+    verdict: 'APPROVED' | 'REWORK_REQUIRED';
+    reworkInstructions?: string;
+    raw: string;
+}
+export interface ReviewPhaseResult {
+    reviews: ReviewReport[];
+    synthesis: ReviewSynthesis;
+    gate: GateResult;
+}
+export interface DocUpdate {
+    filesChanged: string[];
+    rationale: string;
+    raw: string;
+}
+export interface DocReview {
+    verdict: 'APPROVED' | 'REWORK_REQUIRED';
+    unresolvedIssues: number;
+    confidence: number;
+    reworkInstructions?: string;
+    raw: string;
+}
+export interface DocPhaseResult {
+    update: DocUpdate;
+    review: DocReview;
+    gate: GateResult;
+}
+export interface PipelineState {
+    requirements: string;
+    planning?: PlanningPhaseResult;
+    build?: BuildPhaseResult;
+    review?: ReviewPhaseResult;
+    documentation?: DocPhaseResult;
+}
+export interface MiniLoopState {
+    requirements: string;
+    implementation?: ImplementationReport;
+    review?: {
+        confidence: number;
+        changeRequested: boolean;
+        unresolvedIssues: number;
+        reworkInstructions?: string;
+        raw: string;
+    };
+    documentation?: DocPhaseResult;
+}
+/** Parse "provider/model" string into a ModelId. */
+export declare function parseModelString(s: string): ModelId;
+/**
+ * Parse a comma-separated list of `tag:provider/model` entries into NamedModel[].
+ *
+ * Example input: `"opus:anthropic/claude-opus-4-6, gemini:google/gemini-2.5-pro"`
+ */
+export declare function parseNamedModels(s: string): NamedModel[];

package/dist/workflow/types.js

@@ -0,0 +1,62 @@
+/**
+ * Workflow type definitions for the Feature Factory pipeline and mini-loop.
+ *
+ * These types represent the structured data that flows between phases
+ * of the workflow, replacing the untyped $RESULT[name] string interpolation
+ * used by the subtask2 command approach.
+ */
+// ---------------------------------------------------------------------------
+// Default model roster
+// ---------------------------------------------------------------------------
+export const PLANNING_MODELS = [
+    { tag: 'opus', model: { providerID: 'anthropic', modelID: 'claude-opus-4-6' } },
+    { tag: 'gemini', model: { providerID: 'opencode', modelID: 'gemini-3.1-pro' } },
+    { tag: 'codex', model: { providerID: 'openai', modelID: 'gpt-5.3-codex' } },
+];
+export const REVIEW_MODELS = PLANNING_MODELS;
+export const ORCHESTRATOR_MODEL = {
+    providerID: 'openai',
+    modelID: 'gpt-5.4',
+};
+export const BUILD_MODEL = {
+    providerID: 'openai',
+    modelID: 'gpt-5.3-codex',
+};
+export const DOC_MODEL = BUILD_MODEL;
+export const VALIDATE_MODEL = {
+    providerID: 'opencode',
+    modelID: 'gemini-3.1-pro',
+};
+export const DOC_REVIEW_MODEL = VALIDATE_MODEL;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Parse "provider/model" string into a ModelId. */
+export function parseModelString(s) {
+    const slash = s.indexOf('/');
+    if (slash === -1)
+        return { providerID: s, modelID: s };
+    return { providerID: s.slice(0, slash), modelID: s.slice(slash + 1) };
+}
+/**
+ * Parse a comma-separated list of `tag:provider/model` entries into NamedModel[].
+ *
+ * Example input: `"opus:anthropic/claude-opus-4-6, gemini:google/gemini-2.5-pro"`
+ */
+export function parseNamedModels(s) {
+    return s
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+        const colon = entry.indexOf(':');
+        if (colon === -1) {
+            // No tag — use the model id as the tag
+            const model = parseModelString(entry);
+            return { tag: model.modelID, model };
+        }
+        const tag = entry.slice(0, colon).trim();
+        const model = parseModelString(entry.slice(colon + 1).trim());
+        return { tag, model };
+    });
+}

package/package.json

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