@ranker/raxflow 0.2.0

package/src/bridge-adapter-templates.ts

@@ -0,0 +1,181 @@
+import { HostTarget } from "./host-init-templates.js";
+
+function vendorCallFunction(target: HostTarget): string {
+  if (target === "claude-code") return "callClaudeCodeRuntime";
+  if (target === "codex") return "callCodexRuntime";
+  if (target === "opencode") return "callOpenCodeRuntime";
+  if (target === "kilo") return "callKiloRuntime";
+  return "callGenericHostRuntime";
+}
+
+function vendorNotes(target: HostTarget): string {
+  if (target === "claude-code") {
+    return [
+      "// Claude Code integration notes:",
+      "// - Map `payload.action` to Claude Code message/runtime API.",
+      "// - Ensure structured mode returns strict JSON object, not markdown.",
+      ""
+    ].join("\n");
+  }
+  if (target === "codex") {
+    return [
+      "// Codex integration notes:",
+      "// - Map payload.options.model to your Codex runtime model selector.",
+      "// - For callStructured, return parsed JSON object only.",
+      ""
+    ].join("\n");
+  }
+  if (target === "opencode") {
+    return [
+      "// OpenCode integration notes:",
+      "// - Connect to OpenCode model invocation API/SDK.",
+      "// - Preserve latency and model name in response when possible.",
+      ""
+    ].join("\n");
+  }
+  if (target === "kilo") {
+    return [
+      "// Kilo integration notes:",
+      "// - Route both actions through Kilo's model runtime.",
+      "// - Handle model fallback inside runtime wrapper if supported.",
+      ""
+    ].join("\n");
+  }
+  return [
+    "// Generic host integration notes:",
+    "// - Replace runtime call with your environment-specific function.",
+    "// - Keep response aligned with HostBridgeResponse schema.",
+    ""
+  ].join("\n");
+}
+
+export function renderBridgeAdapter(target: HostTarget): string {
+  const runtimeFn = vendorCallFunction(target);
+  return [
+    "#!/usr/bin/env node",
+    "",
+    "/**",
+    ` * RAX-FLOW bridge adapter scaffold for ${target}.`,
+    " *",
+    " * Input : HostBridgeRequest JSON on stdin",
+    " * Output: HostBridgeResponse JSON on stdout",
+    " */",
+    "",
+    "import { readFileSync } from \"node:fs\";",
+    "import path from \"node:path\";",
+    "",
+    "function readStdin() {",
+    "  return new Promise((resolve) => {",
+    "    let data = \"\";",
+    "    process.stdin.setEncoding(\"utf8\");",
+    "    process.stdin.on(\"data\", (chunk) => { data += chunk; });",
+    "    process.stdin.on(\"end\", () => resolve(data));",
+    "  });",
+    "}",
+    "",
+    "function safeJsonParse(text) {",
+    "  try { return JSON.parse(text); } catch { return null; }",
+    "}",
+    "",
+    "function normalizeError(error) {",
+    "  if (!error) return \"unknown_error\";",
+    "  if (typeof error === \"string\") return error;",
+    "  return error.message || String(error);",
+    "}",
+    "",
+    "function isStructuredPayload(obj) {",
+    "  return obj && typeof obj === \"object\" &&",
+    "    typeof obj.agent === \"string\" &&",
+    "    typeof obj.success === \"boolean\" &&",
+    "    typeof obj.confidence === \"number\" &&",
+    "    Array.isArray(obj.risks) &&",
+    "    Array.isArray(obj.logs) &&",
+    "    obj.data && typeof obj.data === \"object\";",
+    "}",
+    "",
+    "function loadRuntimeConfig() {",
+    "  const file = path.join(process.cwd(), '.rax-flow', 'host-init', '" + target + "', 'bridge-runtime-config.json');",
+    "  try {",
+    "    return JSON.parse(readFileSync(file, 'utf8'));",
+    "  } catch {",
+    "    return {",
+    "      vendor: '" + target + "',",
+    "      model: 'host-managed',",
+    "      endpoint: null,",
+    "      authEnv: null,",
+    "      structuredMode: 'json',",
+    "      responseStrict: true,",
+    "      timeoutMs: 20000",
+    "    };",
+    "  }",
+    "}",
+    "",
+    vendorNotes(target),
+    "// callHostModel is the bridge interface for runtime calls",
+    `async function ${runtimeFn}(payload, runtimeConfig) {`,
+    "  // TODO: implement real runtime call for this vendor.",
+    "  // payload.action = callModel | callStructured",
+    "  // runtimeConfig can provide endpoint/auth/model/runtime settings.",
+    "  if (payload.action === 'callStructured') {",
+    "    return {",
+    "      ok: true,",
+    "      model: runtimeConfig.model || payload.options?.model || 'host-managed',",
+    "      latencyMs: 8,",
+    "      output: {",
+    "        agent: 'VendorBridgeTemplate',",
+    "        success: true,",
+    "        confidence: 0.73,",
+    "        risks: [],",
+    "        logs: ['replace with real vendor runtime response'],",
+    "        data: { summary: 'template structured output', nextAction: 'continue' }",
+    "      }",
+    "    };",
+    "  }",
+    "  return {",
+    "    ok: true,",
+    "    model: runtimeConfig.model || payload.options?.model || 'host-managed',",
+    "    latencyMs: 8,",
+    "    output: `template-text:${String(payload.prompt || '').slice(0, 220)}`",
+    "  };",
+    "}",
+    "",
+    "async function main() {",
+    "  const input = await readStdin();",
+    "  const payload = safeJsonParse(input);",
+    "  if (!payload || payload.version !== 1 || !payload.action) {",
+    "    process.stdout.write(JSON.stringify({ ok: false, error: 'invalid_payload' }));",
+    "    return;",
+    "  }",
+    "",
+    "  const runtimeConfig = loadRuntimeConfig();",
+    "",
+    "  try {",
+    `    const response = await ${runtimeFn}(payload, runtimeConfig);`,
+    "    if (payload.action === 'callStructured' && runtimeConfig.responseStrict) {",
+    "      if (!response || !isStructuredPayload(response.output)) {",
+    "        process.stdout.write(JSON.stringify({",
+    "          ok: false,",
+    "          error: 'structured_output_invalid',",
+    "          details: 'Ensure output contains agent/success/confidence/risks/logs/data',",
+    "        }));",
+    "        return;",
+    "      }",
+    "    }",
+    "    process.stdout.write(JSON.stringify(response));",
+    "  } catch (error) {",
+    "    process.stdout.write(JSON.stringify({ ok: false, error: `bridge_exception:${normalizeError(error)}` }));",
+    "  }",
+    "}",
+    "",
+    "main();",
+    ""
+  ].join("\n");
+}
+
+export function bridgeAdapterFilename(target: HostTarget): string {
+  if (target === "claude-code") return "bridge-adapter-claude-code.mjs";
+  if (target === "codex") return "bridge-adapter-codex.mjs";
+  if (target === "opencode") return "bridge-adapter-opencode.mjs";
+  if (target === "kilo") return "bridge-adapter-kilo.mjs";
+  return "bridge-adapter-generic.mjs";
+}

