@syntesseraai/opencode-feature-factory 0.6.20 → 0.7.0

package/dist/tools/parsers.js

@@ -0,0 +1,142 @@
+/**
+ * Response parsers that extract structured data from LLM text output.
+ *
+ * These are intentionally tolerant — they fall back to raw text when
+ * structured sections cannot be found. The gate evaluators work on
+ * the parsed numbers/booleans, not on freeform text.
+ */
+// ---------------------------------------------------------------------------
+// Generic helpers
+// ---------------------------------------------------------------------------
+/** Extract the first integer found after a label in the text. */
+export function extractNumber(text, label, fallback = 0) {
+    // Try patterns like "CONSENSUS_SCORE: 85", "confidence: 92", "CONFIDENCE=95"
+    const patterns = [
+        new RegExp(`${label}[=:\\s]+([0-9]+)`, 'i'),
+        new RegExp(`${label}[^0-9]*([0-9]+)`, 'i'),
+    ];
+    for (const re of patterns) {
+        const m = text.match(re);
+        if (m)
+            return parseInt(m[1], 10);
+    }
+    return fallback;
+}
+/** Extract text between two section headers (markdown-style). */
+export function extractSection(text, heading) {
+    // Try numbered list style: "1. HEADING" or "## HEADING" or "**HEADING**"
+    const patterns = [
+        new RegExp(`(?:^|\\n)(?:\\d+\\.\\s*)?\\*{0,2}${heading}\\*{0,2}[:\\s]*\\n([\\s\\S]*?)(?=\\n(?:\\d+\\.\\s*)?\\*{0,2}[A-Z_]+|$)`, 'i'),
+        new RegExp(`(?:^|\\n)#{1,3}\\s*${heading}[:\\s]*\\n([\\s\\S]*?)(?=\\n#{1,3}\\s|$)`, 'i'),
+    ];
+    for (const re of patterns) {
+        const m = text.match(re);
+        if (m)
+            return m[1].trim();
+    }
+    return '';
+}
+/** Check if a YES/NO field is YES. */
+export function isYes(text, label) {
+    const m = text.match(new RegExp(`${label}[=:\\s]*(YES|NO)`, 'i'));
+    return m ? m[1].toUpperCase() === 'YES' : false;
+}
+// ---------------------------------------------------------------------------
+// Planning parsers
+// ---------------------------------------------------------------------------
+export function parsePlanProposal(tag, raw) {
+    return {
+        tag,
+        requirementsSummary: extractSection(raw, 'REQUIREMENTS_SUMMARY') || raw.slice(0, 200),
+        architectureValidation: extractSection(raw, 'ARCHITECTURE_VALIDATION'),
+        implementationSteps: extractSection(raw, 'IMPLEMENTATION_STEPS'),
+        risksAndMitigations: extractSection(raw, 'RISKS_AND_MITIGATIONS'),
+        testingStrategy: extractSection(raw, 'TESTING_AND_VALIDATION_STRATEGY'),
+        raw,
+    };
+}
+export function parseConsensusPlan(raw) {
+    return {
+        consensusScore: extractNumber(raw, 'CONSENSUS_SCORE'),
+        agreedElements: extractSection(raw, 'AGREED_ELEMENTS'),
+        divergentElements: extractSection(raw, 'DIVERGENT_ELEMENTS'),
+        synthesizedPlan: extractSection(raw, 'SYNTHESIZED_PLAN'),
+        openQuestions: extractSection(raw, 'OPEN_QUESTIONS'),
+        raw,
+    };
+}
+// ---------------------------------------------------------------------------
+// Review parsers
+// ---------------------------------------------------------------------------
+export function parseReviewReport(tag, raw) {
+    return {
+        tag,
+        findings: raw,
+        confidence: extractNumber(raw, 'confidence'),
+        raw,
+    };
+}
+export function parseReviewSynthesis(raw) {
+    const confidence = extractNumber(raw, 'confidence');
+    const unresolvedIssues = extractNumber(raw, 'unresolved');
+    const verdictMatch = raw.match(/verdict[=:\s]*(APPROVED|REWORK_REQUIRED)/i);
+    const verdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
+    const reworkSection = extractSection(raw, 'rework');
+    return {
+        overallConfidence: confidence,
+        consolidatedFindings: raw,
+        unresolvedIssues,
+        verdict,
+        reworkInstructions: reworkSection || undefined,
+        raw,
+    };
+}
+// ---------------------------------------------------------------------------
+// Doc parsers
+// ---------------------------------------------------------------------------
+export function parseDocUpdate(raw) {
+    return {
+        filesChanged: [], // The LLM lists these in the raw text; we keep the raw for the gate
+        rationale: raw,
+        raw,
+    };
+}
+export function parseDocReview(raw) {
+    const confidence = extractNumber(raw, 'confidence');
+    const unresolvedIssues = extractNumber(raw, 'unresolved');
+    const verdictMatch = raw.match(/verdict[=:\s]*(APPROVED|REWORK_REQUIRED)/i);
+    const verdict = (verdictMatch?.[1]?.toUpperCase() === 'APPROVED' ? 'APPROVED' : 'REWORK_REQUIRED');
+    const reworkSection = extractSection(raw, 'rework');
+    return {
+        verdict,
+        unresolvedIssues,
+        confidence,
+        reworkInstructions: reworkSection || undefined,
+        raw,
+    };
+}
+// ---------------------------------------------------------------------------
+// Implementation parsers
+// ---------------------------------------------------------------------------
+export function parseImplementationReport(raw) {
+    return {
+        filesChanged: [],
+        testsRun: [],
+        testsPassed: !raw.toLowerCase().includes('failed'),
+        openIssues: [],
+        raw,
+    };
+}
+// ---------------------------------------------------------------------------
+// Mini-loop review parser
+// ---------------------------------------------------------------------------
+export function parseMiniReview(raw) {
+    return {
+        confidence: extractNumber(raw, 'CONFIDENCE'),
+        changeRequested: isYes(raw, 'CHANGE_REQUESTED'),
+        unresolvedIssues: extractNumber(raw, 'UNRESOLVED_BLOCKING_ISSUES') ||
+            extractNumber(raw, 'UNRESOLVED_DOCUMENTATION_ISSUES'),
+        reworkInstructions: extractSection(raw, 'rework') || undefined,
+        raw,
+    };
+}

package/dist/tools/pipeline.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { type Client } from '../workflow/orchestrator.js';
+export declare function createPipelineTool(client: Client): {
+    description: string;
+    args: {
+        requirements: import("zod").ZodString;
+        planning_models: import("zod").ZodOptional<import("zod").ZodString>;
+        review_models: import("zod").ZodOptional<import("zod").ZodString>;
+        orchestrator_model: import("zod").ZodOptional<import("zod").ZodString>;
+        build_model: import("zod").ZodOptional<import("zod").ZodString>;
+        validate_model: import("zod").ZodOptional<import("zod").ZodString>;
+        doc_model: import("zod").ZodOptional<import("zod").ZodString>;
+        doc_review_model: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        requirements: string;
+        planning_models?: string | undefined;
+        review_models?: string | undefined;
+        orchestrator_model?: string | undefined;
+        build_model?: string | undefined;
+        validate_model?: string | undefined;
+        doc_model?: string | undefined;
+        doc_review_model?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

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`;
+}