@flumecode/runner 0.10.0 → 0.12.0

package/dist/cli.js

@@ -149,6 +149,25 @@ async function uploadJobLog(config, jobId, content) {
   noteServerVersion(res);
   if (!res.ok) throw new Error(`log upload failed: ${res.status} ${await safeText(res)}`);
 }
+async function fetchRelatedSessions(config, params) {
+  if (!params.prNumbers.length) return [];
+  try {
+    const res = await fetch(`${config.serverUrl}/api/runner/sessions/related`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${config.token}`,
+        "content-type": "application/json",
+        [RUNNER_VERSION_HEADER]: RUNNER_VERSION
+      },
+      body: JSON.stringify(params)
+    });
+    noteServerVersion(res);
+    if (!res.ok) return [];
+    return await res.json();
+  } catch {
+    return [];
+  }
+}
 async function safeText(res) {
   try {
     return await res.text();
@@ -157,930 +176,1106 @@ async function safeText(res) {
   }
 }
 
-// src/executor.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { query } from "@anthropic-ai/claude-agent-sdk";
+// src/plugins/socket.ts
+import { exec as execCb } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
 
-// src/widgets.ts
-import { randomUUID } from "node:crypto";
-import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
-import { z } from "zod";
-var SERVER_NAME = "flume_widgets";
-var SINGLE_SELECT = "single_select";
-var MULTI_SELECT = "multi_select";
-var WIDGET_TOOL_NAMES = [
-  `mcp__${SERVER_NAME}__${SINGLE_SELECT}`,
-  `mcp__${SERVER_NAME}__${MULTI_SELECT}`
-];
-var optionsSchema = z.array(z.string().min(1)).min(2).max(8).describe("2\u20138 short, distinct choices for the user to pick from.");
-var TAIL = "Do NOT add an 'Other' or 'None of these' catch-all \u2014 the UI always offers an 'Other' free-text option automatically. After calling this, END YOUR TURN and wait: the user's answer arrives as their next message and starts a fresh run.";
-function createWidgetTooling() {
-  const collected = [];
-  const singleSelect = tool(
-    SINGLE_SELECT,
-    "Ask the user a single-select (radio-button) question \u2014 exactly one answer. Use this for a genuine either/or choice (competing approaches, scope decisions, yes/no) instead of writing the options as prose. " + TAIL,
-    {
-      question: z.string().min(1).describe("The question to ask the user."),
-      options: optionsSchema
-    },
-    async (args) => {
-      collected.push({
-        id: randomUUID(),
-        type: "single_select",
-        question: args.question,
-        options: args.options.map((label) => ({ id: randomUUID(), label })),
-        selectedOptionId: null,
-        customAnswer: null
-      });
-      return widgetPosted("single-select");
-    }
-  );
-  const multiSelect = tool(
-    MULTI_SELECT,
-    "Ask the user a multi-select (checkbox) question \u2014 they may pick any number of options, including none of the presets if they use 'Other'. Use this for 'select all that apply' questions (which features to include, which files to touch). " + TAIL,
-    {
-      question: z.string().min(1).describe("The question to ask the user."),
-      options: optionsSchema
-    },
-    async (args) => {
-      collected.push({
-        id: randomUUID(),
-        type: "multi_select",
-        question: args.question,
-        options: args.options.map((label) => ({ id: randomUUID(), label })),
-        selectedOptionIds: null,
-        customAnswer: null
-      });
-      return widgetPosted("multi-select");
-    }
-  );
-  const mcpServer = createSdkMcpServer({
-    name: SERVER_NAME,
-    tools: [singleSelect, multiSelect]
-  });
-  return { mcpServer, collected };
+// src/workspace.ts
+import { execFile } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { promisify } from "node:util";
+
+// src/types.ts
+function jobTitle(ctx) {
+  return ctx.kind === "init" ? "Initialize FlumeCode wiki" : ctx.request?.title ?? "request";
 }
-function widgetPosted(kind) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Question posted to the user as a ${kind} widget. End your turn now and wait \u2014 their answer will arrive as their next message.`
-      }
-    ]
-  };
+
+// src/logger.ts
+var lines = [];
+var secrets = [];
+var MAX_BYTES = 10 * 1024 * 1024;
+function startJobLog(opts) {
+  lines = [];
+  secrets = opts.secrets.filter(Boolean);
+  logEvent("meta", `job ${opts.jobId} (${opts.kind}) started at ${(/* @__PURE__ */ new Date()).toISOString()}`);
 }