package/src/bridge-test.ts

@@ -0,0 +1,107 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { c } from "./styles.js";
+import { parseHostTarget } from "./host-init-templates.js";
+
+interface BridgeTestOptions {
+  cwd: string;
+  target?: string;
+}
+
+function parseShellCommand(input: string): { command: string; args: string[] } {
+  const parts = input.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [];
+  if (parts.length === 0) {
+    throw new Error("invalid_bridge_command");
+  }
+  const [command, ...rawArgs] = parts;
+  const args = rawArgs.map((arg) => arg.replace(/^"|"$/g, ""));
+  return { command: command!, args };
+}
+
+async function runCommand(commandSpec: string, payload: unknown): Promise<{ code: number; stdout: string; stderr: string }> {
+  const { command, args } = parseShellCommand(commandSpec);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+
+    child.on("error", (error) => reject(error));
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+
+    child.stdin.write(JSON.stringify(payload));
+    child.stdin.end();
+  });
+}
+
+export async function runBridgeTest(options: BridgeTestOptions): Promise<number> {
+  const target = parseHostTarget(options.target);
+  const baseDir = path.join(options.cwd, ".rax-flow", "host-init", target);
+  const manifestFile = path.join(baseDir, "host-manifest.json");
+  const smokeFile = path.join(baseDir, "bridge-smoke-test.json");
+
+  let manifest: { bridgeCommand?: string };
+  let smokePayload: unknown;
+
+  try {
+    manifest = JSON.parse(await readFile(manifestFile, "utf8")) as { bridgeCommand?: string };
+  } catch {
+    console.error(c.red(`Missing host manifest: ${manifestFile}`));
+    return 1;
+  }
+
+  try {
+    smokePayload = JSON.parse(await readFile(smokeFile, "utf8"));
+  } catch {
+    console.error(c.red(`Missing bridge smoke test payload: ${smokeFile}`));
+    return 1;
+  }
+
+  if (!manifest.bridgeCommand) {
+    console.error(c.red("host-manifest.json missing bridgeCommand"));
+    return 1;
+  }
+
+  const result = await runCommand(manifest.bridgeCommand, smokePayload);
+  console.log(c.blue(`RAX-FLOW Bridge Test (${target})`));
+  console.log(`command: ${manifest.bridgeCommand}`);
+  console.log(`exitCode: ${result.code}`);
+
+  if (result.stdout.trim()) {
+    console.log("stdout:");
+    console.log(result.stdout.trim());
+  }
+
+  if (result.stderr.trim()) {
+    console.log("stderr:");
+    console.log(result.stderr.trim());
+  }
+
+  if (result.code !== 0) {
+    console.log(c.red("Bridge smoke test failed."));
+    return 1;
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    const ok = Boolean(parsed?.ok);
+    if (!ok) {
+      console.log(c.red(`Bridge responded with ok=false: ${parsed?.error ?? "unknown"}`));
+      return 1;
+    }
+  } catch {
+    console.log(c.red("Bridge output is not valid JSON."));
+    return 1;
+  }
+
+  console.log(c.green("Bridge smoke test passed."));
+  return 0;
+}

