@kontourai/flow-agents 0.1.2 → 0.2.0

package/src/cli/init.ts

@@ -9,7 +9,7 @@ import { activateCodexLocal } from "../runtime-adapters.js";
 import { main as buildBundles } from "../tools/build-universal-bundles.js";
 import { root } from "../tools/common.js";
 
-type Runtime = "base" | "codex" | "claude-code" | "kiro";
+type Runtime = "base" | "codex" | "claude-code" | "kiro" | "opencode" | "pi";
 type TelemetrySink = "local-files" | "local-kontour-console" | "kontour-hosted-console" | "user-hosted-console" | "kontour-cloud" | "hosted-kontour-console";
 
 type InitOptions = {
@@ -30,13 +30,69 @@ const runtimeBundles: Record<Runtime, string> = {
   codex: "codex",
   "claude-code": "claude-code",
   kiro: "kiro",
+  opencode: "opencode",
+  pi: "pi",
 };
 
+// Stable marker present in every Flow Agents claude-code hook command.
+// Used by scope-collision detection to identify an existing flow-agents install.
+// Marker must be distinctive to Flow Agents generated settings. Sibling
+// products from the same lineage ship identically named hook scripts such
+// as claude-hook-adapter.js, so script filenames are NOT a safe marker.
+export const COLLISION_MARKER = "Recording Flow Agents telemetry";
+
+/**
+ * Check whether a user-level Claude Code settings file already contains
+ * Flow Agents hook commands. If it does, print a WARNING explaining that
+ * Claude Code merges user-level and project-level settings and runs ALL
+ * matching hooks, so having flow-agents in both places causes duplicate
+ * hook execution (double telemetry, double policy enforcement).
+ *
+ * The check does NOT block the install; it is advisory only.
+ *
+ * @param userSettingsFile Path to inspect (defaults to $HOME/.claude/settings.json;
+ *   overridable via FLOW_AGENTS_USER_CLAUDE_SETTINGS env var for testability).
+ * @returns true if a collision was detected, false otherwise.
+ */
+export function checkScopeCollision(userSettingsFile?: string): boolean {
+  const filePath = userSettingsFile
+    ?? process.env["FLOW_AGENTS_USER_CLAUDE_SETTINGS"]
+    ?? path.join(os.homedir(), ".claude", "settings.json");
+  if (!fs.existsSync(filePath)) return false;
+  let text: string;
+  try {
+    text = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  if (!text.includes(COLLISION_MARKER)) return false;
+  console.warn(
+    `\nWARNING: Flow Agents scope collision detected.\n` +
+    `  ${filePath}\n` +
+    `already contains Flow Agents hook commands (marker: ${COLLISION_MARKER}).\n` +
+    `\n` +
+    `Claude Code merges user-level (~/.claude/settings.json) and project-level\n` +
+    `(.claude/settings.json) settings, then runs ALL matching hooks from both files.\n` +
+    `Installing Flow Agents at the project level while it is also present at the\n` +
+    `user level will cause duplicate hook execution: telemetry events are recorded\n` +
+    `twice and policy hooks (workflow-steering, config-protection, quality-gate,\n` +
+    `stop-goal-fit) run twice per event.\n` +
+    `\n` +
+    `To resolve:\n` +
+    `  - Remove the hooks section from ${filePath} and rely solely on the\n` +
+    `    project-level .claude/settings.json installed by flow-agents init, OR\n` +
+    `  - Remove the project-level install and keep only the user-level one.\n` +
+    `\n` +
+    `The install will continue; resolve the collision before running Claude Code.\n`
+  );
+  return true;
+}
+
 function usage(): void {
   console.error(`usage: flow-agents init [options]
 
 Options:
-  --runtime base|codex|claude-code|kiro
+  --runtime base|codex|claude-code|kiro|opencode|pi
   --dest PATH
   --telemetry-sink local-files|local-kontour-console|kontour-hosted-console|user-hosted-console
   --console-url URL
@@ -52,8 +108,8 @@ Options:
 function normalizeRuntime(value: string | undefined): Runtime | undefined {
   if (!value) return undefined;
   if (value === "claude") return "claude-code";
-  if (value === "base" || value === "codex" || value === "claude-code" || value === "kiro") return value;
-  throw new Error(`unknown runtime '${value}'; expected base, codex, claude-code, or kiro`);
+  if (value === "base" || value === "codex" || value === "claude-code" || value === "kiro" || value === "opencode" || value === "pi") return value;
+  throw new Error(`unknown runtime '${value}'; expected base, codex, claude-code, kiro, opencode, or pi`);
 }
 
 function normalizeTelemetrySink(value: string): TelemetrySink {
@@ -86,7 +142,7 @@ async function questionHidden(prompt: string): Promise<string> {
     let value = "";
     const onData = (buffer: Buffer) => {
       const text = buffer.toString("utf8");
-      if (text === "\u0003") {
+      if (text === "") {
         stdout.write("\n");
         process.exit(130);
       }
@@ -97,7 +153,7 @@ async function questionHidden(prompt: string): Promise<string> {
         resolve(value);
         return;
       }
-      if (text === "\u007f") {
+      if (text === "") {
         value = value.slice(0, -1);
         return;
       }
@@ -235,6 +291,18 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
   const headless = argv.includes("--yes") || argv.includes("--headless") || !process.stdin.isTTY;
   try {
     const options = headless ? headlessOptions(argv) : await interactiveOptions(argv);
+    // Scope-collision check for claude-code: Claude Code merges user-level
+    // (~/.claude/settings.json) and project-level (.claude/settings.json) settings
+    // and runs ALL matching hooks from both files. If a user-level settings file
+    // already contains flow-agents hooks, installing at the project level will
+    // cause duplicate hook execution. We warn but do not block.
+    //
+    // Codex note: Codex hooks live in .codex/hooks.json (project-level only).
+    // There is no well-known user-level codex hooks file in our install paths,
+    // so no collision check is needed for codex.
+    if (options.runtime === "claude-code") {
+      checkScopeCollision();
+    }
     const bundle = ensureBundle(options.runtime);
     const installed = installBundle(bundle, options);
     if (installed !== 0) return installed;
@@ -245,4 +313,149 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Dogfood subcommand
+//
+// `flow-agents dogfood --runtime claude-code [--dest PATH]`
+//
+// Writes only the hook-wiring artifacts for the specified runtime into the
+// target directory (default: cwd). Unlike a full install, dogfood:
+//   - Does NOT rsync the full bundle (no agents/skills duplication).
+//   - Reads the generated settings/config from dist/<runtime>/ so the output
+//     cannot drift from what the bundle generates (DRY guarantee).
+//   - For claude-code: OMITS permissions.defaultMode and
+//     skipDangerousModePermissionPrompt (permissive defaults are for installed
+//     workspaces, not source repos).
+//   - Runs the same scope-collision warning as init.
+// ---------------------------------------------------------------------------
+
+function dogfoodUsage(): void {
+  console.error(`usage: flow-agents dogfood [options]
+
+Options:
+  --runtime claude-code|codex|opencode|pi   (required)
+  --dest PATH                               (default: cwd)
+  --yes, --headless
+`);
+}
+
+type DogfoodRuntime = "claude-code" | "codex" | "opencode" | "pi";
+
+function normalizeDogfoodRuntime(value: string | undefined): DogfoodRuntime | undefined {
+  if (!value) return undefined;
+  if (value === "claude" || value === "claude-code") return "claude-code";
+  if (value === "codex" || value === "opencode" || value === "pi") return value;
+  throw new Error(`dogfood: unsupported runtime '${value}'; expected claude-code, codex, opencode, or pi`);
+}
+
+/**
+ * Write the claude-code hook-wiring artifacts into dest.
+ * Reads dist/claude-code/.claude/settings.json (generated by build-bundles),
+ * strips the permissive-mode permission keys (defaultMode, skipDangerousModePermissionPrompt),
+ * and writes .claude/settings.json to dest.
+ */
+function dogfoodClaudeCode(bundleRoot: string, dest: string): void {
+  const sourcePath = path.join(bundleRoot, ".claude", "settings.json");
+  if (!fs.existsSync(sourcePath)) throw new Error(`dogfood: bundle settings missing: ${sourcePath}`);
+  const settings = JSON.parse(fs.readFileSync(sourcePath, "utf8")) as Record<string, unknown>;
+  // Remove permissive defaults that are only appropriate for installed workspaces.
+  // These keys must not be present in the source repo's .claude/settings.json.
+  delete settings["permissions"];
+  delete settings["skipDangerousModePermissionPrompt"];
+  const outDir = path.join(dest, ".claude");
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(path.join(outDir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+/**
+ * Write the codex hook-wiring artifacts into dest.
+ * Reads dist/codex/.codex/hooks.json and writes .codex/hooks.json to dest.
+ * The monolithic .codex/config.toml is not written here because it contains
+ * workspace settings (approvals_reviewer, features) that would override the
+ * developer's existing codex configuration. Only the hooks file is written.
+ */
+function dogfoodCodex(bundleRoot: string, dest: string): void {
+  const sourcePath = path.join(bundleRoot, ".codex", "hooks.json");
+  if (!fs.existsSync(sourcePath)) throw new Error(`dogfood: bundle hooks.json missing: ${sourcePath}`);
+  const hooks = fs.readFileSync(sourcePath, "utf8");
+  const outDir = path.join(dest, ".codex");
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(path.join(outDir, "hooks.json"), hooks, "utf8");
+}
+
+/**
+ * Write the opencode hook-wiring artifacts into dest.
+ * Reads dist/opencode/.opencode/plugins/flow-agents.js and opencode.json,
+ * and writes them into dest. These are the minimal hook-wiring files; the
+ * full skill/agent tree is not copied.
+ */
+function dogfoodOpencode(bundleRoot: string, dest: string): void {
+  const pluginSource = path.join(bundleRoot, ".opencode", "plugins", "flow-agents.js");
+  const configSource = path.join(bundleRoot, "opencode.json");
+  if (!fs.existsSync(pluginSource)) throw new Error(`dogfood: bundle plugin missing: ${pluginSource}`);
+  const pluginDir = path.join(dest, ".opencode", "plugins");
+  fs.mkdirSync(pluginDir, { recursive: true });
+  fs.copyFileSync(pluginSource, path.join(pluginDir, "flow-agents.js"));
+  // Write opencode.json only if it does not already exist to avoid clobbering
+  // any workspace-specific opencode configuration.
+  const destConfig = path.join(dest, "opencode.json");
+  if (!fs.existsSync(destConfig) && fs.existsSync(configSource)) {
+    fs.copyFileSync(configSource, destConfig);
+  }
+}
+
+/**
+ * Write the pi hook-wiring artifacts into dest.
+ * Reads dist/pi/.pi/extensions/flow-agents.ts and writes it to dest.
+ * The extension is the only hook-wiring file needed for pi.
+ */
+function dogfoodPi(bundleRoot: string, dest: string): void {
+  const extSource = path.join(bundleRoot, ".pi", "extensions", "flow-agents.ts");
+  if (!fs.existsSync(extSource)) throw new Error(`dogfood: bundle extension missing: ${extSource}`);
+  const extDir = path.join(dest, ".pi", "extensions");
+  fs.mkdirSync(extDir, { recursive: true });
+  fs.copyFileSync(extSource, path.join(extDir, "flow-agents.ts"));
+}
+
+export async function mainDogfood(argv = process.argv.slice(2)): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    dogfoodUsage();
+    return 0;
+  }
+  const args = parseArgs(argv);
+  try {
+    const runtimeRaw = flagString(args.flags, "runtime");
+    const runtime = normalizeDogfoodRuntime(runtimeRaw);
+    if (!runtime) {
+      console.error("dogfood: --runtime is required (claude-code, codex, opencode, or pi)");
+      dogfoodUsage();
+      return 2;
+    }
+    const dest = path.resolve(flagString(args.flags, "dest") ?? process.cwd());
+
+    // Ensure the bundle for the requested runtime is built.
+    const bundleRuntime: Runtime = runtime as Runtime;
+    const bundleRoot = ensureBundle(bundleRuntime);
+
+    // Scope-collision check: warn if user-level claude settings already has flow-agents.
+    // Codex: no user-level hooks file in our install paths — skip with note above.
+    if (runtime === "claude-code") {
+      checkScopeCollision();
+    }
+
+    // Write only the hook-wiring artifacts, not the full bundle.
+    fs.mkdirSync(dest, { recursive: true });
+    if (runtime === "claude-code") dogfoodClaudeCode(bundleRoot, dest);
+    else if (runtime === "codex") dogfoodCodex(bundleRoot, dest);
+    else if (runtime === "opencode") dogfoodOpencode(bundleRoot, dest);
+    else if (runtime === "pi") dogfoodPi(bundleRoot, dest);
+
+    console.log(`Flow Agents dogfood hooks wired for ${runtime} in ${dest}`);
+    return 0;
+  } catch (error) {
+    console.error(`flow-agents dogfood: ${(error as Error).message}`);
+    return 2;
+  }
+}
+
 if (import.meta.url === `file://${process.argv[1]}`) process.exit(await main());

package/src/cli/utterance-check.ts

@@ -60,6 +60,10 @@ interface SurveyMod {
   referenceUtteranceExtractor: SurveyExtractor;
 }
 
+interface AnthropicSurveyMod {
+  createAnthropicUtteranceExtractor: (options?: { model?: string; apiKey?: string }) => SurveyExtractor;
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -76,6 +80,9 @@ function usage(): void {
       "  --utterance TEXT      Utterance text to check (required unless --not-configured).",
       "  --bundle-path FILE    Trust bundle JSON file. Omit for an empty bundle (all unsupported).",
       "  --agent-id ID         Agent identifier for provenance (default: flow-agents-utterance-check).",
+      "  --extractor NAME      Extractor to use: 'reference' (default, pattern-based) or 'anthropic'",
+      "                        (model-backed, requires ANTHROPIC_API_KEY and @kontourai/survey/anthropic).",
+      "  --model MODEL         Model for the anthropic extractor (e.g. claude-haiku-4-5).",
       "  --not-configured      Skip survey call; output not_configured without error.",
       "  --strict              Exit non-zero when any badge is disputed, rejected, or unsupported.",
       "  --help                Show this help.",
@@ -116,6 +123,45 @@ async function loadSurvey(): Promise<SurveyMod | undefined> {
   }
 }
 
+/**
+ * Dynamically import @kontourai/survey/anthropic and create the Anthropic extractor.
+ * Fails open with a clear not_configured message when the key or peer dep is missing.
+ */
+async function loadAnthropicExtractor(model?: string): Promise<SurveyExtractor | { notConfigured: true; reason: string }> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    return {
+      notConfigured: true,
+      reason:
+        "anthropic extractor requires ANTHROPIC_API_KEY to be set. " +
+        "Set the environment variable or switch extractor to 'reference'.",
+    };
+  }
+  try {
+    const pkg = "@kontourai/survey/anthropic";
+    const mod = await (Function("m", "return import(m)")(pkg) as Promise<unknown>) as AnthropicSurveyMod;
+    if (typeof mod.createAnthropicUtteranceExtractor !== "function") {
+      return {
+        notConfigured: true,
+        reason:
+          "@kontourai/survey/anthropic does not export createAnthropicUtteranceExtractor. " +
+          "Update @kontourai/survey to a version that supports the anthropic extractor.",
+      };
+    }
+    const opts: { model?: string; apiKey?: string } = { apiKey };
+    if (model) opts.model = model;
+    return mod.createAnthropicUtteranceExtractor(opts);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      notConfigured: true,
+      reason:
+        `@kontourai/survey/anthropic is not available: ${msg}. ` +
+        "Install @kontourai/survey with the anthropic subpath export, or switch extractor to 'reference'.",
+    };
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Core check logic
 // ---------------------------------------------------------------------------
@@ -131,6 +177,8 @@ async function runCheck(argv: string[]): Promise<number> {
   const agentId = flagString(flags, "agent-id") ?? "flow-agents-utterance-check";
   const notConfigured = flagBool(flags, "not-configured");
   const strict = flagBool(flags, "strict");
+  const extractorName = flagString(flags, "extractor") ?? "reference";
+  const model = flagString(flags, "model");
 
   if (notConfigured) {
     const report: UtteranceReport = {
@@ -181,9 +229,31 @@ async function runCheck(argv: string[]): Promise<number> {
 
   const { surveyAgentUtterance, referenceUtteranceExtractor } = survey;
 
+  // Resolve which extractor to use.
+  let extractor: SurveyExtractor;
+  if (extractorName === "anthropic") {
+    const anthropicResult = await loadAnthropicExtractor(model);
+    if ("notConfigured" in anthropicResult) {
+      // Fail open: emit not_configured with a clear reason rather than erroring.
+      const report: UtteranceReport = {
+        status: "not_configured",
+        agent_id: agentId,
+        utterance_excerpt: excerptText(utterance),
+        statements: [],
+        summary: anthropicResult.reason,
+      };
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+      process.stderr.write(`[UtteranceCheck] not_configured: ${anthropicResult.reason}\n`);
+      return 0;
+    }
+    extractor = anthropicResult;
+  } else {
+    extractor = referenceUtteranceExtractor;
+  }
+
   let trustReport: SurveyTrustReport;
   try {
-    trustReport = await surveyAgentUtterance(utterance, referenceUtteranceExtractor, {
+    trustReport = await surveyAgentUtterance(utterance, extractor, {
       bundle,
       agentId,
     });

package/src/tools/build-universal-bundles.ts

@@ -332,6 +332,268 @@ function buildCodex(agents: Agent[]): void {
   writeText(path.join(bundle, "install.sh"), installScript("Codex", "/path/to/workspace"));
   fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
 }
+function exportOpencodeAgent(spec: Agent): string {
+  // Determine agent mode: orchestrator-like agents -> primary, others -> subagent
+  const primaryAgents = new Set(["dev"]);
+  const mode = primaryAgents.has(spec.name) ? "primary" : "subagent";
+  const prompt = appendExportNote(sanitizeText(spec.prompt, "opencode", "<bundle-root>"), "Kiro hook wiring and JSON-only runtime fields were omitted. If this agent mentions Kiro-specific scheduler or hook behavior, treat that as optional operational guidance rather than a hard dependency.");
+  const lines: string[] = ["---"];
+  lines.push(`description: ${String(spec.description ?? "").trim()}`);
+  lines.push(`mode: ${mode}`);
+  lines.push(`model: ${mapped("claude_model_map", spec.model)}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(prompt);
+  return lines.join("\n");
+}
+function exportOpencodePlugin(): string {
+  // Generate the Flow Agents opencode plugin.
+  // opencode plugins are auto-loaded from .opencode/plugins/*.js at startup.
+  //
+  // NOTE: opencode has no direct user-prompt-submit hook. For prompt-submit
+  // workflow steering, we wire the steering command behind session.created
+  // (for session-start steering context) and tool.execute.before (for
+  // policy). This is the closest reasonable approximation — documented here
+  // as an honest gap matching the codex live-hook-influence caveat pattern.
+  return `/**
+ * Flow Agents opencode plugin.
+ *
+ * Auto-loaded from .opencode/plugins/flow-agents.js at opencode startup.
+ * Delegates policy and telemetry decisions to shared scripts in scripts/hooks/
+ * using the same payload contract as the claude/codex adapters.
+ *
+ * EVENT MAPPING NOTE: opencode has no direct user-prompt-submit hook.
+ * Workflow steering (workflow-steering.js) is wired to session.created
+ * (session-start context) and tool.execute.before (per-tool policy).
+ * This approximates the UserPromptSubmit behavior in other runtimes but
+ * cannot intercept mid-session user messages before they are processed.
+ * This is an accepted gap documented here analogously to the codex
+ * live-hook-influence caveat.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { join, basename } from 'node:path';
+
+// opencode runs plugins inside its own compiled (Bun-based) binary, so
+// process.execPath points at opencode itself — spawning it with a script
+// path silently does nothing (caught by live acceptance smoke 2026-06-11).
+// Resolve a real node binary instead; fall back to PATH lookup.
+const NODE_BIN = basename(process.execPath).startsWith('node') ? process.execPath : 'node';
+
+export const FlowAgentsPlugin = async ({ project, client, $, directory, worktree }) => {
+  const root = directory || process.cwd();
+
+  // The hook scripts read the event payload from stdin; an empty stdin makes
+  // the telemetry pipeline silently skip the emit (fail-open), so every spawn
+  // must pass a payload (caught by live acceptance smoke 2026-06-11).
+  function hookPayload(eventName, detail) {
+    return JSON.stringify({ hook_event_name: eventName, cwd: root, ...(detail || {}) });
+  }
+
+  function runAdapter(adapterScript, eventName, detail, ...args) {
+    const adapterPath = join(root, 'scripts', 'hooks', adapterScript);
+    const result = spawnSync(NODE_BIN, [adapterPath, eventName, ...args], {
+      input: hookPayload(eventName, detail),
+      encoding: 'utf8',
+      cwd: root,
+      env: { ...process.env, FLOW_AGENTS_HOOK_RUNTIME: 'opencode' },
+      timeout: 30000,
+    });
+    try {
+      return JSON.parse(result.stdout || '{}');
+    } catch {
+      return { allow: true };
+    }
+  }
+
+  function runTelemetry(eventName, detail) {
+    const telemetryPath = join(root, 'scripts', 'hooks', 'opencode-telemetry-hook.js');
+    spawnSync(NODE_BIN, [telemetryPath, eventName, 'dev'], {
+      input: hookPayload(eventName, detail),
+      encoding: 'utf8',
+      cwd: root,
+      env: { ...process.env, FLOW_AGENTS_TELEMETRY_RUNTIME: 'opencode' },
+      timeout: 10000,
+    });
+  }
+
+  return {
+    'session.created': async (_input, _output) => {
+      runTelemetry('session.created');
+      // Wire workflow steering on session start for context injection
+      runAdapter('opencode-hook-adapter.js', 'session.created', null, 'workflow-steering', 'workflow-steering.js', 'default');
+    },
+    'tool.execute.before': async (input, output) => {
+      const detail = { tool: input && input.tool, args: output && output.args };
+      runTelemetry('tool.execute.before', detail);
+      const policyResult = runAdapter('opencode-hook-adapter.js', 'tool.execute.before', detail, 'config-protection', 'config-protection.js', 'default');
+      if (policyResult && policyResult.allow === false) {
+        throw new Error(policyResult.reason || 'Blocked by Flow Agents hook policy.');
+      }
+    },
+    'tool.execute.after': async (input, output) => {
+      const detail = { tool: input && input.tool };
+      runTelemetry('tool.execute.after', detail);
+      runAdapter('opencode-hook-adapter.js', 'tool.execute.after', detail, 'quality-gate', 'quality-gate.js', 'default');
+    },
+    'session.idle': async (_input, _output) => {
+      runTelemetry('session.idle');
+      runAdapter('opencode-hook-adapter.js', 'session.idle', null, 'stop-goal-fit', 'stop-goal-fit.js', 'default');
+    },
+    'session.error': async (_input, _output) => {
+      runTelemetry('session.error');
+    },
+    'session.compacted': async (_input, _output) => {
+      runTelemetry('session.compacted');
+    },
+    'permission.asked': async (_input, _output) => {
+      runTelemetry('permission.asked');
+    },
+    'file.edited': async (_input, _output) => {
+      runTelemetry('file.edited');
+    },
+  };
+};
+`;
+}
+function exportOpencodeConfig(): string {
+  // opencode's config schema requires `instructions` to be an ARRAY of
+  // instruction file paths/globs (a bare string fails validation and aborts
+  // startup). AGENTS.md is loaded natively by opencode, so the config stays
+  // minimal rather than double-including it.
+  return `${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+  }, null, 2)}\n`;
+}
+function buildOpencode(agents: Agent[]): void {
+  const bundle = path.join(dist, "opencode");
+  resetDir(bundle);
+  copySharedContent(bundle, "opencode", "<bundle-root>");
+  writeText(path.join(bundle, manifest.opencode.task_dir, ".gitkeep"), "");
+  for (const spec of agents) {
+    writeText(path.join(bundle, ".opencode/agents", `${spec.name}.md`), exportOpencodeAgent(spec));
+  }
+  for (const skill of fs.readdirSync(path.join(root, "skills"))) {
+    const skillPath = path.join(root, "skills", skill, "SKILL.md");
+    if (fs.existsSync(skillPath)) writeText(path.join(bundle, ".opencode/skills", skill, "SKILL.md"), sanitizeText(readText(skillPath), "opencode", "<bundle-root>"));
+  }
+  writeText(path.join(bundle, ".opencode/plugins/flow-agents.js"), exportOpencodePlugin());
+  writeText(path.join(bundle, "opencode.json"), exportOpencodeConfig());
+  writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("opencode", agents, manifest.opencode.task_dir));
+  writeText(path.join(bundle, "README.md"), exportTargetReadme("opencode", "bash install.sh /path/to/workspace"));
+  writeText(path.join(bundle, "install.sh"), installScript("opencode", "/path/to/workspace"));
+  fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
+function exportPiExtension(): string {
+  // Generate the Flow Agents pi extension.
+  // pi extensions are auto-discovered from .pi/extensions/*.ts (needs project trust).
+  // pi has no named-subagent registry; agents are not exported. The extension
+  // provides workflow steering (via before_agent_start context injection),
+  // tool-call policy (via tool_call event), and telemetry delegation to shared scripts.
+  return `/**
+ * Flow Agents pi extension.
+ *
+ * Auto-discovered from .pi/extensions/flow-agents.ts at startup (needs project trust).
+ * Delegates policy and telemetry to shared scripts/hooks/ using spawnSync,
+ * mirroring the payload contract used by the claude/codex adapters.
+ *
+ * NOTE: pi has no named-subagent registry. Agents are not exported for pi.
+ * Rely on AGENTS.md + skills + this extension for workflow guidance.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { spawnSync } from "node:child_process";
+import { join, basename } from "node:path";
+
+// pi may run extensions under a non-node runtime (Bun), where process.execPath
+// is not a node binary and spawning it with a script path silently fails.
+// Same failure class the opencode live smoke caught on 2026-06-11.
+const NODE_BIN = basename(process.execPath).startsWith("node") ? process.execPath : "node";
+
+export default function (pi: ExtensionAPI) {
+  const root = process.cwd();
+
+  function runAdapter(adapterScript: string, eventName: string, hookId: string, relScript: string): { allow: boolean; context?: string; reason?: string } {
+    const adapterPath = join(root, "scripts", "hooks", adapterScript);
+    const payload = JSON.stringify({ hook_event_name: eventName, cwd: root });
+    const result = spawnSync(NODE_BIN, [adapterPath, eventName, hookId, relScript, "default"], {
+      input: payload,
+      encoding: "utf8",
+      cwd: root,
+      env: { ...process.env, FLOW_AGENTS_HOOK_RUNTIME: "pi" },
+      timeout: 30000,
+    });
+    try {
+      return JSON.parse(result.stdout || "{}") as { allow: boolean; context?: string; reason?: string };
+    } catch {
+      return { allow: true };
+    }
+  }
+
+  function runTelemetry(eventName: string): void {
+    const telemetryPath = join(root, "scripts", "hooks", "pi-telemetry-hook.js");
+    const payload = JSON.stringify({ hook_event_name: eventName, cwd: root });
+    spawnSync(NODE_BIN, [telemetryPath, eventName, "dev"], {
+      input: payload,
+      encoding: "utf8",
+      cwd: root,
+      env: { ...process.env, FLOW_AGENTS_TELEMETRY_RUNTIME: "pi" },
+      timeout: 10000,
+    });
+  }
+
+  pi.on("session_start", async (_event, _ctx) => {
+    runTelemetry("session_start");
+  });
+
+  pi.on("before_agent_start", async (event, _ctx) => {
+    runTelemetry("before_agent_start");
+    // Inject workflow steering context at agent start
+    const result = runAdapter("pi-hook-adapter.js", "before_agent_start", "workflow-steering", "workflow-steering.js");
+    if (result.context) {
+      return {
+        systemPrompt: event.systemPrompt + "\\n\\n" + result.context,
+      };
+    }
+  });
+
+  pi.on("tool_call", async (event, _ctx) => {
+    runTelemetry("tool_call");
+    const result = runAdapter("pi-hook-adapter.js", "tool_call", "config-protection", "config-protection.js");
+    if (result && result.allow === false) {
+      return { block: true, reason: result.reason || "Blocked by Flow Agents hook policy." };
+    }
+  });
+
+  pi.on("tool_result", async (_event, _ctx) => {
+    runTelemetry("tool_result");
+    runAdapter("pi-hook-adapter.js", "tool_result", "quality-gate", "quality-gate.js");
+  });
+
+  pi.on("session_shutdown", async (_event, _ctx) => {
+    runTelemetry("session_shutdown");
+    runAdapter("pi-hook-adapter.js", "session_shutdown", "stop-goal-fit", "stop-goal-fit.js");
+  });
+}
+`;
+}
+function buildPi(agents: Agent[]): void {
+  const bundle = path.join(dist, "pi");
+  resetDir(bundle);
+  copySharedContent(bundle, "pi", "<bundle-root>");
+  writeText(path.join(bundle, manifest.pi.task_dir, ".gitkeep"), "");
+  // pi has no named-subagent registry; agents are left canonical/unexported.
+  // Skills are exported to .pi/skills/ (direct .md files supported in that dir).
+  for (const skill of fs.readdirSync(path.join(root, "skills"))) {
+    const skillPath = path.join(root, "skills", skill, "SKILL.md");
+    if (fs.existsSync(skillPath)) writeText(path.join(bundle, ".pi/skills", skill, "SKILL.md"), sanitizeText(readText(skillPath), "pi", "<bundle-root>"));
+  }
+  writeText(path.join(bundle, ".pi/extensions/flow-agents.ts"), exportPiExtension());
+  writeText(path.join(bundle, "AGENTS.md"), exportRootAgentsMd("pi", agents, manifest.pi.task_dir));
+  writeText(path.join(bundle, "README.md"), exportTargetReadme("pi", "bash install.sh /path/to/workspace"));
+  writeText(path.join(bundle, "install.sh"), installScript("pi", "/path/to/workspace"));
+  fs.chmodSync(path.join(bundle, "install.sh"), 0o755);
+}
 function buildCatalog(agents: Agent[]): Record<string, unknown> {
   const kitsCatalog = path.join(root, "kits/catalog.json");
   return {
@@ -350,6 +612,8 @@ export function main(): number {
   buildKiro(agents);
   buildClaudeCode(agents);
   buildCodex(agents);
+  buildOpencode(agents);
+  buildPi(agents);
   writeText(path.join(dist, "catalog.json"), `${JSON.stringify(buildCatalog(agents), null, 2)}\n`);
   writeText(path.join(dist, "README.md"), "# Universal Bundles\n\nRun `npm run build:bundles` from the repo root to regenerate these bundles.\n");
   console.log("Built bundles:");
@@ -357,6 +621,8 @@ export function main(): number {
   console.log(" - dist/kiro");
   console.log(" - dist/claude-code");
   console.log(" - dist/codex");
+  console.log(" - dist/opencode");
+  console.log(" - dist/pi");
   if (printDiagnostics && dropDiagnostics.length) {
     console.error("Export sanitization diagnostics:");
     for (const item of dropDiagnostics) console.error(` - ${item}`);