+function redact(s) {
+  for (const sec of secrets) {
+    s = s.split(sec).join("***REDACTED***");
+  }
+  return s;
+}
+function logEvent(section, text) {
+  lines.push(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${section}] ${redact(text)}`);
+}
+function getJobLog() {
+  const full = lines.join("\n");
+  if (full.length <= MAX_BYTES) return full;
+  const half = Math.floor(MAX_BYTES / 2);
+  return full.slice(0, half) + `
 
-// src/plan.ts
-import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
-var SERVER_NAME2 = "flume_plan";
-var SUBMIT_PLAN = "submit_plan";
-var PLAN_TOOL_NAME = `mcp__${SERVER_NAME2}__${SUBMIT_PLAN}`;
-var PLAN_MARKER = "<!-- flumecode:end-of-plan -->";
-var pseudoCodeEntrySchema = z2.object({
-  file: z2.string().min(1),
-  pseudoCode: z2.string().min(1)
-});
-var stepSchema = z2.object({
-  title: z2.string().min(1).describe("A concise imperative title for this step."),
-  description: z2.string().min(1).describe("What changes and why \u2014 the rationale for this step."),
-  pseudoCode: z2.array(pseudoCodeEntrySchema).optional().describe(
-    "Per-file pseudo code. Provide an entry for every non-documentation file this step touches. Each entry contains the file path and pseudo code describing the changes to that file."
-  )
-});
-var planInputSchema = {
-  title: z2.string().min(1).max(120).describe(
-    "A concise, descriptive name for THIS plan. Must be distinct from the request title and from any sibling plans on the same request. Keep it under 120 characters."
-  ),
-  scope: z2.enum(["feat", "fix", "chore", "docs", "test", "refactor"]).describe("The primary intent of the change."),
-  goal: z2.string().min(1).describe("One or two sentences stating the outcome."),
-  assumptions: z2.array(z2.string()).describe("Anything decided during planning, including unanswered defaults."),
-  steps: z2.array(stepSchema).min(1).describe("Ordered list of changes. Each step says what and why, with file references."),
-  acceptanceCriteria: z2.array(z2.string().min(1)).min(2).describe(
-    "Observable conditions that together define done. Each must be checkable \u2014 a behavior, test, or state you could verify \u2014 not a restatement of a step. At least 2 required."
-  ),
-  risks: z2.array(z2.string()).describe("Anything that could change the approach."),
-  outOfScope: z2.array(z2.string()).describe("What is deliberately not being done.")
-};
-var planSchema = z2.object(planInputSchema);
-function renderPlan(plan) {
-  const lines2 = [];
-  lines2.push(`# ${plan.title}`);
-  lines2.push("");
-  lines2.push(`**Scope** \u2014 \`${plan.scope}\``);
-  lines2.push("");
-  lines2.push(`**Goal** \u2014 ${plan.goal}`);
-  if (plan.assumptions.length > 0) {
-    lines2.push("");
-    lines2.push("**Assumptions**");
-    for (const assumption of plan.assumptions) {
-      lines2.push(`- ${assumption}`);
-    }
+\u2026[truncated ${full.length - MAX_BYTES} bytes]\u2026
+
+` + full.slice(-half);
+}
+
+// src/workspace.ts
+var exec = promisify(execFile);
+var WORKSPACE_PREFIX = "flume-runner-";
+var MAX_BUFFER = 1 << 24;
+async function git(args) {
+  logEvent("git", `git ${args.join(" ")}`);
+  try {
+    const result = await exec("git", args, { maxBuffer: MAX_BUFFER });
+    if (result.stdout.trim()) logEvent("git:out", result.stdout.trim());
+    if (result.stderr.trim()) logEvent("git:err", result.stderr.trim());
+    return result;
+  } catch (err) {
+    logEvent("git:err", String(err.stderr ?? err));
+    throw err;
   }
-  lines2.push("");
-  lines2.push("## Steps");
-  for (const [i, step] of plan.steps.entries()) {
-    lines2.push("");
-    lines2.push(`### ${i + 1}. ${step.title}`);
-    lines2.push("");
-    lines2.push(step.description);
-    if (step.pseudoCode && step.pseudoCode.length > 0) {
-      for (const entry of step.pseudoCode) {
-        lines2.push("");
-        lines2.push(`\`${entry.file}\``);
-        lines2.push("");
-        lines2.push("```");
-        lines2.push(entry.pseudoCode);
-        lines2.push("```");
-      }
-    }
+}
+async function ensureGitIdentity(dir, identity) {
+  await git(["-C", dir, "config", "user.email", identity.email]);
+  await git(["-C", dir, "config", "user.name", identity.name]);
+}
+function cloneUrl(ctx) {
+  const { owner, name, cloneToken } = ctx.repo;
+  return `https://x-access-token:${cloneToken}@github.com/${owner}/${name}.git`;
+}
+function detectPackageManager(dir) {
+  if (!existsSync2(join2(dir, "package.json"))) return null;
+  if (existsSync2(join2(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(dir, "yarn.lock"))) return "yarn";
+  if (existsSync2(join2(dir, "package-lock.json"))) return "npm";
+  if (existsSync2(join2(dir, "bun.lockb"))) return "bun";
+  return "npm";
+}
+async function installDependencies(dir) {
+  const manager = detectPackageManager(dir);
+  if (manager === null) return { status: "skipped" };
+  const env = { ...process.env, CI: "1", ADBLOCK: "1", DISABLE_OPENCOLLECTIVE: "1" };
+  logEvent("install", `${manager} install`);
+  try {
+    const result = await exec(manager, ["install"], {
+      cwd: dir,
+      maxBuffer: MAX_BUFFER,
+      env,
+      timeout: 5 * 6e4
+    });
+    if (result.stdout.trim()) logEvent("install:out", result.stdout.trim());
+    if (result.stderr.trim()) logEvent("install:err", result.stderr.trim());
+    return { status: "installed", manager };
+  } catch (err) {
+    const e = err;
+    const detail = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean).join("\n");
+    logEvent("install:err", detail || (err instanceof Error ? err.message : String(err)));
+    return { status: "failed", manager, error: err instanceof Error ? err.message : String(err) };
   }
-  lines2.push("");
-  lines2.push("## Acceptance criteria");
-  for (const criterion of plan.acceptanceCriteria) {
-    lines2.push(`- [ ] ${criterion}`);
+}
+async function makeWorkspace() {
+  return mkdtemp(join2(tmpdir(), WORKSPACE_PREFIX));
+}
+var MAX_WORKSPACES = 8;
+var workspaceRegistry = /* @__PURE__ */ new Map();
+async function acquireWorkspace(key) {
+  const existing = workspaceRegistry.get(key);
+  if (existing !== void 0 && existsSync2(existing)) {
+    workspaceRegistry.delete(key);
+    workspaceRegistry.set(key, existing);
+    return { dir: existing, reused: true };
   }
-  if (plan.risks.length > 0) {
-    lines2.push("");
-    lines2.push("**Risks / open questions**");
-    for (const risk of plan.risks) {
-      lines2.push(`- ${risk}`);
-    }
+  const dir = await makeWorkspace();
+  workspaceRegistry.set(key, dir);
+  if (workspaceRegistry.size > MAX_WORKSPACES) {
+    const oldest = workspaceRegistry.keys().next().value;
+    const oldDir = workspaceRegistry.get(oldest);
+    workspaceRegistry.delete(oldest);
+    rm(oldDir, { recursive: true, force: true }).catch(() => {
+    });
   }
-  if (plan.outOfScope.length > 0) {
-    lines2.push("");
-    lines2.push("**Out of scope**");
-    for (const item of plan.outOfScope) {
-      lines2.push(`- ${item}`);
-    }
+  return { dir, reused: false };
+}
+async function discardWorkspace(key) {
+  const dir = workspaceRegistry.get(key);
+  workspaceRegistry.delete(key);
+  if (dir !== void 0) {
+    await cleanup(dir).catch(() => {
+    });
   }
-  lines2.push("");
-  lines2.push(PLAN_MARKER);
-  return lines2.join("\n");
 }
-var submitPlanInputSchema = {
-  plans: z2.array(z2.object(planInputSchema)).min(1).refine(
-    (arr) => {
-      const titles = arr.map((p) => p.title.trim()).filter((t) => t.length > 0);
-      return new Set(titles).size === titles.length;
-    },
-    { message: "Each plan must have a distinct non-empty title" }
-  )
-};
-var submitPlanSchema = z2.object(submitPlanInputSchema);
-function createPlanTooling() {
-  let renderedPlans = null;
-  const submitPlan = tool2(
-    SUBMIT_PLAN,
-    "Submit ALL your plans in a single call \u2014 one entry per plan; each becomes its own independently-acceptable Accept-as-plan draft. Do NOT call submit_plan more than once. acceptanceCriteria is required in each plan and must contain at least 2 observable, verifiable conditions. The 'title' field names each specific plan \u2014 make it concise and distinct from the request title and from sibling plan titles.",
-    submitPlanInputSchema,
-    async (args) => {
-      const parsed = submitPlanSchema.parse(args);
-      renderedPlans = parsed.plans.map(renderPlan);
-      return {
-        content: [
-          {
-            type: "text",
-            text: "Plan(s) submitted. The runner will render and post them as your comment(s). End your turn now."
-          }
-        ]
-      };
-    }
-  );
-  const mcpServer = createSdkMcpServer2({
-    name: SERVER_NAME2,
-    tools: [submitPlan]
+async function resetWorkspace(dir) {
+  await git(["-C", dir, "reset", "--hard", "HEAD"]).catch(() => {
+  });
+  await git(["-C", dir, "clean", "-fd"]).catch(() => {
   });
-  return { mcpServer, getPlans: () => renderedPlans };
 }
-
-// src/report.ts
-import { createSdkMcpServer as createSdkMcpServer3, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z3 } from "zod";
-var SERVER_NAME3 = "flume_report";
-var SUBMIT_REPORT = "submit_report";
-var REPORT_TOOL_NAME = `mcp__${SERVER_NAME3}__${SUBMIT_REPORT}`;
-var STATUS_ICON = {
-  met: "\u2705",
-  not_met: "\u274C",
-  unclear: "\u26A0\uFE0F"
-};
-var evidenceSchema = z3.object({
-  file: z3.string().min(1).describe("Repo-relative path the hunk comes from."),
-  hunk: z3.string().min(1).describe(
-    "A unified-diff hunk body proving the criterion \u2014 the lines that matter, not the whole file. Rendered verbatim as a ```diff block."
-  ),
-  note: z3.string().optional().describe("Optional one-line explanation of why this hunk satisfies the criterion.")
-});
-var acVerdictSchema = z3.object({
-  criterion: z3.string().min(1).describe("The acceptance-criterion text, verbatim from the plan."),
-  status: z3.enum(["met", "not_met", "unclear"]).describe("Verdict for this criterion, verified against the actual diff."),
-  rationale: z3.string().min(1).describe("One or two sentences on why the verdict holds."),
-  evidence: z3.array(evidenceSchema).describe(
-    "Diff hunks proving the verdict. Include the relevant hunk(s) for a met criterion; may be empty for not_met / unclear."
-  )
-});
-var reportInputSchema = {
-  summary: z3.string().min(1).describe("One or two sentences on what was implemented."),
-  prose: z3.string().min(1).describe(
-    "Markdown for the remaining report sections \u2014 What changed, Files changed, Build / tests, and Caveats / follow-ups. Use ## headings. Do NOT include the acceptance-criteria section here (that goes in acceptanceCriteria) and do NOT include the PR link (the runner appends it)."
-  ),
-  acceptanceCriteria: z3.array(acVerdictSchema).min(1).describe(
-    "One entry per acceptance criterion from the plan, in plan order, each with a verdict and the diff evidence behind it."
-  )
-};
-var reportSchema = z3.object(reportInputSchema);
-function renderReport(report) {
-  const lines2 = [];
-  lines2.push(report.summary.trim());
-  lines2.push("");
-  lines2.push(report.prose.trim());
-  lines2.push("");
-  lines2.push("## Acceptance criteria");
-  for (const ac of report.acceptanceCriteria) {
-    lines2.push("");
-    lines2.push(`### ${STATUS_ICON[ac.status]} ${ac.criterion}`);
-    lines2.push("");
-    lines2.push(ac.rationale.trim());
-    for (const ev of ac.evidence) {
-      lines2.push("");
-      lines2.push(ev.note ? `\`${ev.file}\` \u2014 ${ev.note}` : `\`${ev.file}\``);
-      lines2.push("");
-      lines2.push("```diff");
-      lines2.push(ev.hunk.replace(/\n+$/, ""));
-      lines2.push("```");
-    }
+async function prepareAtSha(ctx, dir, reused) {
+  const identity = { name: ctx.agentName, email: ctx.agentEmail };
+  if (!reused) {
+    await cloneAtSha(ctx, dir);
+    await ensureGitIdentity(dir, identity);
+    return;
   }
-  return lines2.join("\n");
+  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
+  await ensureGitIdentity(dir, identity);
 }
-function createReportTooling() {
-  let submittedReport = null;
-  const submitReport = tool3(
-    SUBMIT_REPORT,
-    "Submit the final implementation report as structured data. Call this exactly once, at the end of the run. `acceptanceCriteria` must contain one entry per plan criterion, each with a met / not_met / unclear verdict and the diff hunk(s) that prove it. `summary` + `prose` are markdown for the rest of the report. Do NOT include a PR link \u2014 the runner appends it.",
-    reportInputSchema,
-    async (args) => {
-      submittedReport = reportSchema.parse(args);
-      return {
-        content: [
-          {
-            type: "text",
-            text: "Report submitted. The runner will render and post it. End your turn now."
-          }
-        ]
-      };
+async function prepareResumingBranch(ctx, dir, reused) {
+  const identity = { name: ctx.agentName, email: ctx.agentEmail };
+  if (!reused) {
+    const result = await cloneResumingBranch(ctx, dir);
+    await ensureGitIdentity(dir, identity);
+    return result;
+  }
+  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
+  await ensureGitIdentity(dir, identity);
+  return { resumed: true };
+}
+async function sweepWorkspaces() {
+  const base = tmpdir();
+  let entries;
+  try {
+    entries = await readdir(base);
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  for (const entry of entries) {
+    if (!entry.startsWith(WORKSPACE_PREFIX)) continue;
+    try {
+      await rm(join2(base, entry), { recursive: true, force: true });
+      removed++;
+    } catch {
     }
-  );
-  const mcpServer = createSdkMcpServer3({
-    name: SERVER_NAME3,
-    tools: [submitReport]
-  });
-  return { mcpServer, getReport: () => submittedReport };
+  }
+  return removed;
 }
-
-// src/logger.ts
-var lines = [];
-var secrets = [];
-var MAX_BYTES = 10 * 1024 * 1024;
-function startJobLog(opts) {
-  lines = [];
-  secrets = opts.secrets.filter(Boolean);
-  logEvent("meta", `job ${opts.jobId} (${opts.kind}) started at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+async function cloneAtSha(ctx, dir) {
+  await git(["clone", "--quiet", cloneUrl(ctx), dir]);
+  await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, ctx.repo.checkoutSha]);
 }
-function redact(s) {
-  for (const sec of secrets) {
-    s = s.split(sec).join("***REDACTED***");
+async function cloneResumingBranch(ctx, dir) {
+  await git(["clone", "--quiet", cloneUrl(ctx), dir]);
+  try {
+    await git(["-C", dir, "fetch", "--quiet", "origin", ctx.repo.checkoutBranch]);
+    await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, "FETCH_HEAD"]);
+    return { resumed: true };
+  } catch {
+    await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, ctx.repo.checkoutSha]);
+    return { resumed: false };
   }
-  return s;
 }
-function logEvent(section, text) {
-  lines.push(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${section}] ${redact(text)}`);
+async function hasChanges(dir) {
+  await git(["-C", dir, "add", "-A"]);
+  const { stdout: stdout2 } = await git(["-C", dir, "status", "--porcelain"]);
+  return stdout2.trim().length > 0;
 }
-function getJobLog() {
-  const full = lines.join("\n");
-  if (full.length <= MAX_BYTES) return full;
-  const half = Math.floor(MAX_BYTES / 2);
-  return full.slice(0, half) + `
-
-\u2026[truncated ${full.length - MAX_BYTES} bytes]\u2026
-
-` + full.slice(-half);
+var PreCommitError = class extends Error {
+  constructor(log) {
+    super("pre-commit checks failed");
+    this.log = log;
+    this.name = "PreCommitError";
+  }
+};
+function commitFailureLog(err) {
+  const e = err;
+  const parts = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter((s) => s.length > 0);
+  return parts.length > 0 ? parts.join("\n") : e.message ?? String(err);
 }
-
-// src/executor.ts
-var FLUME_PLUGIN_DIR = fileURLToPath2(new URL("../skills-plugin", import.meta.url));
-function stringifyResult(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map(
-      (c) => typeof c === "object" && c !== null && "text" in c ? String(c.text) : JSON.stringify(c)
-    ).join("\n");
+function isUnsupportedGitSubcommand(err) {
+  const e = err;
+  const text = `${typeof e.stderr === "string" ? e.stderr : ""}
+${e.message ?? ""}`;
+  return /is not a git command|unknown subcommand|usage: git hook/i.test(text);
+}
+async function runRepoChecks(dir) {
+  try {
+    await git(["-C", dir, "hook", "run", "pre-commit"]);
+    logEvent("checks", "pre-commit hook passed");
+    return { ok: true, log: "", skipped: false };
+  } catch (err) {
+    if (isUnsupportedGitSubcommand(err)) {
+      logEvent("checks", "pre-commit hook skipped (git too old)");
+      return { ok: true, log: "", skipped: true };
+    }
+    const log = commitFailureLog(err);
+    logEvent("checks:err", log);
+    return { ok: false, log, skipped: false };
   }
-  return JSON.stringify(content);
 }
-async function runClaudeCode(opts) {
-  let finalText = "";
-  const { mcpServer, collected } = createWidgetTooling();
-  const { mcpServer: planServer, getPlans } = createPlanTooling();
-  const { mcpServer: reportServer, getReport } = createReportTooling();
-  for await (const message of query({
-    prompt: opts.prompt,
-    options: {
-      cwd: opts.cwd,
-      permissionMode: opts.permissionMode,
-      allowDangerouslySkipPermissions: opts.permissionMode === "bypassPermissions",
-      ...opts.model ? { model: opts.model } : {},
-      ...opts.abortController ? { abortController: opts.abortController } : {},
-      maxTurns: opts.maxTurns ?? 40,
-      // Hermetic: ignore ALL config from the checked-out repo (CLAUDE.md,
-      // .claude/settings.json, .claude/skills, …) and the runner owner's
-      // ~/.claude. Only our plugin's skills are exposed to the agent. Auto-memory
-      // is disabled separately via CLAUDE_CODE_DISABLE_AUTO_MEMORY (see cli.ts).
-      settingSources: [],
-      plugins: [{ type: "local", path: FLUME_PLUGIN_DIR }],
-      // Pre-approve the widget, plan, and Task tools so they run without a
-      // permission prompt in headless mode (allow-listing pre-approves them; it
-      // does NOT restrict anything else). Task lets the implement-plan
-      // orchestrator spawn its subagents; without pre-approval the spawn could
-      // stall waiting for an approval no one can give.
-      mcpServers: { flume_widgets: mcpServer, flume_plan: planServer, flume_report: reportServer },
-      allowedTools: [...WIDGET_TOOL_NAMES, PLAN_TOOL_NAME, REPORT_TOOL_NAME, "Task"]
-    }
-  })) {
-    if (message.type === "assistant") {
-      const content = message.message?.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block && block.type === "text" && typeof block.text === "string") {
-            process.stdout.write(block.text);
-            logEvent("agent", block.text);
-          } else if (block && block.type === "tool_use") {
-            logEvent("tool_use", `${block.name} ${JSON.stringify(block.input)}`);
-          }
-        }
-      }
-    } else if (message.type === "user") {
-      const content = message.message?.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block && block.type === "tool_result") {
-            logEvent("tool_result", stringifyResult(block.content));
-          }
-        }
-      }
-    } else if (message.type === "result") {
-      finalText = message.result ?? "";
-      logEvent("result", finalText);
-    } else if (message.type === "system") {
-      logEvent("system", JSON.stringify(message));
-    }
-  }
-  process.stdout.write("\n");
-  if (opts.abortController?.signal.aborted) {
-    throw new Error("Run canceled by user");
+async function commitChanges(ctx, dir) {
+  if (!await hasChanges(dir)) return false;
+  try {
+    await git(["-C", dir, "commit", "--quiet", "-m", `FlumeCode: ${jobTitle(ctx)}`]);
+  } catch (err) {
+    throw new PreCommitError(commitFailureLog(err));
   }
-  return { text: finalText, widgets: collected, plans: getPlans(), report: getReport() };
+  return true;
 }
-
-// src/health.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-var PROBE_TIMEOUT_MS = 6e4;
-async function checkClaudeCode() {
+async function pushBranch(ctx, dir) {
+  await git(["-C", dir, "push", "--quiet", "-u", "origin", ctx.repo.checkoutBranch]);
+}
+var RebaseConflictError = class extends Error {
+  constructor(mergeBranch, files) {
+    const list = files.length ? `: ${files.join(", ")}` : "";
+    super(`Rebase onto ${mergeBranch} hit conflicts in ${files.length} file(s)${list}`);
+    this.mergeBranch = mergeBranch;
+    this.files = files;
+    this.name = "RebaseConflictError";
+  }
+};
+async function rebaseOntoMergeBranch(ctx, dir) {
+  const { mergeBranch } = ctx.repo;
+  if (!mergeBranch) return;
+  await git(["-C", dir, "fetch", "--quiet", "origin", mergeBranch]);
   try {
-    let sawResult = false;
-    const run = (async () => {
-      for await (const message of query2({
-        prompt: "Reply with the single word: ok",
-        options: { permissionMode: "bypassPermissions", maxTurns: 1 }
-      })) {
-        if (message.type === "result") {
-          sawResult = true;
-          const isError = message.is_error === true;
-          const subtype = message.subtype;
-          if (isError)
-            throw new Error(
-              subtype ? `Claude Code error: ${subtype}` : "Claude Code returned an error"
-            );
-        }
-      }
-    })();
-    await withTimeout(run, PROBE_TIMEOUT_MS, "Claude Code did not respond in time");
-    if (!sawResult) return { ready: false, error: "Claude Code produced no result" };
-    return { ready: true };
+    await git(["-C", dir, "rebase", "--empty=drop", "FETCH_HEAD"]);
   } catch (err) {
-    return { ready: false, error: errorMessage(err) };
+    const conflicted = await git(["-C", dir, "diff", "--name-only", "--diff-filter=U"]).catch(
+      () => ({ stdout: "" })
+    );
+    const files = conflicted.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+    await git(["-C", dir, "rebase", "--abort"]).catch(() => {
+    });
+    if (files.length === 0) throw err;
+    throw new RebaseConflictError(mergeBranch, files);
   }
 }
-function withTimeout(p, ms, message) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(message)), ms);
-    p.then(
-      (v) => {
-        clearTimeout(timer);
-        resolve(v);
-      },
-      (e) => {
-        clearTimeout(timer);
-        reject(e);
-      }
-    );
-  });
+async function mergeInMergeBranch(ctx, dir) {
+  const { mergeBranch } = ctx.repo;
+  if (!mergeBranch) return { conflicted: false };
+  await git(["-C", dir, "fetch", "--quiet", "origin", mergeBranch]);
+  try {
+    await git(["-C", dir, "merge", "--no-edit", "FETCH_HEAD"]);
+    return { conflicted: false };
+  } catch {
+    return { conflicted: true };
+  }
 }
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+async function listUnmergedPaths(dir) {
+  const { stdout: stdout2 } = await git(["-C", dir, "diff", "--name-only", "--diff-filter=U"]).catch(() => ({
+    stdout: ""
+  }));
+  return stdout2.split("\n").map((line) => line.trim()).filter(Boolean);
 }
-
-// src/rules.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join2 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-var RULES_DIR = fileURLToPath3(new URL("../skills-plugin/rules", import.meta.url));
-function loadRule(name) {
-  const raw = readFileSync3(join2(RULES_DIR, `${name}.md`), "utf8");
-  return stripFrontMatter(raw).trim();
+async function listConflictMarkerPaths(dir, paths) {
+  if (paths.length === 0) return [];
+  const { stdout: stdout2 } = await git([
+    "-C",
+    dir,
+    "grep",
+    "--no-color",
+    "-lE",
+    "^(<<<<<<<|>>>>>>>|\\|\\|\\|\\|\\|\\|\\|)",
+    "--",
+    ...paths
+  ]).catch(() => ({ stdout: "" }));
+  return stdout2.split("\n").map((line) => line.trim()).filter(Boolean);
 }
-function stripFrontMatter(raw) {
-  const match = raw.match(/^---\n.*?\n---\n/s);
-  return match ? raw.slice(match[0].length) : raw;
+async function openPullRequest(ctx) {
+  const { owner, name, cloneToken, checkoutBranch, mergeBranch } = ctx.repo;
+  if (!mergeBranch) return null;
+  const apiBase = `https://api.github.com/repos/${owner}/${name}`;
+  const headers = {
+    authorization: `Bearer ${cloneToken}`,
+    accept: "application/vnd.github+json",
+    "x-github-api-version": "2022-11-28",
+    "content-type": "application/json"
+  };
+  const title = jobTitle(ctx);
+  const body = ctx.kind === "init" ? "Bootstraps the `.flumecode/` wiki for this repository. Opened by the FlumeCode runner." : `Opened by the FlumeCode runner for request "${title}".`;
+  const res = await fetch(`${apiBase}/pulls`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      title: `FlumeCode: ${title}`,
+      head: checkoutBranch,
+      base: mergeBranch,
+      body
+    })
+  });
+  if (res.status === 201) {
+    const data = await res.json();
+    return { number: data.number, url: data.html_url };
+  }
+  if (res.status === 422) {
+    const list = await fetch(
+      `${apiBase}/pulls?state=open&head=${owner}:${checkoutBranch}&base=${mergeBranch}`,
+      { headers }
+    );
+    if (list.ok) {
+      const open = await list.json();
+      if (open[0]) return { number: open[0].number, url: open[0].html_url };
+    }
+    return null;
+  }
+  throw new Error(`PR creation failed: ${res.status} ${await res.text()}`);
 }
-
-// src/prompt.ts
-function turnHeading(turn, agentName) {
-  if (turn.role === "user") return "User";
-  if (turn.failed) return `${agentName} (this run ended in an error)`;
-  if (turn.kind === "plan") return `${agentName} (proposed a plan)`;
-  if (turn.kind === "report") return `${agentName} (implementation report)`;
-  return agentName;
+async function cleanup(dir) {
+  await rm(dir, { recursive: true, force: true });
 }
-function appendThread(lines2, ctx) {
-  if (!ctx.thread || ctx.thread.length === 0) return;
-  lines2.push("", "# Conversation so far");
-  for (const turn of ctx.thread) {
-    lines2.push("", `## ${turnHeading(turn, ctx.agentName)}`, turn.content);
+function parsePrFromSubject(subject) {
+  const m = subject.match(/\(#(\d+)\)\s*$/);
+  return m ? Number(m[1]) : null;
+}
+async function incomingPrNumbers(ctx, dir, paths) {
+  if (!paths.length) return [];
+  try {
+    const mergeHeadResult = await git(["-C", dir, "rev-parse", "MERGE_HEAD"]);
+    const mergeHead = mergeHeadResult.stdout.trim();
+    const baseResult = await git(["-C", dir, "merge-base", "HEAD", mergeHead]);
+    const base = baseResult.stdout.trim();
+    const logResult = await git([
+      "-C",
+      dir,
+      "log",
+      "--no-merges",
+      `--format=%H%x1f%s`,
+      `${base}..${mergeHead}`,
+      "--",
+      ...paths
+    ]);
+    const nums = /* @__PURE__ */ new Set();
+    const needLookup = [];
+    for (const line of logResult.stdout.split("\n").filter(Boolean)) {
+      const idx = line.indexOf("");
+      const sha = line.slice(0, idx);
+      const subject = line.slice(idx + 1);
+      const n = parsePrFromSubject(subject);
+      if (n !== null) nums.add(n);
+      else needLookup.push(sha);
+    }
+    for (const sha of needLookup) {
+      for (const n of await prNumbersForCommit(ctx, sha)) nums.add(n);
+    }
+    return [...nums];
+  } catch {
+    return [];
   }
 }
-function buildPrompt(ctx) {
-  const task = ctx.permissionMode === "plan" ? `Use the \`flumecode:request-to-plan\` skill to handle this request. You are read-only and cannot modify files \u2014 clarify any ambiguity with the user first, then produce a concrete, actionable plan (the specific changes you would make and why). Cite the relevant files. Do NOT call ExitPlanMode or write the plan to a file. When the plan is ready, call the \`submit_plan\` tool with the structured plan fields; the runner renders it into the canonical plan markdown and posts it as your comment.` : `Use the \`flumecode:implement-plan\` skill to handle this request. You are the ORCHESTRATOR: do not implement, review, or write the report yourself \u2014 follow the skill to delegate each phase to subagents via the Task tool, picking the right model for each. Do not commit or push \u2014 the runner handles that.`;
-  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this request. If there is no wiki, work from the code directly.`;
-  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
-  const lines2 = [
-    `You are "${ctx.agentName}", an autonomous coding agent working inside a FlumeCode request.`,
-    `The repository ${ctx.repo.fullName} is checked out in your current working directory on branch "${ctx.repo.checkoutBranch}" at commit ${ctx.repo.checkoutSha.slice(0, 7)}.`,
-    task,
-    orient,
-    widgets
-  ];
-  if (ctx.permissionMode !== "plan") {
-    lines2.push(
-      "",
-      "These coding guidelines apply to all code produced in this run:",
-      "",
-      loadRule("coding-guideline")
-    );
+async function prNumbersForCommit(ctx, sha) {
+  const { owner, name, cloneToken } = ctx.repo;
+  try {
+    const res = await fetch(`https://api.github.com/repos/${owner}/${name}/commits/${sha}/pulls`, {
+      headers: {
+        authorization: `Bearer ${cloneToken}`,
+        accept: "application/vnd.github+json",
+        "x-github-api-version": "2022-11-28"
+      }
+    });
+    if (!res.ok) return [];
+    return (await res.json()).map((p) => p.number);
+  } catch {
+    return [];
   }
-  lines2.push("", `# Request: ${ctx.request?.title ?? ""}`);
-  if (ctx.request?.body) {
-    lines2.push("", ctx.request.body);
+}
+
+// src/plugins/manifest.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir as readdir2, readFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function loadPlugins(dir) {
+  const pluginsDir = join3(dir, ".flumecode", "plugins");
+  if (!existsSync3(pluginsDir)) return [];
+  let entries;
+  try {
+    entries = await readdir2(pluginsDir);
+  } catch {
+    return [];
   }
-  appendThread(lines2, ctx);
-  lines2.push(
-    "",
-    ctx.permissionMode === "plan" ? "Your final reply is posted verbatim as your comment in the thread \u2014 if you called `submit_plan`, the rendered plan is posted automatically; for clarifying questions, your reply text is posted as-is." : "Your final reply is posted verbatim as your comment in the thread \u2014 make it the implementation report your report subagent produced, with nothing added. The runner appends the pull-request link."
-  );
-  return lines2.join("\n");
+  const manifests = [];
+  for (const entry of entries) {
+    const manifestPath = join3(pluginsDir, entry, "plugin.json");
+    try {
+      const raw = JSON.parse(await readFile(manifestPath, "utf8"));
+      const manifest = parseManifest(raw);
+      if (manifest) manifests.push(manifest);
+    } catch {
+    }
+  }
+  return manifests;
+}
+function parseManifest(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (typeof r.key !== "string" || !r.key) return null;
+  if (r.socket !== "pre-commit") return null;
+  if (typeof r.run !== "string" || !r.run) return null;
+  const manifest = { key: r.key, socket: r.socket, run: r.run };
+  if (typeof r.heartbeat === "object" && r.heartbeat !== null) {
+    const hb = r.heartbeat;
+    if (typeof hb.url === "string" && typeof hb.token === "string") {
+      manifest.heartbeat = { url: hb.url, token: hb.token };
+    }
+  }
+  return manifest;
 }
-function buildRevisePrompt(ctx) {
-  const task = `Use the \`flumecode:revise-implementation\` skill to handle this turn. The plan below was already implemented (its implementation report appears in the conversation below, tagged as such); the user is now asking to fine-tune that implementation. Decide how to respond to their latest message: if it's unclear, ask a clarifying question (as a widget); if it's a bad idea or not feasible, push back with your reasoning; if it warrants rethinking the plan, call \`submit_plan\` with a revised plan; otherwise implement the requested change. When you implement, you are the ORCHESTRATOR: delegate the work to subagents via the Task tool as the skill directs, and do not commit or push \u2014 the runner handles that, updating the existing pull request.`;
-  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this change. If there is no wiki, work from the code directly.`;
-  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
-  const lines2 = [
-    `You are "${ctx.agentName}", an autonomous coding agent fine-tuning an implemented FlumeCode plan in an ongoing thread with the user.`,
-    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the plan's implementation branch "${ctx.repo.checkoutBranch}" \u2014 the same branch its open pull request is built from, so any change you push updates that PR.`,
-    task,
-    orient,
-    widgets,
-    "",
-    "These coding guidelines apply to all code produced in this run:",
-    "",
-    loadRule("coding-guideline"),
-    "",
-    `# Plan: ${ctx.request?.title ?? ""}`
-  ];
-  if (ctx.request?.body) {
-    lines2.push("", ctx.request.body);
-  }
-  appendThread(lines2, ctx);
-  lines2.push(
-    "",
-    "The last message above is the user's request for this turn. Your final reply is posted verbatim as your comment in the plan thread: if you implemented a change, make it a short report of what you changed (the runner appends the pull-request link); if you asked a question, called `submit_plan`, or pushed back, your reply text is posted as-is."
-  );
-  return lines2.join("\n");
-}
-function buildResolvePrompt(ctx) {
-  const mergeBranch = ctx.repo.mergeBranch ?? "the merge branch";
-  const task = `Use the \`flumecode:resolve-merge-conflict\` skill to handle this turn. A merge of \`${mergeBranch}\` into this branch is IN PROGRESS and has left conflict markers in your working tree. Resolve every conflicted file by correctly integrating BOTH sides \u2014 the change this session implemented (described below) and the incoming changes from \`${mergeBranch}\` \u2014 never blindly discard either side. Remove all conflict markers and verify the result builds and tests pass. Do NOT \`git add\`, commit, push, or open a pull request \u2014 the runner finalizes the merge commit and updates the existing pull request.`;
-  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to the conflicting code. If there is no wiki, work from the code directly.`;
-  const lines2 = [
-    `You are "${ctx.agentName}", an autonomous coding agent resolving merge conflicts on an implemented FlumeCode plan.`,
-    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the plan's implementation branch "${ctx.repo.checkoutBranch}" \u2014 the same branch its open pull request is built from \u2014 with an in-progress merge of "${mergeBranch}".`,
-    task,
-    orient,
-    "",
-    "These coding guidelines apply to all code produced in this run:",
-    "",
-    loadRule("coding-guideline"),
-    "",
-    `# Plan: ${ctx.request?.title ?? ""}`
-  ];
-  if (ctx.request?.body) {
-    lines2.push("", ctx.request.body);
+
+// src/plugins/socket.ts
+var exec2 = promisify2(execCb);
+async function runSocket(socketName, dir) {
+  const plugins = (await loadPlugins(dir)).filter((p) => p.socket === socketName);
+  for (const plugin of plugins) {
+    const result = await runPluginCommand(plugin.run, dir);
+    if (result.exitCode !== 0) {
+      throw new PreCommitError(`[plugin:${plugin.key}] ${result.output}`);
+    }
   }
-  appendThread(lines2, ctx);
-  lines2.push(
-    "",
-    "Resolve the conflicts now. Your final reply is posted as a report in the plan thread: summarize which files conflicted and how you resolved each (the runner appends the pull-request link, so don't add one)."
-  );
-  return lines2.join("\n");
 }
-function buildDocumentPrompt(ctx) {
-  const lines2 = [
-    `You are "${ctx.agentName}" maintaining the repository wiki for ${ctx.repo.fullName}.`,
-    `An implementation just ran in this working directory to satisfy the request below; its changes are uncommitted in the working tree.`,
-    `Use the \`flumecode:document\` skill to bring the wiki in sync with those changes. Only edit files under \`.flumecode/wiki/\` \u2014 do not touch application code. The runner commits the wiki alongside the implementation in the same pull request.`,
-    "",
-    `# Request: ${ctx.request?.title ?? ""}`
-  ];
-  if (ctx.request?.body) {
-    lines2.push("", ctx.request.body);
+async function runPluginCommand(command2, cwd) {
+  try {
+    const result = await exec2(command2, { cwd, maxBuffer: 1 << 24 });
+    const output = [result.stdout, result.stderr].map((s) => s.trim()).filter(Boolean).join("\n");
+    return { exitCode: 0, output };
+  } catch (err) {
+    const e = err;
+    const output = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean).join("\n");
+    return { exitCode: typeof e.code === "number" ? e.code : 1, output };
   }
-  appendThread(lines2, ctx);
-  lines2.push("", "When done, reply with a one- or two-line summary of the wiki changes you made.");
-  return lines2.join("\n");
-}
-function buildRepairPrompt(ctx, hookLog) {
-  const lines2 = [
-    `You are "${ctx.agentName}", fixing a failed pre-commit check in the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
-    `The changes from the previous step are still uncommitted in the working tree. When the runner tried to commit them, the repository's pre-commit hook \u2014 which runs the project's own checks (lint / typecheck / unit tests) \u2014 failed. Make the working tree pass those checks: fix the failing code or tests at their root. Do NOT delete or skip tests, weaken assertions, or disable the checks to silence the failure. Preserve the intent of the original change; repair only what's broken. Do NOT commit or push \u2014 the runner re-commits once the checks pass.`,
-    "",
-    "These coding guidelines apply to all code produced in this run:",
-    "",
-    loadRule("coding-guideline"),
-    "",
-    "# Pre-commit hook output",
-    "",
-    "```",
-    hookLog,
-    "```",
-    "",
-    "When done, reply with a one-line summary of what you fixed."
-  ];
-  return lines2.join("\n");
 }
-function buildReleasePrompt(ctx, baseChecks) {
-  const task = `Use the \`flumecode:create-release\` skill to handle this turn. You are driving a release: first analyse commits since the last tag, propose version bumps, and ask the user to confirm via widgets (Phase 1); once the user's widget answers appear in the thread, apply the bumps to package.json files and update CHANGELOG.md (Phase 2). Do NOT commit or push \u2014 the runner handles that and opens the bump PR.`;
-  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this release. If there is no wiki, work from the code directly.`;
-  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
-  const lines2 = [
-    `You are "${ctx.agentName}", an autonomous coding agent driving a FlumeCode release.`,
-    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the release bump branch "${ctx.repo.checkoutBranch}".`,
-    task,
-    orient,
-    widgets,
-    "",
-    "These coding guidelines apply to all code produced in this run:",
-    "",
-    loadRule("coding-guideline"),
-    "",
-    `# Release: ${ctx.request?.title ?? ""}`
-  ];
-  if (ctx.request?.body) {
-    lines2.push("", ctx.request.body);
-  }
-  if (baseChecks && !baseChecks.ok) {
-    lines2.push(
-      "",
-      "# Pre-release check status",
-      "",
-      "\u26A0\uFE0F The repository's pre-commit checks (lint / typecheck / tests) are currently FAILING on the base branch, independently of any version bump. A release must not ship a broken base:",
-      "",
-      "- **Phase 1 (propose):** tell the user, in your reply, that the base currently fails these checks and that the release will fix them as part of the bump.",
-      "- **Phase 2 (apply):** fix the failing code at its root so the checks pass, THEN apply the version bumps and CHANGELOG. Do NOT delete/skip tests or weaken assertions. The fixes ship in the same bump PR. Still do NOT commit or push \u2014 the runner does.",
-      "",
-      "Failing check output:",
-      "",
-      "```",
-      baseChecks.log,
-      "```"
-    );
-  }
-  appendThread(lines2, ctx);
-  lines2.push(
-    "",
-    "Your final reply is posted verbatim as your comment in the release thread \u2014 if you called widgets (Phase 1), your reply text accompanies the questions; if you applied the bumps (Phase 2), make it the report the skill produced. The runner appends the pull-request link."
+
+// src/executor.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/widgets.ts
+import { randomUUID } from "node:crypto";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+var SERVER_NAME = "flume_widgets";
+var SINGLE_SELECT = "single_select";
+var MULTI_SELECT = "multi_select";
+var WIDGET_TOOL_NAMES = [
+  `mcp__${SERVER_NAME}__${SINGLE_SELECT}`,
+  `mcp__${SERVER_NAME}__${MULTI_SELECT}`
+];
+var optionsSchema = z.array(z.string().min(1)).min(2).max(8).describe("2\u20138 short, distinct choices for the user to pick from.");
+var TAIL = "Do NOT add an 'Other' or 'None of these' catch-all \u2014 the UI always offers an 'Other' free-text option automatically. After calling this, END YOUR TURN and wait: the user's answer arrives as their next message and starts a fresh run.";
+function createWidgetTooling() {
+  const collected = [];
+  const singleSelect = tool(
+    SINGLE_SELECT,
+    "Ask the user a single-select (radio-button) question \u2014 exactly one answer. Use this for a genuine either/or choice (competing approaches, scope decisions, yes/no) instead of writing the options as prose. " + TAIL,
+    {
+      question: z.string().min(1).describe("The question to ask the user."),
+      options: optionsSchema
+    },
+    async (args) => {
+      collected.push({
+        id: randomUUID(),
+        type: "single_select",
+        question: args.question,
+        options: args.options.map((label) => ({ id: randomUUID(), label })),
+        selectedOptionId: null,
+        customAnswer: null
+      });
+      return widgetPosted("single-select");
+    }
   );
-  return lines2.join("\n");
-}
-function buildInitPrompt(ctx) {
-  return [
-    `You are "${ctx.agentName}" initializing FlumeCode for the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
-    `Use the \`flumecode:document\` skill to create the initial repository wiki under \`.flumecode/wiki/\`. The wiki does not exist yet, so the skill will bootstrap it: survey the codebase and produce a high-level overview plus per-component pages. Only create files under \`.flumecode/\` \u2014 do not modify application code. The runner commits the result and opens a pull request.`,
-    "",
-    "When done, reply with a one- or two-line summary of the wiki you created."
-  ].join("\n");
+  const multiSelect = tool(
+    MULTI_SELECT,
+    "Ask the user a multi-select (checkbox) question \u2014 they may pick any number of options, including none of the presets if they use 'Other'. Use this for 'select all that apply' questions (which features to include, which files to touch). " + TAIL,
+    {
+      question: z.string().min(1).describe("The question to ask the user."),
+      options: optionsSchema
+    },
+    async (args) => {
+      collected.push({
+        id: randomUUID(),
+        type: "multi_select",
+        question: args.question,
+        options: args.options.map((label) => ({ id: randomUUID(), label })),
+        selectedOptionIds: null,
+        customAnswer: null
+      });
+      return widgetPosted("multi-select");
+    }
+  );
+  const mcpServer = createSdkMcpServer({
+    name: SERVER_NAME,
+    tools: [singleSelect, multiSelect]
+  });
+  return { mcpServer, collected };
 }
-
-// src/types.ts
-function jobTitle(ctx) {
-  return ctx.kind === "init" ? "Initialize FlumeCode wiki" : ctx.request?.title ?? "request";
+function widgetPosted(kind) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Question posted to the user as a ${kind} widget. End your turn now and wait \u2014 their answer will arrive as their next message.`
+      }
+    ]
+  };
 }
 
-// src/workspace.ts
-import { execFile } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
-import { mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
-import { promisify } from "node:util";
-var exec = promisify(execFile);
-var WORKSPACE_PREFIX = "flume-runner-";
-var MAX_BUFFER = 1 << 24;
-async function git(args) {
-  logEvent("git", `git ${args.join(" ")}`);
-  try {
-    const result = await exec("git", args, { maxBuffer: MAX_BUFFER });
-    if (result.stdout.trim()) logEvent("git:out", result.stdout.trim());
-    if (result.stderr.trim()) logEvent("git:err", result.stderr.trim());
-    return result;
-  } catch (err) {
-    logEvent("git:err", String(err.stderr ?? err));
-    throw err;
+// src/plan.ts
+import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+var SERVER_NAME2 = "flume_plan";
+var SUBMIT_PLAN = "submit_plan";
+var PLAN_TOOL_NAME = `mcp__${SERVER_NAME2}__${SUBMIT_PLAN}`;
+var PLAN_MARKER = "<!-- flumecode:end-of-plan -->";
+var pseudoCodeEntrySchema = z2.object({
+  file: z2.string().min(1),
+  pseudoCode: z2.string().min(1)
+});
+var stepSchema = z2.object({
+  title: z2.string().min(1).describe("A concise imperative title for this step."),
+  description: z2.string().min(1).describe("What changes and why \u2014 the rationale for this step."),
+  pseudoCode: z2.array(pseudoCodeEntrySchema).optional().describe(
+    "Per-file pseudo code. Provide an entry for every non-documentation file this step touches. Each entry contains the file path and pseudo code describing the changes to that file."
+  )
+});
+var planInputSchema = {
+  title: z2.string().min(1).max(120).describe(
+    "A concise, descriptive name for THIS plan. Must be distinct from the request title and from any sibling plans on the same request. Keep it under 120 characters."
+  ),
+  scope: z2.enum(["feat", "fix", "chore", "docs", "test", "refactor"]).describe("The primary intent of the change."),
+  goal: z2.string().min(1).describe("One or two sentences stating the outcome."),
+  assumptions: z2.array(z2.string()).describe("Anything decided during planning, including unanswered defaults."),
+  steps: z2.array(stepSchema).min(1).describe("Ordered list of changes. Each step says what and why, with file references."),
+  acceptanceCriteria: z2.array(z2.string().min(1)).min(2).describe(
+    "Concrete, deterministically-checkable conditions that together define done. Each names a trigger/precondition and the exact observable result (run X -> output Y; file Z contains W; f(a) returns b) \u2014 no vague adjectives, not a restatement of a step. The set must collectively cover every step's change. At least 2 required."
+  ),
+  risks: z2.array(z2.string()).describe("Anything that could change the approach."),
+  outOfScope: z2.array(z2.string()).describe("What is deliberately not being done.")
+};
+var planSchema = z2.object(planInputSchema);
+function renderPlan(plan) {
+  const lines2 = [];
+  lines2.push(`# ${plan.title}`);
+  lines2.push("");
+  lines2.push(`**Scope** \u2014 \`${plan.scope}\``);
+  lines2.push("");
+  lines2.push(`**Goal** \u2014 ${plan.goal}`);
+  if (plan.assumptions.length > 0) {
+    lines2.push("");
+    lines2.push("**Assumptions**");
+    for (const assumption of plan.assumptions) {
+      lines2.push(`- ${assumption}`);
+    }
   }
-}
-async function ensureGitIdentity(dir, identity) {
-  await git(["-C", dir, "config", "user.email", identity.email]);
-  await git(["-C", dir, "config", "user.name", identity.name]);
-}
-function cloneUrl(ctx) {
-  const { owner, name, cloneToken } = ctx.repo;
-  return `https://x-access-token:${cloneToken}@github.com/${owner}/${name}.git`;
-}
-function detectPackageManager(dir) {
-  if (!existsSync2(join3(dir, "package.json"))) return null;
-  if (existsSync2(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join3(dir, "yarn.lock"))) return "yarn";
-  if (existsSync2(join3(dir, "package-lock.json"))) return "npm";
-  if (existsSync2(join3(dir, "bun.lockb"))) return "bun";
-  return "npm";
-}
-async function installDependencies(dir) {
-  const manager = detectPackageManager(dir);
-  if (manager === null) return { status: "skipped" };
-  const env = { ...process.env, CI: "1", ADBLOCK: "1", DISABLE_OPENCOLLECTIVE: "1" };
-  logEvent("install", `${manager} install`);
-  try {
-    const result = await exec(manager, ["install"], {
-      cwd: dir,
-      maxBuffer: MAX_BUFFER,
-      env,
-      timeout: 5 * 6e4
-    });
-    if (result.stdout.trim()) logEvent("install:out", result.stdout.trim());
-    if (result.stderr.trim()) logEvent("install:err", result.stderr.trim());
-    return { status: "installed", manager };
-  } catch (err) {
-    const e = err;
-    const detail = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean).join("\n");
-    logEvent("install:err", detail || (err instanceof Error ? err.message : String(err)));
-    return { status: "failed", manager, error: err instanceof Error ? err.message : String(err) };
+  lines2.push("");
+  lines2.push("## Steps");
+  for (const [i, step] of plan.steps.entries()) {
+    lines2.push("");
+    lines2.push(`### ${i + 1}. ${step.title}`);
+    lines2.push("");
+    lines2.push(step.description);
+    if (step.pseudoCode && step.pseudoCode.length > 0) {
+      for (const entry of step.pseudoCode) {
+        lines2.push("");
+        lines2.push(`\`${entry.file}\``);
+        lines2.push("");
+        lines2.push("```");
+        lines2.push(entry.pseudoCode);
+        lines2.push("```");
+      }
+    }
   }
-}
-async function makeWorkspace() {
-  return mkdtemp(join3(tmpdir(), WORKSPACE_PREFIX));
-}
-var MAX_WORKSPACES = 8;
-var workspaceRegistry = /* @__PURE__ */ new Map();
-async function acquireWorkspace(key) {
-  const existing = workspaceRegistry.get(key);
-  if (existing !== void 0 && existsSync2(existing)) {
-    workspaceRegistry.delete(key);
-    workspaceRegistry.set(key, existing);
-    return { dir: existing, reused: true };
+  lines2.push("");
+  lines2.push("## Acceptance criteria");
+  for (const criterion of plan.acceptanceCriteria) {
+    lines2.push(`- [ ] ${criterion}`);
   }
-  const dir = await makeWorkspace();
-  workspaceRegistry.set(key, dir);
-  if (workspaceRegistry.size > MAX_WORKSPACES) {
-    const oldest = workspaceRegistry.keys().next().value;
-    const oldDir = workspaceRegistry.get(oldest);
-    workspaceRegistry.delete(oldest);
-    rm(oldDir, { recursive: true, force: true }).catch(() => {
-    });
+  if (plan.risks.length > 0) {
+    lines2.push("");
+    lines2.push("**Risks / open questions**");
+    for (const risk of plan.risks) {
+      lines2.push(`- ${risk}`);
+    }
   }
-  return { dir, reused: false };
+  if (plan.outOfScope.length > 0) {
+    lines2.push("");
+    lines2.push("**Out of scope**");
+    for (const item of plan.outOfScope) {
+      lines2.push(`- ${item}`);
+    }
+  }
+  lines2.push("");
+  lines2.push(PLAN_MARKER);
+  return lines2.join("\n");
 }
-async function discardWorkspace(key) {
-  const dir = workspaceRegistry.get(key);
-  workspaceRegistry.delete(key);
-  if (dir !== void 0) {
-    await cleanup(dir).catch(() => {
-    });
+var submitPlanInputSchema = {
+  plans: z2.array(z2.object(planInputSchema)).min(1).refine(
+    (arr) => {
+      const titles = arr.map((p) => p.title.trim()).filter((t) => t.length > 0);
+      return new Set(titles).size === titles.length;
+    },
+    { message: "Each plan must have a distinct non-empty title" }
+  )
+};
+var submitPlanSchema = z2.object(submitPlanInputSchema);
+function createPlanTooling() {
+  let renderedPlans = null;
+  const submitPlan = tool2(
+    SUBMIT_PLAN,
+    "Submit ALL your plans in a single call \u2014 one entry per plan; each becomes its own independently-acceptable Accept-as-plan draft. Do NOT call submit_plan more than once. acceptanceCriteria is required in each plan and must contain at least 2 observable, verifiable conditions. The 'title' field names each specific plan \u2014 make it concise and distinct from the request title and from sibling plan titles.",
+    submitPlanInputSchema,
+    async (args) => {
+      const parsed = submitPlanSchema.parse(args);
+      renderedPlans = parsed.plans.map(renderPlan);
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Plan(s) submitted. The runner will render and post them as your comment(s). End your turn now."
+          }
+        ]
+      };
+    }
+  );
+  const mcpServer = createSdkMcpServer2({
+    name: SERVER_NAME2,
+    tools: [submitPlan]
+  });
+  return { mcpServer, getPlans: () => renderedPlans };
+}
+
+// src/report.ts
+import { createSdkMcpServer as createSdkMcpServer3, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
+var SERVER_NAME3 = "flume_report";
+var SUBMIT_REPORT = "submit_report";
+var REPORT_TOOL_NAME = `mcp__${SERVER_NAME3}__${SUBMIT_REPORT}`;
+var STATUS_ICON = {
+  met: "\u2705",
+  not_met: "\u274C",
+  unclear: "\u26A0\uFE0F"
+};
+var evidenceSchema = z3.object({
+  file: z3.string().min(1).describe("Repo-relative path the hunk comes from."),
+  hunk: z3.string().min(1).describe(
+    "A unified-diff hunk body proving the criterion \u2014 the lines that matter, not the whole file. Rendered verbatim as a ```diff block."
+  ),
+  note: z3.string().optional().describe("Optional one-line explanation of why this hunk satisfies the criterion.")
+});
+var acVerdictSchema = z3.object({
+  criterion: z3.string().min(1).describe("The acceptance-criterion text, verbatim from the plan."),
+  status: z3.enum(["met", "not_met", "unclear"]).describe("Verdict for this criterion, verified against the actual diff."),
+  rationale: z3.string().min(1).describe("One or two sentences on why the verdict holds."),
+  evidence: z3.array(evidenceSchema).describe(
+    "Diff hunks proving the verdict, copied verbatim from git --no-pager diff. Across ALL criteria the evidence must collectively cover every hunk in the diff \u2014 each changed hunk appears under at least one criterion. Cite the relevant hunk(s) for a met criterion; may be empty for not_met / unclear."
+  )
+});
+var reportInputSchema = {
+  summary: z3.string().min(1).describe("One or two sentences on what was implemented."),
+  prose: z3.string().min(1).describe(
+    "Markdown for the remaining report sections \u2014 Files changed, Build / tests, and Caveats / follow-ups. Use ## headings. Do NOT include the acceptance-criteria section here (that goes in acceptanceCriteria) and do NOT include the PR link (the runner appends it)."
+  ),
+  acceptanceCriteria: z3.array(acVerdictSchema).min(1).describe(
+    "One entry per acceptance criterion from the plan, in plan order, each with a verdict and the diff evidence behind it."
+  )
+};
+var reportSchema = z3.object(reportInputSchema);
+function renderReport(report) {
+  const lines2 = [];
+  lines2.push(report.summary.trim());
+  lines2.push("");
+  lines2.push(report.prose.trim());
+  lines2.push("");
+  lines2.push("## Acceptance criteria");
+  for (const ac of report.acceptanceCriteria) {
+    lines2.push("");
+    lines2.push(`### ${STATUS_ICON[ac.status]} ${ac.criterion}`);
+    lines2.push("");
+    lines2.push(ac.rationale.trim());
+    for (const ev of ac.evidence) {
+      lines2.push("");
+      lines2.push(ev.note ? `\`${ev.file}\` \u2014 ${ev.note}` : `\`${ev.file}\``);
+      lines2.push("");
+      lines2.push("```diff");
+      lines2.push(ev.hunk.replace(/\n+$/, ""));
+      lines2.push("```");
+    }
   }
+  return lines2.join("\n");
 }
-async function resetWorkspace(dir) {
-  await git(["-C", dir, "reset", "--hard", "HEAD"]).catch(() => {
-  });
-  await git(["-C", dir, "clean", "-fd"]).catch(() => {
+function createReportTooling() {
+  let submittedReport = null;
+  const submitReport = tool3(
+    SUBMIT_REPORT,
+    "Submit the final implementation report as structured data. Call this exactly once, at the end of the run. `acceptanceCriteria` must contain one entry per plan criterion, each with a met / not_met / unclear verdict and the diff hunk(s) that prove it. `summary` + `prose` are markdown for the rest of the report. Do NOT include a PR link \u2014 the runner appends it.",
+    reportInputSchema,
+    async (args) => {
+      submittedReport = reportSchema.parse(args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Report submitted. The runner will render and post it. End your turn now."
+          }
+        ]
+      };
+    }
+  );
+  const mcpServer = createSdkMcpServer3({
+    name: SERVER_NAME3,
+    tools: [submitReport]
   });
+  return { mcpServer, getReport: () => submittedReport };
 }
-async function prepareAtSha(ctx, dir, reused) {
-  const identity = { name: ctx.agentName, email: ctx.agentEmail };
-  if (!reused) {
-    await cloneAtSha(ctx, dir);
-    await ensureGitIdentity(dir, identity);
-    return;
-  }
-  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
-  await ensureGitIdentity(dir, identity);
+
+// src/executor.ts
+var FLUME_PLUGIN_DIR = fileURLToPath2(new URL("../skills-plugin", import.meta.url));
+function emptyUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    costUsd: 0
+  };
 }
-async function prepareResumingBranch(ctx, dir, reused) {
-  const identity = { name: ctx.agentName, email: ctx.agentEmail };
-  if (!reused) {
-    const result = await cloneResumingBranch(ctx, dir);
-    await ensureGitIdentity(dir, identity);
-    return result;
-  }
-  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
-  await ensureGitIdentity(dir, identity);
-  return { resumed: true };
+var usageAcc = emptyUsage();
+function resetUsage() {
+  usageAcc = emptyUsage();
 }
-async function sweepWorkspaces() {
-  const base = tmpdir();
-  let entries;
-  try {
-    entries = await readdir(base);
-  } catch {
-    return 0;
+function getUsage() {
+  const totalTokens = usageAcc.inputTokens + usageAcc.outputTokens + usageAcc.cacheCreationTokens + usageAcc.cacheReadTokens;
+  return { ...usageAcc, totalTokens };
+}
+function stringifyResult(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map(
+      (c) => typeof c === "object" && c !== null && "text" in c ? String(c.text) : JSON.stringify(c)
+    ).join("\n");
   }
-  let removed = 0;
-  for (const entry of entries) {
-    if (!entry.startsWith(WORKSPACE_PREFIX)) continue;
-    try {
-      await rm(join3(base, entry), { recursive: true, force: true });
-      removed++;
-    } catch {
+  return JSON.stringify(content);
+}
+async function runClaudeCode(opts) {
+  let finalText = "";
+  const { mcpServer, collected } = createWidgetTooling();
+  const { mcpServer: planServer, getPlans } = createPlanTooling();
+  const { mcpServer: reportServer, getReport } = createReportTooling();
+  for await (const message of query({
+    prompt: opts.prompt,
+    options: {
+      cwd: opts.cwd,
+      permissionMode: opts.permissionMode,
+      allowDangerouslySkipPermissions: opts.permissionMode === "bypassPermissions",
+      ...opts.model ? { model: opts.model } : {},
+      ...opts.abortController ? { abortController: opts.abortController } : {},
+      maxTurns: opts.maxTurns ?? 40,
+      // Hermetic: ignore ALL config from the checked-out repo (CLAUDE.md,
+      // .claude/settings.json, .claude/skills, …) and the runner owner's
+      // ~/.claude. Only our plugin's skills are exposed to the agent. Auto-memory
+      // is disabled separately via CLAUDE_CODE_DISABLE_AUTO_MEMORY (see cli.ts).
+      settingSources: [],
+      plugins: [{ type: "local", path: FLUME_PLUGIN_DIR }],
+      // Pre-approve the widget, plan, and Task tools so they run without a
+      // permission prompt in headless mode (allow-listing pre-approves them; it
+      // does NOT restrict anything else). Task lets the implement-plan
+      // orchestrator spawn its subagents; without pre-approval the spawn could
+      // stall waiting for an approval no one can give.
+      mcpServers: { flume_widgets: mcpServer, flume_plan: planServer, flume_report: reportServer },
+      allowedTools: [...WIDGET_TOOL_NAMES, PLAN_TOOL_NAME, REPORT_TOOL_NAME, "Task"]
+    }
+  })) {
+    if (message.type === "assistant") {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block && block.type === "text" && typeof block.text === "string") {
+            process.stdout.write(block.text);
+            logEvent("agent", block.text);
+          } else if (block && block.type === "tool_use") {
+            logEvent("tool_use", `${block.name} ${JSON.stringify(block.input)}`);
+          }
+        }
+      }
+    } else if (message.type === "user") {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block && block.type === "tool_result") {
+            logEvent("tool_result", stringifyResult(block.content));
+          }
+        }
+      }
+    } else if (message.type === "result") {
+      finalText = message.result ?? "";
+      logEvent("result", finalText);
+      const resultMsg = message;
+      if (resultMsg.usage) {
+        usageAcc.inputTokens += resultMsg.usage.input_tokens ?? 0;
+        usageAcc.outputTokens += resultMsg.usage.output_tokens ?? 0;
+        usageAcc.cacheCreationTokens += resultMsg.usage.cache_creation_input_tokens ?? 0;
+        usageAcc.cacheReadTokens += resultMsg.usage.cache_read_input_tokens ?? 0;
+      }
+      usageAcc.costUsd += resultMsg.total_cost_usd ?? 0;
+    } else if (message.type === "system") {
+      logEvent("system", JSON.stringify(message));
     }
   }
-  return removed;
-}
-async function cloneAtSha(ctx, dir) {
-  await git(["clone", "--quiet", cloneUrl(ctx), dir]);
-  await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, ctx.repo.checkoutSha]);
+  process.stdout.write("\n");
+  if (opts.abortController?.signal.aborted) {
+    throw new Error("Run canceled by user");
+  }
+  return { text: finalText, widgets: collected, plans: getPlans(), report: getReport() };
 }
-async function cloneResumingBranch(ctx, dir) {
-  await git(["clone", "--quiet", cloneUrl(ctx), dir]);
+
+// src/health.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+var PROBE_TIMEOUT_MS = 6e4;
+async function checkClaudeCode() {
   try {
-    await git(["-C", dir, "fetch", "--quiet", "origin", ctx.repo.checkoutBranch]);
-    await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, "FETCH_HEAD"]);
-    return { resumed: true };
-  } catch {
-    await git(["-C", dir, "checkout", "-B", ctx.repo.checkoutBranch, ctx.repo.checkoutSha]);
-    return { resumed: false };
+    let sawResult = false;
+    const run = (async () => {
+      for await (const message of query2({
+        prompt: "Reply with the single word: ok",
+        options: { permissionMode: "bypassPermissions", maxTurns: 1 }
+      })) {
+        if (message.type === "result") {
+          sawResult = true;
+          const isError = message.is_error === true;
+          const subtype = message.subtype;
+          if (isError)
+            throw new Error(
+              subtype ? `Claude Code error: ${subtype}` : "Claude Code returned an error"
+            );
+        }
+      }
+    })();
+    await withTimeout(run, PROBE_TIMEOUT_MS, "Claude Code did not respond in time");
+    if (!sawResult) return { ready: false, error: "Claude Code produced no result" };
+    return { ready: true };
+  } catch (err) {
+    return { ready: false, error: errorMessage(err) };
   }
 }
-async function hasChanges(dir) {
-  await git(["-C", dir, "add", "-A"]);
-  const { stdout: stdout2 } = await git(["-C", dir, "status", "--porcelain"]);
-  return stdout2.trim().length > 0;
+function withTimeout(p, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
 }
-var PreCommitError = class extends Error {
-  constructor(log) {
-    super("pre-commit checks failed");
-    this.log = log;
-    this.name = "PreCommitError";
-  }
-};
-function commitFailureLog(err) {
-  const e = err;
-  const parts = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter((s) => s.length > 0);
-  return parts.length > 0 ? parts.join("\n") : e.message ?? String(err);
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-function isUnsupportedGitSubcommand(err) {
-  const e = err;
-  const text = `${typeof e.stderr === "string" ? e.stderr : ""}
-${e.message ?? ""}`;
-  return /is not a git command|unknown subcommand|usage: git hook/i.test(text);
+
+// src/rules.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var RULES_DIR = fileURLToPath3(new URL("../skills-plugin/rules", import.meta.url));
+function loadRule(name) {
+  const raw = readFileSync3(join4(RULES_DIR, `${name}.md`), "utf8");
+  return stripFrontMatter(raw).trim();
 }
-async function runRepoChecks(dir) {
-  try {
-    await git(["-C", dir, "hook", "run", "pre-commit"]);
-    logEvent("checks", "pre-commit hook passed");
-    return { ok: true, log: "", skipped: false };
-  } catch (err) {
-    if (isUnsupportedGitSubcommand(err)) {
-      logEvent("checks", "pre-commit hook skipped (git too old)");
-      return { ok: true, log: "", skipped: true };
-    }
-    const log = commitFailureLog(err);
-    logEvent("checks:err", log);
-    return { ok: false, log, skipped: false };
+function stripFrontMatter(raw) {
+  const match = raw.match(/^---\n.*?\n---\n/s);
+  return match ? raw.slice(match[0].length) : raw;
+}
+
+// src/prompt.ts
+function turnHeading(turn, agentName) {
+  if (turn.role === "user") return "User";
+  if (turn.failed) return `${agentName} (this run ended in an error)`;
+  if (turn.kind === "plan") return `${agentName} (proposed a plan)`;
+  if (turn.kind === "report") return `${agentName} (implementation report)`;
+  return agentName;
+}
+function appendThread(lines2, ctx) {
+  if (!ctx.thread || ctx.thread.length === 0) return;
+  lines2.push("", "# Conversation so far");
+  for (const turn of ctx.thread) {
+    lines2.push("", `## ${turnHeading(turn, ctx.agentName)}`, turn.content);
   }
 }
-async function commitChanges(ctx, dir) {
-  if (!await hasChanges(dir)) return false;
-  try {
-    await git(["-C", dir, "commit", "--quiet", "-m", `FlumeCode: ${jobTitle(ctx)}`]);
-  } catch (err) {
-    throw new PreCommitError(commitFailureLog(err));
+function buildPrompt(ctx) {
+  const task = ctx.permissionMode === "plan" ? `Use the \`flumecode:request-to-plan\` skill to handle this request. You are read-only and cannot modify files \u2014 clarify any ambiguity with the user first, then produce a concrete, actionable plan (the specific changes you would make and why). Cite the relevant files. Do NOT call ExitPlanMode or write the plan to a file. When the plan is ready, call the \`submit_plan\` tool with the structured plan fields; the runner renders it into the canonical plan markdown and posts it as your comment.` : `Use the \`flumecode:implement-plan\` skill to handle this request. You are the ORCHESTRATOR: do not implement, review, or write the report yourself \u2014 follow the skill to delegate each phase to subagents via the Task tool, picking the right model for each. Do not commit or push \u2014 the runner handles that.`;
+  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this request. If there is no wiki, work from the code directly.`;
+  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
+  const lines2 = [
+    `You are "${ctx.agentName}", an autonomous coding agent working inside a FlumeCode request.`,
+    `The repository ${ctx.repo.fullName} is checked out in your current working directory on branch "${ctx.repo.checkoutBranch}" at commit ${ctx.repo.checkoutSha.slice(0, 7)}.`,
+    task,
+    orient,
+    widgets
+  ];
+  if (ctx.permissionMode !== "plan") {
+    lines2.push(
+      "",
+      "These coding guidelines apply to all code produced in this run:",
+      "",
+      loadRule("coding-guideline")
+    );
   }
-  return true;
+  lines2.push("", `# Request: ${ctx.request?.title ?? ""}`);
+  if (ctx.request?.body) {
+    lines2.push("", ctx.request.body);
+  }
+  appendThread(lines2, ctx);
+  lines2.push(
+    "",
+    ctx.permissionMode === "plan" ? "Your final reply is posted verbatim as your comment in the thread \u2014 if you called `submit_plan`, the rendered plan is posted automatically; for clarifying questions, your reply text is posted as-is." : "Your final reply is posted verbatim as your comment in the thread \u2014 make it the implementation report your report subagent produced, with nothing added. The runner appends the pull-request link."
+  );
+  return lines2.join("\n");
 }
-async function pushBranch(ctx, dir) {
-  await git(["-C", dir, "push", "--quiet", "-u", "origin", ctx.repo.checkoutBranch]);
+function buildRevisePrompt(ctx) {
+  const task = `Use the \`flumecode:revise-implementation\` skill to handle this turn. The plan below was already implemented (its implementation report appears in the conversation below, tagged as such); the user is now asking to fine-tune that implementation. Decide how to respond to their latest message: if it's unclear, ask a clarifying question (as a widget); if it's a bad idea or not feasible, push back with your reasoning; if it warrants rethinking the plan, call \`submit_plan\` with a revised plan; otherwise implement the requested change. When you implement, you are the ORCHESTRATOR: delegate the work to subagents via the Task tool as the skill directs, and do not commit or push \u2014 the runner handles that, updating the existing pull request.`;
+  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this change. If there is no wiki, work from the code directly.`;
+  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
+  const lines2 = [
+    `You are "${ctx.agentName}", an autonomous coding agent fine-tuning an implemented FlumeCode plan in an ongoing thread with the user.`,
+    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the plan's implementation branch "${ctx.repo.checkoutBranch}" \u2014 the same branch its open pull request is built from, so any change you push updates that PR.`,
+    task,
+    orient,
+    widgets,
+    "",
+    "These coding guidelines apply to all code produced in this run:",
+    "",
+    loadRule("coding-guideline"),
+    "",
+    `# Plan: ${ctx.request?.title ?? ""}`
+  ];
+  if (ctx.request?.body) {
+    lines2.push("", ctx.request.body);
+  }
+  appendThread(lines2, ctx);
+  lines2.push(
+    "",
+    "The last message above is the user's request for this turn. Your final reply is posted verbatim as your comment in the plan thread: if you implemented a change, make it a short report of what you changed (the runner appends the pull-request link); if you asked a question, called `submit_plan`, or pushed back, your reply text is posted as-is."
+  );
+  return lines2.join("\n");
 }
-var RebaseConflictError = class extends Error {
-  constructor(mergeBranch, files) {
-    const list = files.length ? `: ${files.join(", ")}` : "";
-    super(`Rebase onto ${mergeBranch} hit conflicts in ${files.length} file(s)${list}`);
-    this.mergeBranch = mergeBranch;
-    this.files = files;
-    this.name = "RebaseConflictError";
+function buildResolvePrompt(ctx, related = []) {
+  const mergeBranch = ctx.repo.mergeBranch ?? "the merge branch";
+  const task = `Use the \`flumecode:resolve-merge-conflict\` skill to handle this turn. A merge of \`${mergeBranch}\` into this branch is IN PROGRESS and has left conflict markers in your working tree. Resolve every conflicted file by correctly integrating BOTH sides \u2014 the change this session implemented (described below) and the incoming changes from \`${mergeBranch}\` \u2014 never blindly discard either side. Remove all conflict markers and verify the result builds and tests pass. Do NOT \`git add\`, commit, push, or open a pull request \u2014 the runner finalizes the merge commit and updates the existing pull request.`;
+  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to the conflicting code. If there is no wiki, work from the code directly.`;
+  const lines2 = [
+    `You are "${ctx.agentName}", an autonomous coding agent resolving merge conflicts on an implemented FlumeCode plan.`,
+    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the plan's implementation branch "${ctx.repo.checkoutBranch}" \u2014 the same branch its open pull request is built from \u2014 with an in-progress merge of "${mergeBranch}".`,
+    task,
+    orient,
+    "",
+    "These coding guidelines apply to all code produced in this run:",
+    "",
+    loadRule("coding-guideline"),
+    "",
+    `# Plan: ${ctx.request?.title ?? ""}`
+  ];
+  if (ctx.request?.body) {
+    lines2.push("", ctx.request.body);
   }
-};
-async function rebaseOntoMergeBranch(ctx, dir) {
-  const { mergeBranch } = ctx.repo;
-  if (!mergeBranch) return;
-  await git(["-C", dir, "fetch", "--quiet", "origin", mergeBranch]);
-  try {
-    await git(["-C", dir, "rebase", "--empty=drop", "FETCH_HEAD"]);
-  } catch (err) {
-    const conflicted = await git(["-C", dir, "diff", "--name-only", "--diff-filter=U"]).catch(
-      () => ({ stdout: "" })
+  appendThread(lines2, ctx);
+  if (related.length > 0) {
+    lines2.push(
+      "",
+      "# Related sessions behind the incoming changes",
+      "Each conflicting change on the merge branch came from another coding session whose plan and report follow. Preserve THEIR intent too while integrating them with this session's work \u2014 do not undo what they built."
     );
-    const files = conflicted.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-    await git(["-C", dir, "rebase", "--abort"]).catch(() => {
-    });
-    if (files.length === 0) throw err;
-    throw new RebaseConflictError(mergeBranch, files);
+    for (const r of related) {
+      lines2.push("", `## PR #${r.prNumber} \u2014 ${r.title}`);
+      if (r.plan) lines2.push("", "### Accepted plan", r.plan);
+      if (r.report) lines2.push("", "### Final report", r.report);
+    }
   }
+  lines2.push(
+    "",
+    "Resolve the conflicts now. Your final reply is posted as a report in the plan thread: summarize which files conflicted and how you resolved each (the runner appends the pull-request link, so don't add one)."
+  );
+  return lines2.join("\n");
 }
-async function mergeInMergeBranch(ctx, dir) {
-  const { mergeBranch } = ctx.repo;
-  if (!mergeBranch) return { conflicted: false };
-  await git(["-C", dir, "fetch", "--quiet", "origin", mergeBranch]);
-  try {
-    await git(["-C", dir, "merge", "--no-edit", "FETCH_HEAD"]);
-    return { conflicted: false };
-  } catch {
-    return { conflicted: true };
+function buildDocumentPrompt(ctx) {
+  const lines2 = [
+    `You are "${ctx.agentName}" maintaining the repository wiki for ${ctx.repo.fullName}.`,
+    `An implementation just ran in this working directory to satisfy the request below; its changes are uncommitted in the working tree.`,
+    `Use the \`flumecode:document\` skill to bring the wiki in sync with those changes. Only edit files under \`.flumecode/wiki/\` \u2014 do not touch application code. The runner commits the wiki alongside the implementation in the same pull request.`,
+    "",
+    `# Request: ${ctx.request?.title ?? ""}`
+  ];
+  if (ctx.request?.body) {
+    lines2.push("", ctx.request.body);
   }
+  appendThread(lines2, ctx);
+  lines2.push("", "When done, reply with a one- or two-line summary of the wiki changes you made.");
+  return lines2.join("\n");
 }
-async function listUnmergedPaths(dir) {
-  const { stdout: stdout2 } = await git(["-C", dir, "diff", "--name-only", "--diff-filter=U"]).catch(() => ({
-    stdout: ""
-  }));
-  return stdout2.split("\n").map((line) => line.trim()).filter(Boolean);
+function buildRepairPrompt(ctx, hookLog) {
+  const lines2 = [
+    `You are "${ctx.agentName}", fixing a failed pre-commit check in the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
+    `The changes from the previous step are still uncommitted in the working tree. When the runner tried to commit them, the repository's pre-commit hook \u2014 which runs the project's own checks (lint / typecheck / unit tests) \u2014 failed. Make the working tree pass those checks: fix the failing code or tests at their root. Do NOT delete or skip tests, weaken assertions, or disable the checks to silence the failure. Preserve the intent of the original change; repair only what's broken. Do NOT commit or push \u2014 the runner re-commits once the checks pass.`,
+    "",
+    "These coding guidelines apply to all code produced in this run:",
+    "",
+    loadRule("coding-guideline"),
+    "",
+    "# Pre-commit hook output",
+    "",
+    "```",
+    hookLog,
+    "```",
+    "",
+    "When done, reply with a one-line summary of what you fixed."
+  ];
+  return lines2.join("\n");
 }
-async function openPullRequest(ctx) {
-  const { owner, name, cloneToken, checkoutBranch, mergeBranch } = ctx.repo;
-  if (!mergeBranch) return null;
-  const apiBase = `https://api.github.com/repos/${owner}/${name}`;
-  const headers = {
-    authorization: `Bearer ${cloneToken}`,
-    accept: "application/vnd.github+json",
-    "x-github-api-version": "2022-11-28",
-    "content-type": "application/json"
-  };
-  const title = jobTitle(ctx);
-  const body = ctx.kind === "init" ? "Bootstraps the `.flumecode/` wiki for this repository. Opened by the FlumeCode runner." : `Opened by the FlumeCode runner for request "${title}".`;
-  const res = await fetch(`${apiBase}/pulls`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      title: `FlumeCode: ${title}`,
-      head: checkoutBranch,
-      base: mergeBranch,
-      body
-    })
-  });
-  if (res.status === 201) {
-    const data = await res.json();
-    return { number: data.number, url: data.html_url };
+function buildReleasePrompt(ctx, baseChecks) {
+  const task = `Use the \`flumecode:create-release\` skill to handle this turn. You are driving a release: first analyse commits since the last tag, propose version bumps, and ask the user to confirm via widgets (Phase 1); once the user's widget answers appear in the thread, apply the bumps to package.json files and update CHANGELOG.md (Phase 2). Do NOT commit or push \u2014 the runner handles that and opens the bump PR.`;
+  const orient = `Before investigating raw source, check for a FlumeCode wiki at \`.flumecode/wiki/\`. If it exists, read \`.flumecode/wiki/README.md\` first \u2014 it is the index \u2014 and follow its links to the pages and source paths relevant to this release. If there is no wiki, work from the code directly.`;
+  const widgets = `When you need the user to choose, ask it as a widget rather than writing the options as prose: call \`single_select\` for a one-of-N choice (radio buttons) or \`multi_select\` for a "select all that apply" choice (checkboxes). Don't add your own "Other" option \u2014 the UI always provides one. After calling a widget tool, end your turn \u2014 the user's answer comes back as their next message and starts a fresh run.`;
+  const lines2 = [
+    `You are "${ctx.agentName}", an autonomous coding agent driving a FlumeCode release.`,
+    `The repository ${ctx.repo.fullName} is checked out in your current working directory on the release bump branch "${ctx.repo.checkoutBranch}".`,
+    task,
+    orient,
+    widgets,
+    "",
+    "These coding guidelines apply to all code produced in this run:",
+    "",
+    loadRule("coding-guideline"),
+    "",
+    `# Release: ${ctx.request?.title ?? ""}`
+  ];
+  if (ctx.request?.body) {
+    lines2.push("", ctx.request.body);
   }
-  if (res.status === 422) {
-    const list = await fetch(
-      `${apiBase}/pulls?state=open&head=${owner}:${checkoutBranch}&base=${mergeBranch}`,
-      { headers }
+  if (baseChecks && !baseChecks.ok) {
+    lines2.push(
+      "",
+      "# Pre-release check status",
+      "",
+      "\u26A0\uFE0F The repository's pre-commit checks (lint / typecheck / tests) are currently FAILING on the base branch, independently of any version bump. A release must not ship a broken base:",
+      "",
+      "- **Phase 1 (propose):** tell the user, in your reply, that the base currently fails these checks and that the release will fix them as part of the bump.",
+      "- **Phase 2 (apply):** fix the failing code at its root so the checks pass, THEN apply the version bumps and CHANGELOG. Do NOT delete/skip tests or weaken assertions. The fixes ship in the same bump PR. Still do NOT commit or push \u2014 the runner does.",
+      "",
+      "Failing check output:",
+      "",
+      "```",
+      baseChecks.log,
+      "```"
     );
-    if (list.ok) {
-      const open = await list.json();
-      if (open[0]) return { number: open[0].number, url: open[0].html_url };
-    }
-    return null;
   }
-  throw new Error(`PR creation failed: ${res.status} ${await res.text()}`);
+  appendThread(lines2, ctx);
+  lines2.push(
+    "",
+    "Your final reply is posted verbatim as your comment in the release thread \u2014 if you called widgets (Phase 1), your reply text accompanies the questions; if you applied the bumps (Phase 2), make it the report the skill produced. The runner appends the pull-request link."
+  );
+  return lines2.join("\n");
 }
-async function cleanup(dir) {
-  await rm(dir, { recursive: true, force: true });
+function buildInitPrompt(ctx) {
+  return [
+    `You are "${ctx.agentName}" initializing FlumeCode for the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
+    `Use the \`flumecode:document\` skill to create the initial repository wiki under \`.flumecode/wiki/\`. The wiki does not exist yet, so the skill will bootstrap it: survey the codebase and produce a high-level overview plus per-component pages. Only create files under \`.flumecode/\` \u2014 do not modify application code. The runner commits the result and opens a pull request.`,
+    "",
+    "When done, reply with a one- or two-line summary of the wiki you created."
+  ].join("\n");
 }
 
 // src/run.ts
@@ -1093,7 +1288,7 @@ var MAX_IMPLEMENT_RETRIES = 1;
 var INIT_MAX_TURNS = 200;
 var DOCUMENT_MAX_TURNS = 120;
 var HEARTBEAT_MS = 5 * 6e4;
-async function pushAndOpenPr(ctx, dir, abort, opts = { rebase: true }) {
+async function pushAndOpenPr(ctx, dir, config, abort, opts = { rebase: true }) {
   if (abort.signal.aborted) throw new Error("Run canceled by user");
   const committed = await commitWithRepair(ctx, dir, abort);
   if (!committed) return { outcome: { kind: "none" }, autoMerged: false };
@@ -1107,8 +1302,8 @@ async function pushAndOpenPr(ctx, dir, abort, opts = { rebase: true }) {
       console.warn(
         `  rebase onto ${ctx.repo.mergeBranch} conflicted \u2014 merging it in and resolving with the agent\u2026`
       );
-      await mergeAndResolveConflicts(ctx, dir, abort);
-      await commitWithRepair(ctx, dir, abort);
+      await mergeAndResolveConflicts(ctx, dir, config, abort);
+      await commitWithRepair(ctx, dir, abort, { skipSocket: true });
       autoMerged = true;
     }
   }
@@ -1116,28 +1311,36 @@ async function pushAndOpenPr(ctx, dir, abort, opts = { rebase: true }) {
   const pr = await openPullRequest(ctx);
   return { outcome: pr ? { kind: "pr", pr } : { kind: "pushed" }, autoMerged };
 }
-async function mergeAndResolveConflicts(ctx, dir, abort) {
+async function mergeAndResolveConflicts(ctx, dir, config, abort) {
   const { conflicted } = await mergeInMergeBranch(ctx, dir);
   if (!conflicted) return { resolved: false, text: null };
+  const conflictedPaths = await listUnmergedPaths(dir);
+  const prNumbers = await incomingPrNumbers(ctx, dir, conflictedPaths);
+  const related = await fetchRelatedSessions(config, {
+    owner: ctx.repo.owner,
+    name: ctx.repo.name,
+    prNumbers
+  });
   const result = await runClaudeCode({
     cwd: dir,
-    prompt: buildResolvePrompt(ctx),
+    prompt: buildResolvePrompt(ctx, related),
     permissionMode: ctx.permissionMode,
     model: ORCHESTRATOR_MODEL,
     maxTurns: ORCHESTRATOR_MAX_TURNS,
     abortController: abort
   });
-  const unresolved = await listUnmergedPaths(dir);
+  const unresolved = await listConflictMarkerPaths(dir, conflictedPaths);
   if (unresolved.length > 0) {
     throw new Error(
-      `Could not fully resolve the merge \u2014 ${unresolved.length} file(s) still conflict: ${unresolved.join(", ")}`
+      `Could not fully resolve the merge \u2014 ${unresolved.length} file(s) still contain conflict markers: ${unresolved.join(", ")}`
     );
   }
   return { resolved: true, text: result.text.trim() || null };
 }
-async function commitWithRepair(ctx, dir, abort) {
+async function commitWithRepair(ctx, dir, abort, opts = {}) {
   for (let attempt = 1; ; attempt++) {
     try {
+      if (!opts.skipSocket) await runSocket("pre-commit", dir);
       return await commitChanges(ctx, dir);
     } catch (err) {
       if (!(err instanceof PreCommitError) || attempt > MAX_COMMIT_REPAIRS) throw err;
@@ -1176,38 +1379,38 @@ function outcomeBanner(outcome, opts) {
 \u2139\uFE0F **No code changes were made** \u2014 ${opts.noChange ?? "there was nothing to open a pull request for."}`;
   }
 }
-async function processJob(ctx, abort = new AbortController()) {
+async function processJob(ctx, config, abort = new AbortController()) {
   const { dir, reused } = await acquireWorkspace(ctx.workspaceKey);
   let prepared = false;
   try {
     if (ctx.kind === "init") {
       await prepareAtSha(ctx, dir, reused);
       prepared = true;
-      return await processInitJob(ctx, dir, abort);
+      return await processInitJob(ctx, dir, config, abort);
     }
     if (ctx.kind === "implement") {
       const { resumed } = await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processImplementJob(ctx, dir, resumed, abort);
+      return await processImplementJob(ctx, dir, resumed, config, abort);
     }
     if (ctx.kind === "revise") {
       const { resumed } = await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processReviseJob(ctx, dir, resumed, abort);
+      return await processReviseJob(ctx, dir, resumed, config, abort);
     }
     if (ctx.kind === "resolve") {
       await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processResolveJob(ctx, dir, abort);
+      return await processResolveJob(ctx, dir, config, abort);
     }
     if (ctx.kind === "release") {
       const { resumed } = await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processReleaseJob(ctx, dir, resumed, abort);
+      return await processReleaseJob(ctx, dir, resumed, config, abort);
     }
     await prepareAtSha(ctx, dir, reused);
     prepared = true;
-    return await processChatJob(ctx, dir, abort);
+    return await processChatJob(ctx, dir, config, abort);
   } catch (err) {
     if (abort.signal.aborted && prepared) {
       await resetWorkspace(dir);
@@ -1217,7 +1420,7 @@ async function processJob(ctx, abort = new AbortController()) {
     throw err;
   }
 }
-async function processInitJob(ctx, dir, abort) {
+async function processInitJob(ctx, dir, config, abort) {
   console.log(`
 \u25B6 Init ${ctx.jobId} \u2014 ${ctx.repo.fullName} on ${ctx.repo.checkoutBranch}`);
   const summary = (await runClaudeCode({
@@ -1228,7 +1431,7 @@ async function processInitJob(ctx, dir, abort) {
     abortController: abort
   })).text.trim();
   let reply = summary || "(the agent produced no summary)";
-  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort);
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, config, abort);
   reply += outcomeBanner(outcome, {
     branch: ctx.repo.checkoutBranch,
     noChange: "no files were generated; the wiki may already exist.",
@@ -1236,7 +1439,7 @@ async function processInitJob(ctx, dir, abort) {
   });
   return { text: reply, widgets: [] };
 }
-async function processChatJob(ctx, dir, abort) {
+async function processChatJob(ctx, dir, config, abort) {
   console.log(`
 \u25B6 Job ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const orchestrating = ctx.permissionMode !== "plan";
@@ -1278,14 +1481,14 @@ async function processChatJob(ctx, dir, abort) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort);
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, config, abort);
   reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   return { text: reply, widgets: [] };
 }
 function reportClaimsWork(report) {
   return !!report && report.acceptanceCriteria.some((ac) => ac.status === "met" && ac.evidence.length > 0);
 }
-async function processImplementJob(ctx, dir, resumed, abort) {
+async function processImplementJob(ctx, dir, resumed, config, abort) {
   console.log(`
 \u25B6 Implement ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
@@ -1333,7 +1536,9 @@ async function processImplementJob(ctx, dir, resumed, abort) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, config, abort, {
+    rebase: !resumed
+  });
   reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   return {
     text: reply,
@@ -1342,7 +1547,7 @@ async function processImplementJob(ctx, dir, resumed, abort) {
     ...outcome.kind === "pr" ? { pr: outcome.pr } : {}
   };
 }
-async function processReviseJob(ctx, dir, resumed, abort) {
+async function processReviseJob(ctx, dir, resumed, config, abort) {
   console.log(`
 \u25B6 Revise ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
@@ -1382,7 +1587,9 @@ async function processReviseJob(ctx, dir, resumed, abort) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, config, abort, {
+    rebase: !resumed
+  });
   if (outcome.kind !== "none") {
     reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   }
@@ -1393,11 +1600,11 @@ async function processReviseJob(ctx, dir, resumed, abort) {
     ...result.plans?.length ? { plans: result.plans } : {}
   };
 }
-async function processResolveJob(ctx, dir, abort) {
+async function processResolveJob(ctx, dir, config, abort) {
   console.log(`
 \u25B6 Resolve ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
-  const { resolved, text } = await mergeAndResolveConflicts(ctx, dir, abort);
+  const { resolved, text } = await mergeAndResolveConflicts(ctx, dir, config, abort);
   let reply = resolved ? text || "(the agent produced no report)" : `Merged \`${ctx.repo.mergeBranch ?? "the merge branch"}\` into \`${ctx.repo.checkoutBranch}\` cleanly \u2014 there were no conflicts to resolve.`;
   if (installResult.status === "failed") {
     reply += `
@@ -1405,14 +1612,14 @@ async function processResolveJob(ctx, dir, abort) {
 > \u26A0\uFE0F Dependencies failed to install (\`${installResult.manager}\`); tests may not have run.`;
   }
   if (abort.signal.aborted) throw new Error("Run canceled by user");
-  await commitWithRepair(ctx, dir, abort);
+  await commitWithRepair(ctx, dir, abort, { skipSocket: true });
   await pushBranch(ctx, dir);
   const pr = await openPullRequest(ctx);
   const outcome = pr ? { kind: "pr", pr } : { kind: "pushed" };
   reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch });
   return { text: reply, widgets: [], ...pr ? { pr } : {} };
 }
-async function processReleaseJob(ctx, dir, resumed, abort) {
+async function processReleaseJob(ctx, dir, resumed, config, abort) {
   console.log(`
 \u25B6 Release ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
@@ -1443,7 +1650,9 @@ async function processReleaseJob(ctx, dir, resumed, abort) {
     );
     return { text: reply, widgets: result.widgets };
   }
-  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, config, abort, {
+    rebase: !resumed
+  });
   if (outcome.kind !== "none") {
     reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, autoMerged });
   }
@@ -1516,14 +1725,17 @@ async function pollLoop(config) {
       };
       scheduleCancelPoll();
       try {
-        const { text, widgets, pr, plans, report } = await processJob(ctx, abort);
+        resetUsage();
+        const { text, widgets, pr, plans, report } = await processJob(ctx, config, abort);
+        const usage = getUsage();
         await reportJob(config, ctx.jobId, {
           status: "done",
           text,
           widgets,
           pr,
           ...plans?.length ? { plans } : {},
-          ...report ? { report } : {}
+          ...report ? { report } : {},
+          ...usage.totalTokens > 0 ? { usage } : {}
         });
         console.log(`\u2713 Job ${ctx.jobId} done`);
       } catch (err) {