package/src/dashboard.ts

@@ -0,0 +1,51 @@
+import http from "node:http";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function runDashboard({ port = 3003 }: { port?: number } = {}): Promise<number> {
+    const server = http.createServer(async (req, res) => {
+        // Simple static server for the dashboard
+        if (req.url === "/" || req.url === "/index.html") {
+            try {
+                // Try to find the dashboard file
+                // In the monorepo, it's in packages/cli/dashboard/index.html
+                // When installed as a package, it will be relative to this file
+                let htmlPath = path.join(process.cwd(), "packages/cli/dashboard/index.html");
+
+                // Fallback for when running from dist or installed package
+                try {
+                    await readFile(htmlPath);
+                } catch {
+                    htmlPath = path.join(__dirname, "..", "dashboard", "index.html");
+                }
+
+                const content = await readFile(htmlPath, "utf8");
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(content);
+            } catch (err) {
+                console.error("[UI] Error loading dashboard:", err);
+                res.writeHead(500);
+                res.end("Error loading dashboard. Please ensure you are running from the project root.");
+            }
+        } else {
+            res.writeHead(404);
+            res.end("Not Found");
+        }
+    });
+
+    return new Promise((resolve) => {
+        server.listen(port, () => {
+            console.log(`\n[UI] 🚀 RAX Dashboard started on http://localhost:${port}`);
+            console.log(`[UI] Monitoring kernel evolution and workflow health.`);
+            console.log(`[UI] Press Ctrl+C to stop.`);
+        });
+
+        process.on("SIGINT", () => {
+            server.close();
+            resolve(0);
+        });
+    });
+}

