@syntesseraai/opencode-feature-factory 0.6.21 → 0.7.1

package/dist/tools/pipeline.js

@@ -0,0 +1,227 @@
+/**
+ * ff_pipeline — Full plan → build → review → document workflow tool.
+ *
+ * This is an entrypoint tool exposed to the LLM. It orchestrates the
+ * complete Feature Factory pipeline using deterministic control flow
+ * (TypeScript loops and gates) while delegating creative work to
+ * model-specific prompts via the SDK client.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { fanOut, promptSession, evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, PLANNING_MODELS, REVIEW_MODELS, ORCHESTRATOR_MODEL, BUILD_MODEL, DOC_MODEL, VALIDATE_MODEL, DOC_REVIEW_MODEL, parseModelString, parseNamedModels, } from '../workflow/orchestrator.js';
+import { planningPrompt, synthesisPrompt, breakdownPrompt, validateBatchPrompt, implementBatchPrompt, triagePrompt, reviewPrompt, reviewSynthesisPrompt, documentPrompt, docReviewPrompt, } from './prompts.js';
+import { parseConsensusPlan, parseReviewSynthesis, parseImplementationReport, parseDocReview, } from './parsers.js';
+// ---------------------------------------------------------------------------
+// Tool factory — needs the SDK client from plugin init
+// ---------------------------------------------------------------------------
+export function createPipelineTool(client) {
+    return tool({
+        description: 'Run the full Feature Factory pipeline: multi-model planning → build → review → documentation. ' +
+            'Returns a structured completion report. All model parameters are optional and use sensible defaults.',
+        args: {
+            requirements: tool.schema
+                .string()
+                .describe('The feature requirements or task description to implement'),
+            planning_models: tool.schema
+                .string()
+                .optional()
+                .describe('Comma-separated list of tag:provider/model for planning fan-out. ' +
+                'Example: "opus:anthropic/claude-opus-4-6, gemini:google/gemini-2.5-pro". ' +
+                'Defaults to opus + gemini + codex.'),
+            review_models: tool.schema
+                .string()
+                .optional()
+                .describe('Comma-separated list of tag:provider/model for review fan-out. ' +
+                'Defaults to the same models as planning_models.'),
+            orchestrator_model: tool.schema
+                .string()
+                .optional()
+                .describe('provider/model for synthesis and triage steps. Defaults to openai/gpt-5.4.'),
+            build_model: tool.schema
+                .string()
+                .optional()
+                .describe('provider/model for building and implementation. Defaults to openai/gpt-5.3-codex.'),
+            validate_model: tool.schema
+                .string()
+                .optional()
+                .describe('provider/model for batch validation. Defaults to opencode/gemini-3.1-pro.'),
+            doc_model: tool.schema
+                .string()
+                .optional()
+                .describe('provider/model for documentation writing. Defaults to the build model.'),
+            doc_review_model: tool.schema
+                .string()
+                .optional()
+                .describe('provider/model for documentation review. Defaults to the validate model.'),
+        },
+        async execute(args, context) {
+            const sessionId = context.sessionID;
+            const { requirements } = args;
+            // Resolve models — use provided overrides or fall back to defaults
+            const planModels = args.planning_models
+                ? parseNamedModels(args.planning_models)
+                : PLANNING_MODELS;
+            const revModels = args.review_models
+                ? parseNamedModels(args.review_models)
+                : args.planning_models
+                    ? planModels
+                    : REVIEW_MODELS;
+            const orchestratorModel = args.orchestrator_model
+                ? parseModelString(args.orchestrator_model)
+                : ORCHESTRATOR_MODEL;
+            const buildModel = args.build_model
+                ? parseModelString(args.build_model)
+                : BUILD_MODEL;
+            const validateModel = args.validate_model
+                ? parseModelString(args.validate_model)
+                : VALIDATE_MODEL;
+            const docModel = args.doc_model
+                ? parseModelString(args.doc_model)
+                : args.build_model
+                    ? buildModel
+                    : DOC_MODEL;
+            const docReviewModel = args.doc_review_model
+                ? parseModelString(args.doc_review_model)
+                : args.validate_model
+                    ? validateModel
+                    : DOC_REVIEW_MODEL;
+            const report = [];
+            const addReport = (phase, msg) => {
+                report.push(`## ${phase}\n${msg}`);
+            };
+            // ===================================================================
+            // PHASE 1: PLANNING (fan-out → synthesize → gate, loop up to 5)
+            // ===================================================================
+            let planningGate = { decision: 'REWORK', feedback: requirements };
+            let finalPlan = '';
+            for (let planIter = 0; planIter < 5 && planningGate.decision === 'REWORK'; planIter++) {
+                const planInput = planIter === 0
+                    ? requirements
+                    : `${requirements}\n\nPrevious feedback:\n${planningGate.feedback}`;
+                // Fan-out: N models plan in parallel
+                const fanOutResults = await fanOut(client, sessionId, planModels, (tag) => planningPrompt(planInput, tag), 'planning');
+                // Synthesize consensus
+                const synthesisRaw = await promptSession(client, sessionId, synthesisPrompt(fanOutResults), {
+                    model: orchestratorModel,
+                    agent: 'planning',
+                    title: `ff-plan-synthesis-${planIter + 1}`,
+                });
+                const consensus = parseConsensusPlan(synthesisRaw);
+                // Gate (deterministic)
+                planningGate = evaluatePlanningGate(consensus);
+                if (planningGate.decision === 'APPROVED') {
+                    finalPlan = consensus.synthesizedPlan || synthesisRaw;
+                    addReport('Planning', `APPROVED (score: ${consensus.consensusScore}, iteration: ${planIter + 1})`);
+                }
+                else if (planningGate.decision === 'BLOCKED') {
+                    addReport('Planning', `BLOCKED: ${planningGate.reason}`);
+                    return report.join('\n\n');
+                }
+                // REWORK continues the loop
+            }
+            if (planningGate.decision !== 'APPROVED') {
+                addReport('Planning', `REWORK exhausted (5 iterations). Last feedback:\n${planningGate.feedback}`);
+                return report.join('\n\n');
+            }
+            // ===================================================================
+            // PHASE 2: BUILDING (breakdown → validate → implement)
+            // ===================================================================
+            // Breakdown
+            const tasksRaw = await promptSession(client, sessionId, breakdownPrompt(finalPlan), {
+                model: buildModel,
+                agent: 'building',
+                title: 'ff-build-breakdown',
+            });
+            // Validate batches
+            const batchesRaw = await promptSession(client, sessionId, validateBatchPrompt(tasksRaw), {
+                model: validateModel,
+                agent: 'building',
+                title: 'ff-build-validate',
+            });
+            // Implement
+            const implRaw = await promptSession(client, sessionId, implementBatchPrompt(batchesRaw), {
+                model: buildModel,
+                agent: 'building',
+                title: 'ff-build-implement',
+            });
+            const implementation = parseImplementationReport(implRaw);
+            addReport('Building', `Implementation completed. Tests passed: ${implementation.testsPassed}`);
+            // ===================================================================
+            // PHASE 3: REVIEWING (triage → fan-out review → synthesize → gate, loop up to 10)
+            // ===================================================================
+            let reviewInput = implRaw;
+            let reviewGate = { decision: 'REWORK' };
+            for (let revIter = 0; revIter < 10 && reviewGate.decision === 'REWORK'; revIter++) {
+                // Triage
+                const brief = await promptSession(client, sessionId, triagePrompt(reviewInput), {
+                    model: orchestratorModel,
+                    agent: 'reviewing',
+                    title: `ff-review-triage-${revIter + 1}`,
+                });
+                // Fan-out review
+                const reviewResults = await fanOut(client, sessionId, revModels, (tag) => reviewPrompt(brief, tag), 'reviewing');
+                // Synthesize
+                const synthRaw = await promptSession(client, sessionId, reviewSynthesisPrompt(reviewResults), {
+                    model: orchestratorModel,
+                    agent: 'reviewing',
+                    title: `ff-review-synthesis-${revIter + 1}`,
+                });
+                const synthesis = parseReviewSynthesis(synthRaw);
+                // Gate (deterministic)
+                reviewGate = evaluateReviewGate(synthesis, revIter + 1);
+                if (reviewGate.decision === 'APPROVED') {
+                    addReport('Reviewing', `APPROVED (confidence: ${synthesis.overallConfidence}, iteration: ${revIter + 1})`);
+                }
+                else if (reviewGate.decision === 'ESCALATE') {
+                    addReport('Reviewing', `ESCALATE: ${reviewGate.reason}`);
+                    return report.join('\n\n');
+                }
+                else {
+                    // 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}` });
+                    reviewInput = fixRaw;
+                }
+            }
+            if (reviewGate.decision !== 'APPROVED') {
+                addReport('Reviewing', `REWORK exhausted (10 iterations). Last feedback:\n${reviewGate.feedback}`);
+                return report.join('\n\n');
+            }
+            // ===================================================================
+            // PHASE 4: DOCUMENTATION (document → review → gate, loop up to 5)
+            // ===================================================================
+            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++) {
+                // Write docs
+                const docRaw = await promptSession(client, sessionId, documentPrompt(docInput), {
+                    model: docModel,
+                    agent: 'documenting',
+                    title: `ff-doc-write-${docIter + 1}`,
+                });
+                // Review docs
+                const docRevRaw = await promptSession(client, sessionId, docReviewPrompt(docRaw), {
+                    model: docReviewModel,
+                    agent: 'reviewing',
+                    title: `ff-doc-review-${docIter + 1}`,
+                });
+                const docReview = parseDocReview(docRevRaw);
+                // Gate (deterministic)
+                docGate = evaluateDocGate(docReview, docIter + 1);
+                if (docGate.decision === 'APPROVED') {
+                    addReport('Documentation', `APPROVED (confidence: ${docReview.confidence}, iteration: ${docIter + 1})`);
+                }
+                else if (docGate.decision === 'ESCALATE') {
+                    addReport('Documentation', `ESCALATE: ${docGate.reason}`);
+                }
+                else {
+                    // Feed feedback into the next iteration
+                    docInput = `${docInput}\n\nDocumentation review feedback:\n${docGate.feedback}`;
+                }
+            }
+            // ===================================================================
+            // FINAL REPORT
+            // ===================================================================
+            addReport('Complete', 'Pipeline finished.');
+            return report.join('\n\n');
+        },
+    });
+}

package/dist/tools/prompts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Prompt templates for workflow tools.
+ *
+ * Centralised here so that tools stay lean and prompts are easy to review
+ * and tune independently.
+ */
+export declare function planningPrompt(requirements: string, modelTag: string): string;
+export declare function synthesisPrompt(proposals: Array<{
+    tag: string;
+    raw: string;
+}>): string;
+export declare function breakdownPrompt(finalPlan: string): string;
+export declare function validateBatchPrompt(tasks: string): string;
+export declare function implementBatchPrompt(batches: string): string;
+export declare function triagePrompt(implementationReport: string): string;
+export declare function reviewPrompt(brief: string, modelTag: string): string;
+export declare function reviewSynthesisPrompt(reviews: Array<{
+    tag: string;
+    raw: string;
+}>): string;
+export declare function documentPrompt(input: string): string;
+export declare function docReviewPrompt(docUpdate: string): string;
+export declare function miniBuildPrompt(requirements: string, reworkFeedback?: string): string;
+export declare function miniReviewPrompt(implementationReport: string): string;

