@syntesseraai/opencode-feature-factory 0.10.1 → 0.10.3

package/dist/tools/prompts.d.ts

@@ -21,4 +21,5 @@ export declare function reviewSynthesisPrompt(reviews: Array<{
 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 ciFixPrompt(requirements: string, ciOutput: string): string;
 export declare function miniReviewPrompt(implementationReport: string): string;

package/dist/tools/prompts.js

@@ -169,6 +169,22 @@ Requirements:
 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 ciFixPrompt(requirements, ciOutput) {
+    return `The CI checks (ff-ci.sh) failed after your implementation. Fix the issues identified below.
+
+Original requirements:
+${requirements}
+
+CI failure output:
+\`\`\`
+${ciOutput}
+\`\`\`
+
+Requirements:
+1. Fix all failing checks (lint, typecheck, build, tests).
+2. Do not remove or skip tests — fix the underlying issues.
+3. Return a concise implementation report with changed files and what was fixed.`;
+}
 export function miniReviewPrompt(implementationReport) {
     return `Review the latest mini-loop implementation output below.
 

package/dist/workflow/ci-runner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CI runner utility for workflow tools.
+ *
+ * Executes `ff-ci.sh` in a subprocess and returns a structured result.
+ * Reuses sanitizeOutput / truncateOutput from stop-quality-gate.ts for
+ * consistent secret redaction and output trimming.
+ */
+export interface CIResult {
+    passed: boolean;
+    output: string;
+    timedOut: boolean;
+}
+/**
+ * Check whether `ff-ci.sh` exists at the given directory root.
+ * Never throws — returns `false` on any error.
+ */
+export declare function ciScriptExists(directory: string): Promise<boolean>;
+/**
+ * Execute `ff-ci.sh` from the given directory and return a structured result.
+ * Never throws — returns a failure result on any error.
+ */
+export declare function runCI(directory: string): Promise<CIResult>;

package/dist/workflow/ci-runner.js

@@ -0,0 +1,91 @@
+/**
+ * CI runner utility for workflow tools.
+ *
+ * Executes `ff-ci.sh` in a subprocess and returns a structured result.
+ * Reuses sanitizeOutput / truncateOutput from stop-quality-gate.ts for
+ * consistent secret redaction and output trimming.
+ */
+import { sanitizeOutput, truncateOutput } from '../stop-quality-gate.js';
+const CI_TIMEOUT_MS = 300_000; // 5 minutes
+/**
+ * Check whether `ff-ci.sh` exists at the given directory root.
+ * Never throws — returns `false` on any error.
+ */
+export async function ciScriptExists(directory) {
+    try {
+        const ciPath = `${directory}/ff-ci.sh`;
+        // eslint-disable-next-line no-undef
+        const proc = Bun.spawn(['test', '-f', ciPath], {
+            cwd: directory,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        await proc.exited;
+        return proc.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute `ff-ci.sh` from the given directory and return a structured result.
+ * Never throws — returns a failure result on any error.
+ */
+export async function runCI(directory) {
+    try {
+        const ciPath = `${directory}/ff-ci.sh`;
+        // eslint-disable-next-line no-undef
+        const proc = Bun.spawn(['bash', ciPath], {
+            cwd: directory,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        let timedOut = false;
+        let timeoutId = null;
+        let forceKillTimeoutId = null;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill('SIGTERM');
+                forceKillTimeoutId = setTimeout(() => {
+                    try {
+                        proc.kill('SIGKILL');
+                    }
+                    catch {
+                        // Process already terminated
+                    }
+                }, 5000);
+                resolve();
+            }, CI_TIMEOUT_MS);
+        });
+        await Promise.race([proc.exited, timeoutPromise]);
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        if (forceKillTimeoutId)
+            clearTimeout(forceKillTimeoutId);
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        let output;
+        let passed;
+        if (timedOut) {
+            output =
+                `CI execution timed out after ${CI_TIMEOUT_MS / 1000} seconds\n\n${stdout}\n${stderr}`.trim();
+            passed = false;
+        }
+        else {
+            output = stdout + (stderr ? `\n${stderr}` : '');
+            passed = proc.exitCode === 0;
+        }
+        // Sanitize secrets and truncate for prompt safety
+        output = truncateOutput(sanitizeOutput(output));
+        return { passed, output, timedOut };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            passed: false,
+            output: `CI runner error: ${message}`,
+            timedOut: false,
+        };
+    }
+}

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

@@ -18,6 +18,9 @@ import type { NamedModel, ModelId } from './types.js';
 export type Client = {
     session: {
         create(options: {
+            query?: {
+                directory?: string;
+            };
             body?: {
                 parentID?: string;
                 title?: string;
@@ -28,6 +31,9 @@ export type Client = {
             };
         }>;
         prompt(options: {
+            query?: {
+                directory?: string;
+            };
             path: {
                 id: string;
             };
@@ -53,6 +59,9 @@ export type Client = {
             };
         }>;
         promptAsync(options: {
+            query?: {
+                directory?: string;
+            };
             path: {
                 id: string;
             };
@@ -100,6 +109,14 @@ export declare function extractText(parts: Array<{
     text?: string;
     [k: string]: unknown;
 }>): string;
+export interface SessionContext {
+    sessionId: string;
+    directory?: string;
+}
+export declare function createRunParentSession(client: Client, callerSessionId: string, options?: {
+    title?: string;
+    directory?: string;
+}): Promise<SessionContext>;
 export interface FanOutResult {
     tag: string;
     raw: string;
@@ -111,13 +128,13 @@ export interface FanOutResult {
  * 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[]>;
+export declare function fanOut(client: Client, context: SessionContext, 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?: {
+export declare function promptSession(client: Client, context: SessionContext, prompt: string, options?: {
     model?: ModelId;
     agent?: string;
     title?: string;
@@ -125,8 +142,12 @@ export declare function promptSession(client: Client, parentSessionId: string, p
 /**
  * Send a visible notification message to the parent session via `promptAsync`.
  *
- * Uses `noReply: true` so the message appears in the TUI as a chat message
- * without triggering an LLM turn. Errors are swallowed — notification
- * delivery must never break the pipeline.
+ * By default uses `noReply: true` so the message appears in the TUI as a chat
+ * message without triggering an LLM turn. Pass `noReply: false` for terminal
+ * messages (completion reports, errors) so the LLM can validate the outcome.
+ *
+ * Errors are swallowed — notification delivery must never break the pipeline.
  */
-export declare function notifyParent(client: Client, sessionId: string, agent: string | undefined, message: string): Promise<void>;
+export declare function notifyParent(client: Client, context: SessionContext, agent: string | undefined, message: string, options?: {
+    noReply?: boolean;
+}): Promise<void>;

package/dist/workflow/fan-out.js

@@ -19,6 +19,29 @@ export function extractText(parts) {
         .map((p) => p.text)
         .join('\n');
 }
+function withDirectory(directory) {
+    if (!directory) {
+        return undefined;
+    }
+    return { directory };
+}
+export async function createRunParentSession(client, callerSessionId, options) {
+    const session = await client.session.create({
+        query: withDirectory(options?.directory),
+        body: {
+            parentID: callerSessionId,
+            title: options?.title,
+        },
+    });
+    const runParentId = session.data?.id;
+    if (!runParentId) {
+        throw new Error('Failed to create run parent session');
+    }
+    return {
+        sessionId: runParentId,
+        directory: options?.directory,
+    };
+}
 // ---------------------------------------------------------------------------
 // Isolated session helper
 // ---------------------------------------------------------------------------
@@ -28,11 +51,12 @@ export function extractText(parts) {
  * 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) {
+async function promptInChildSession(client, context, prompt, options) {
     // 1. Create an isolated child session
     const session = await client.session.create({
+        query: withDirectory(context.directory),
         body: {
-            parentID: parentSessionId,
+            parentID: context.sessionId,
             title: options?.title,
         },
     });
@@ -53,6 +77,7 @@ async function promptInChildSession(client, parentSessionId, prompt, options) {
         body.agent = options.agent;
     }
     const response = await client.session.prompt({
+        query: withDirectory(context.directory),
         path: { id: childId },
         body,
     });
@@ -66,9 +91,9 @@ async function promptInChildSession(client, parentSessionId, prompt, options) {
  * 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) {
+export async function fanOut(client, context, models, buildPrompt, agent) {
     const results = await Promise.all(models.map(async (nm) => {
-        const raw = await promptInChildSession(client, parentSessionId, buildPrompt(nm.tag), {
+        const raw = await promptInChildSession(client, context, buildPrompt(nm.tag), {
             model: nm.model,
             agent,
             title: `ff-fanout-${nm.tag}`,
@@ -85,8 +110,8 @@ export async function fanOut(client, parentSessionId, models, buildPrompt, agent
  *
  * 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);
+export async function promptSession(client, context, prompt, options) {
+    return promptInChildSession(client, context, prompt, options);
 }
 // ---------------------------------------------------------------------------
 // Parent session notification helper
@@ -94,21 +119,24 @@ export async function promptSession(client, parentSessionId, prompt, options) {
 /**
  * Send a visible notification message to the parent session via `promptAsync`.
  *
- * Uses `noReply: true` so the message appears in the TUI as a chat message
- * without triggering an LLM turn. Errors are swallowed — notification
- * delivery must never break the pipeline.
+ * By default uses `noReply: true` so the message appears in the TUI as a chat
+ * message without triggering an LLM turn. Pass `noReply: false` for terminal
+ * messages (completion reports, errors) so the LLM can validate the outcome.
+ *
+ * Errors are swallowed — notification delivery must never break the pipeline.
  */
-export async function notifyParent(client, sessionId, agent, message) {
+export async function notifyParent(client, context, agent, message, options) {
     try {
         const body = {
-            noReply: true,
+            noReply: options?.noReply ?? true,
             parts: [{ type: 'text', text: message }],
         };
         if (agent) {
             body.agent = agent;
         }
         await client.session.promptAsync({
-            path: { id: sessionId },
+            query: withDirectory(context.directory),
+            path: { id: context.sessionId },
             body,
         });
     }

package/dist/workflow/orchestrator.d.ts

@@ -4,6 +4,7 @@
  * Re-exports the fan-out, gate, and type modules as a single convenient
  * entry-point for tool implementations.
  */
-export { fanOut, promptSession, extractText, notifyParent, type Client } from './fan-out.js';
+export { fanOut, promptSession, extractText, notifyParent, createRunParentSession, type Client, type SessionContext, } from './fan-out.js';
 export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export { runCI, ciScriptExists } from './ci-runner.js';
 export * from './types.js';

package/dist/workflow/orchestrator.js

@@ -4,6 +4,7 @@
  * Re-exports the fan-out, gate, and type modules as a single convenient
  * entry-point for tool implementations.
  */
-export { fanOut, promptSession, extractText, notifyParent } from './fan-out.js';
+export { fanOut, promptSession, extractText, notifyParent, createRunParentSession, } from './fan-out.js';
 export { evaluatePlanningGate, evaluateReviewGate, evaluateDocGate, evaluateMiniLoopImplGate, evaluateMiniLoopDocGate, } from './gate-evaluator.js';
+export { runCI, ciScriptExists } from './ci-runner.js';
 export * from './types.js';

package/dist/workflow/run-isolation.d.ts

@@ -0,0 +1,13 @@
+export interface WorktreeOptions {
+    enabled?: boolean;
+    parentDirectory?: string;
+}
+export interface RunDirectoryContext {
+    runId: string;
+    runDirectory: string;
+    worktreeEnabled: boolean;
+    worktreePath?: string;
+    repoRoot?: string;
+}
+export declare function resolveRunDirectory(toolTag: 'pipeline' | 'mini-loop', worktree: WorktreeOptions | undefined, cwd?: string): Promise<RunDirectoryContext>;
+export declare function cleanupWorktree(ctx: RunDirectoryContext): Promise<void>;

package/dist/workflow/run-isolation.js

@@ -0,0 +1,77 @@
+import { mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+const UNSAFE_WORKTREE_PARENT_DIRS = new Set(['/', '/etc']);
+function assertSafeParentDirectory(parentDirectory) {
+    const normalized = resolve(parentDirectory);
+    if (UNSAFE_WORKTREE_PARENT_DIRS.has(normalized)) {
+        throw new Error(`Unsafe worktree_parent_dir: ${parentDirectory}. Choose a dedicated writable path.`);
+    }
+}
+function resolveParentDirectory(cwd, parentDirectory) {
+    // Trust model: worktree_parent_dir is caller-controlled and can point anywhere
+    // on the local filesystem. We allow flexible absolute/relative paths but reject
+    // obviously unsafe system locations where accidental cleanup would be dangerous.
+    if (!parentDirectory || parentDirectory.trim().length === 0) {
+        return join(cwd, '.feature-factory', 'worktrees');
+    }
+    const resolvedParent = isAbsolute(parentDirectory)
+        ? parentDirectory
+        : resolve(cwd, parentDirectory);
+    assertSafeParentDirectory(resolvedParent);
+    return resolvedParent;
+}
+async function runGit(args, cwd) {
+    // eslint-disable-next-line no-undef
+    const proc = Bun.spawn(['git', ...args], {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+    const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ]);
+    if (proc.exitCode !== 0) {
+        const detail = stderr.trim() || stdout.trim() || `git ${args.join(' ')} failed`;
+        throw new Error(detail);
+    }
+    return stdout.trim();
+}
+export async function resolveRunDirectory(toolTag, worktree, cwd = process.cwd()) {
+    const runId = `${toolTag}-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    if (!worktree?.enabled) {
+        return {
+            runId,
+            runDirectory: cwd,
+            worktreeEnabled: false,
+        };
+    }
+    const repoRoot = await runGit(['rev-parse', '--show-toplevel'], cwd);
+    const head = await runGit(['rev-parse', '--verify', 'HEAD'], repoRoot);
+    const parentDirectory = resolveParentDirectory(repoRoot, worktree.parentDirectory);
+    await mkdir(parentDirectory, { recursive: true });
+    const repoName = basename(repoRoot);
+    const worktreePath = join(parentDirectory, `${repoName}-${runId}`);
+    await runGit(['worktree', 'add', '--detach', worktreePath, head], repoRoot);
+    return {
+        runId,
+        runDirectory: worktreePath,
+        worktreeEnabled: true,
+        worktreePath,
+        repoRoot,
+    };
+}
+export async function cleanupWorktree(ctx) {
+    if (!ctx.worktreeEnabled || !ctx.worktreePath) {
+        return;
+    }
+    const gitCwd = ctx.repoRoot ?? ctx.runDirectory;
+    try {
+        await runGit(['worktree', 'remove', '--force', ctx.worktreePath], gitCwd);
+    }
+    catch (error) {
+        console.warn('[feature-factory] Failed to cleanup run worktree:', error);
+    }
+}

package/package.json

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