package/src/doctor.ts

@@ -0,0 +1,92 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { HostBridgeAdapter } from "rax-flow-providers";
+import { c } from "./styles.js";
+
+interface DoctorOptions {
+  cwd: string;
+}
+
+interface RaxConfig {
+  defaultProvider?: string;
+  strongProvider?: string;
+  providers?: {
+    host?: { model?: string; mode?: "auto" | "bridge-only" | "mock"; bridgeCommandEnv?: string; timeoutMs?: number };
+  };
+}
+
+async function loadConfig(cwd: string): Promise<RaxConfig | null> {
+  const file = path.join(cwd, ".raxrc");
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw) as RaxConfig;
+  } catch {
+    return null;
+  }
+}
+
+function printLine(ok: boolean, label: string, details?: string) {
+  const icon = ok ? c.green("[ok]") : c.red("[fail]");
+  console.log(`${icon} ${label}${details ? ` - ${details}` : ""}`);
+}
+
+export async function runDoctor(options: DoctorOptions): Promise<number> {
+  console.log(c.blue("RAXFLOW Doctor"));
+
+  const config = await loadConfig(options.cwd);
+  if (!config) {
+    printLine(false, "Missing .raxrc", "run `raxflow install` first");
+    return 1;
+  }
+  printLine(true, "Found .raxrc");
+
+  const hostCfg = config.providers?.host;
+  const bridgeCommandEnv = hostCfg?.bridgeCommandEnv ?? "RAX_HOST_BRIDGE_COMMAND";
+  const bridgeCommand = process.env[bridgeCommandEnv];
+  const provider = new HostBridgeAdapter({
+    model: hostCfg?.model ?? "host-managed",
+    mode: hostCfg?.mode ?? "auto",
+    command: bridgeCommand,
+    timeoutMs: hostCfg?.timeoutMs ?? 10000
+  });
+
+  const health = await provider.healthCheck();
+  printLine(health, "Host provider health", `mode=${hostCfg?.mode ?? "auto"}`);
+
+  const hasBridgeFn = typeof (globalThis as Record<string, unknown>).__RAX_HOST_BRIDGE__ === "function";
+  printLine(hasBridgeFn || Boolean(bridgeCommand), "Bridge source", hasBridgeFn ? "global bridge function" : bridgeCommand ? `command via ${bridgeCommandEnv}` : "auto/mock fallback");
+
+  try {
+    const ping = await provider.callModel("doctor ping", { model: hostCfg?.model ?? "host-managed", maxTokens: 32, temperature: 0 });
+    printLine(true, "callModel test", `provider=${ping.provider} model=${ping.model}`);
+  } catch (error) {
+    printLine(false, "callModel test", String(error));
+    return 1;
+  }
+
+  try {
+    const structured = await provider.callStructured(
+      "doctor structured ping",
+      {
+        type: "object",
+        required: ["agent", "success", "confidence", "risks", "logs", "data"],
+        properties: {
+          agent: { type: "string" },
+          success: { type: "boolean" },
+          confidence: { type: "number" },
+          risks: { type: "array" },
+          logs: { type: "array" },
+          data: { type: "object" }
+        }
+      },
+      { model: hostCfg?.model ?? "host-managed", maxTokens: 128, temperature: 0 }
+    );
+    printLine(true, "callStructured test", `model=${structured.model}`);
+  } catch (error) {
+    printLine(false, "callStructured test", String(error));
+    return 1;
+  }
+
+  console.log(c.green("Doctor checks passed."));
+  return 0;
+}

package/src/evolve.ts