package/dist/tools/prompts.js

@@ -0,0 +1,182 @@
+/**
+ * Prompt templates for workflow tools.
+ *
+ * Centralised here so that tools stay lean and prompts are easy to review
+ * and tune independently.
+ */
+// ---------------------------------------------------------------------------
+// Planning
+// ---------------------------------------------------------------------------
+export function planningPrompt(requirements, modelTag) {
+    return `[MODEL_TAG:${modelTag}]
+
+Create a comprehensive implementation plan from the requirements below.
+
+Requirements:
+${requirements}
+
+Return a structured proposal with these sections:
+
+1. REQUIREMENTS_SUMMARY
+2. ARCHITECTURE_VALIDATION
+3. IMPLEMENTATION_STEPS
+4. RISKS_AND_MITIGATIONS
+5. TESTING_AND_VALIDATION_STRATEGY`;
+}
+export function synthesisPrompt(proposals) {
+    const formatted = proposals.map((p) => `--- ${p.tag} ---\n${p.raw}`).join('\n\n');
+    return `Synthesize the following model planning outputs into a consensus report.
+
+${formatted}
+
+Produce a consensus report with these sections:
+
+1. CONSENSUS_SCORE (0-100)
+2. AGREED_ELEMENTS
+3. DIVERGENT_ELEMENTS
+4. SYNTHESIZED_PLAN
+5. OPEN_QUESTIONS`;
+}
+// ---------------------------------------------------------------------------
+// Building
+// ---------------------------------------------------------------------------
+export function breakdownPrompt(finalPlan) {
+    return `Read the approved final plan below and produce atomic tasks.
+
+${finalPlan}
+
+Each task must include:
+- task id
+- title and description
+- target files
+- dependencies
+- acceptance criteria
+
+Return structured TASKS output.`;
+}
+export function validateBatchPrompt(tasks) {
+    return `Read the TASKS input below and create dependency-safe batches.
+
+${tasks}
+
+For each batch:
+1. validate architecture and codebase fit
+2. confirm or adjust file targets
+3. flag architectural risks
+4. mark whether tasks can run in parallel
+
+Return structured BATCHES output.`;
+}
+export function implementBatchPrompt(batches) {
+    return `Read the BATCHES input below and implement each batch.
+
+${batches}
+
+Execution strategy:
+1. Process batches in dependency order.
+2. Within each batch, implement tasks that have no mutual dependency edges.
+3. Tasks that share file targets or have explicit dependency edges must run sequentially.
+4. Wait for all tasks in a batch to complete before starting the next batch.
+
+For each task:
+1. implement code changes
+2. add/update tests
+3. run lint/typecheck/tests for impacted scope
+4. return a structured completion report
+
+After all batches complete, merge the per-task completion reports into a single IMPLEMENTATION_REPORT output.`;
+}
+// ---------------------------------------------------------------------------
+// Reviewing
+// ---------------------------------------------------------------------------
+export function triagePrompt(implementationReport) {
+    return `Prepare a review brief for the completed implementation.
+
+${implementationReport}
+
+Include:
+- summary of implemented changes
+- files changed
+- focus areas and risk points
+
+Return a structured REVIEW_BRIEF output.`;
+}
+export function reviewPrompt(brief, modelTag) {
+    return `[MODEL_TAG:${modelTag}]
+
+Review the current task from the triage brief below for correctness, quality, architecture validity, testing, security, and edge cases.
+
+${brief}
+
+Classify findings as critical/high/medium/low and include a confidence score (0-100).
+
+Return a structured review report.`;
+}
+export function reviewSynthesisPrompt(reviews) {
+    const formatted = reviews.map((r) => `--- ${r.tag} ---\n${r.raw}`).join('\n\n');
+    return `Read the three review inputs below and synthesize a single authoritative output.
+
+${formatted}
+
+Required output:
+1. overall confidence (0-100)
+2. consolidated deduplicated findings
+3. unresolved issues list (count)
+4. verdict APPROVED or REWORK_REQUIRED
+5. explicit rework instructions when needed`;
+}
+// ---------------------------------------------------------------------------
+// Documentation
+// ---------------------------------------------------------------------------
+export function documentPrompt(input) {
+    return `Document the approved code changes and update repository documentation.
+
+${input}
+
+Requirements:
+1. Use the latest approved review outputs and implementation artifacts as source of truth.
+2. Update all affected docs so behavior and operational steps match shipped code.
+3. If this is a rework iteration, incorporate documentation reviewer feedback from the previous documentation review.
+4. Summarize what docs were changed and why.
+
+Return a structured documentation update summary.`;
+}
+export function docReviewPrompt(docUpdate) {
+    return `Review the latest documentation pass for completeness, correctness, and repository doc consistency.
+
+${docUpdate}
+
+Required output:
+1. verdict APPROVED or REWORK_REQUIRED
+2. unresolved documentation issues (count, integer)
+3. explicit rework instructions
+4. confidence score (0-100)`;
+}
+// ---------------------------------------------------------------------------
+// Mini-loop specific
+// ---------------------------------------------------------------------------
+export function miniBuildPrompt(requirements, reworkFeedback) {
+    const rework = reworkFeedback
+        ? `\n\nPrevious review feedback to address:\n${reworkFeedback}`
+        : '';
+    return `Implement the current mini-loop requirements below.
+
+${requirements}${rework}
+
+Requirements:
+1. Apply requested code rework when present.
+2. Add or update tests for behavioral changes.
+3. Run lint/typecheck/tests only for impacted scope.
+4. Return a concise implementation report with changed files, tests run, and known open issues.`;
+}
+export function miniReviewPrompt(implementationReport) {
+    return `Review the latest mini-loop implementation output below.
+
+${implementationReport}
+
+Required output fields:
+1. CHANGE_REQUESTED=YES|NO
+2. UNRESOLVED_BLOCKING_ISSUES=<integer>
+3. CONFIDENCE=<0-100>
+4. concise rework instructions when change is requested`;
+}

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;