@@ -0,0 +1,74 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { c } from "./styles.js";
+
+interface EvolveOptions {
+    cwd: string;
+    history?: boolean;
+}
+
+interface Blueprint {
+    id: string;
+    version: string;
+    createdAt: string;
+    fitnessScore: number;
+    mutationType: string;
+    metadata?: {
+        message?: string;
+        reason?: string;
+    };
+}
+
+export async function showEvolution(options: EvolveOptions): Promise<number> {
+    const evolutionDir = path.join(options.cwd, ".rax-flow", "evolutions");
+
+    try {
+        const files = await readdir(evolutionDir);
+        const blueprintFiles = files.filter(f => f.startsWith("blueprint_") && f.endsWith(".json"));
+
+        if (blueprintFiles.length === 0) {
+            console.log(c.yellow("\nNo evolutions recorded yet. Run more tasks to trigger Darwinian mutations."));
+            return 0;
+        }
+
+        const blueprints: Blueprint[] = [];
+        for (const file of blueprintFiles) {
+            const raw = await readFile(path.join(evolutionDir, file), "utf8");
+            blueprints.push(JSON.parse(raw) as Blueprint);
+        }
+
+        // Sort by creation date
+        blueprints.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+
+        console.log(c.bold(c.magenta(`\n\n--- [GENETIC LINEAGE: RAX-FLOW] ---`)));
+        console.log(c.gray(`Found ${blueprints.length} evolutionary jumps.\n`));
+
+        blueprints.forEach((bp, i) => {
+            const connector = i === blueprints.length - 1 ? "└" : "├";
+            const branch = i === 0 ? "" : `  ${connector}── `;
+
+            const scoreColor = bp.fitnessScore >= 0.8 ? c.green : (bp.fitnessScore >= 0.6 ? c.yellow : c.red);
+
+            console.log(`${branch}${c.bold(bp.id)} ${c.gray(`v${bp.version}`)}`);
+            console.log(`     ${c.gray("Type:")} ${c.cyan(bp.mutationType)}`);
+            console.log(`     ${c.gray("Fitness:")} ${scoreColor(bp.fitnessScore.toFixed(2))}`);
+            if (bp.metadata?.reason || bp.metadata?.message) {
+                console.log(`     ${c.gray("Note:")} ${c.white(bp.metadata.reason || bp.metadata.message || "")}`);
+            }
+            if (i < blueprints.length - 1) {
+                console.log(`     ${c.gray("│")}`);
+            }
+        });
+
+        console.log(c.bold(c.cyan(`\nSurvival of the fittest: Blueprint ${blueprints[blueprints.length - 1]?.id} is currently dominant.`)));
+
+        return 0;
+    } catch (error) {
+        if ((error as any).code === "ENOENT") {
+            console.log(c.yellow("\nNo evolutions directory found. Run tasks first."));
+            return 0;
+        }
+        console.error(c.red(`Failed to read evolution history: ${error}`));
+        return 1;
+    }
+}

package/src/host-init-templates.ts

@@ -0,0 +1,134 @@
+export type HostTarget = "claude-code" | "codex" | "opencode" | "kilo" | "generic";
+
+export interface HostTemplate {
+  id: HostTarget;
+  title: string;
+  envHint: string;
+  chatHint: string;
+  bootstrapPromptBase: string[];
+  quickCommands: string[];
+  autoInjectMode: "native" | "scripted" | "manual";
+  sessionEntryExamples: string[];
+}
+
+export const HOST_TEMPLATES: Record<HostTarget, HostTemplate> = {
+  "claude-code": {
+    id: "claude-code",
+    title: "Claude Code",
+    envHint: "Export RAX_HOST_BRIDGE_COMMAND before starting Claude Code session.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt at the beginning of the chat.",
+    bootstrapPromptBase: [
+      "RAXFLOW bootstrap (Claude Code)",
+      "- Enable host-native orchestration.",
+      "- Route generation through the configured host bridge.",
+      "- Keep structured JSON outputs for orchestration steps.",
+      "- Execute Verify -> Fix loop when schema validation fails.",
+      "- Report confidence, risk flags, and logs for each step."
+    ],
+    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "scripted",
+    sessionEntryExamples: [
+      "claude-code chat --message-file .raxflow/host-init/claude-code/BOOTSTRAP_PROMPT.txt",
+      "claude-code (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  codex: {
+    id: "codex",
+    title: "Codex",
+    envHint: "Set RAX_HOST_BRIDGE_COMMAND in the shell running Codex.",
+    chatHint: "Send BOOTSTRAP_PROMPT.txt as first instruction in session.",
+    bootstrapPromptBase: [
+      "RAXFLOW bootstrap (Codex)",
+      "- Use host-native model execution through the host bridge.",
+      "- Produce strict structured outputs for all agent steps.",
+      "- Apply Verify -> Fix until valid schema or retry cap.",
+      "- Include confidence and risks in every final step."
+    ],
+    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "scripted",
+    sessionEntryExamples: [
+      "codex chat --message-file .raxflow/host-init/codex/BOOTSTRAP_PROMPT.txt",
+      "codex (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  opencode: {
+    id: "opencode",
+    title: "OpenCode",
+    envHint: "Configure RAX_HOST_BRIDGE_COMMAND in OpenCode terminal/runtime env.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt before requesting implementation.",
+    bootstrapPromptBase: [
+      "RAXFLOW bootstrap (OpenCode)",
+      "- Activate host bridge orchestration mode.",
+      "- Keep responses compact but structured for agent pipeline.",
+      "- Trigger fix cycles on validation failures automatically.",
+      "- Emit step logs and confidence scores."
+    ],
+    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "opencode chat --message-file .raxflow/host-init/opencode/BOOTSTRAP_PROMPT.txt",
+      "opencode (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  kilo: {
+    id: "kilo",
+    title: "Kilo Code",
+    envHint: "Set RAX_HOST_BRIDGE_COMMAND in Kilo launch environment.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt as initialization message.",
+    bootstrapPromptBase: [
+      "RAXFLOW bootstrap (Kilo)",
+      "- Run in host-native orchestration mode.",
+      "- Enforce structured output contract for each stage.",
+      "- Apply Verify -> Fix and escalate when confidence is low.",
+      "- Return actionable logs and risk flags."
+    ],
+    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "kilo chat --message-file .raxflow/host-init/kilo/BOOTSTRAP_PROMPT.txt",
+      "kilo (open session, then paste BOOTSTRAP_PROMPT.txt)"
+    ]
+  },
+  generic: {
+    id: "generic",
+    title: "Generic Host",
+    envHint: "Provide a bridge command through RAX_HOST_BRIDGE_COMMAND.",
+    chatHint: "Paste BOOTSTRAP_PROMPT.txt at session start.",
+    bootstrapPromptBase: [
+      "RAXFLOW bootstrap (Generic)",
+      "- Enable orchestration through host bridge.",
+      "- Return strict JSON for each orchestration step.",
+      "- Retry/fix invalid outputs automatically.",
+      "- Report confidence, risks, and logs."
+    ],
+    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
+    autoInjectMode: "manual",
+    sessionEntryExamples: [
+      "your-host-cli chat --message-file .raxflow/host-init/generic/BOOTSTRAP_PROMPT.txt",
+      "open session, then paste BOOTSTRAP_PROMPT.txt"
+    ]
+  }
+};
+
+export function parseHostTarget(value: string | undefined): HostTarget {
+  if (!value) return "generic";
+  if (value in HOST_TEMPLATES) return value as HostTarget;
+  return "generic";
+}
+
+export function listHostTargets(): HostTarget[] {
+  return Object.keys(HOST_TEMPLATES) as HostTarget[];
+}
+
+export function buildBootstrapPrompt(target: HostTarget, task?: string): string {
+  const template = HOST_TEMPLATES[target];
+  const lines = [...template.bootstrapPromptBase];
+
+  if (task && task.trim().length > 0) {
+    lines.push(`- Task context: ${task.trim()}`);
+    lines.push("- Keep orchestration aligned with this task context unless user changes scope.");
+  }
+
+  lines.push("- If bridge call fails, report issue clearly and keep orchestration state.");
+  return lines.join("\n");
+}