@flumecode/runner 0.9.0 → 0.11.0

package/dist/cli.js

@@ -136,6 +136,38 @@ async function reportHeartbeat(config, claudeCode) {
   noteServerVersion(res);
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status} ${await safeText(res)}`);
 }
+async function uploadJobLog(config, jobId, content) {
+  const res = await fetch(`${config.serverUrl}/api/runner/jobs/${jobId}/logs`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      "content-type": "application/json",
+      [RUNNER_VERSION_HEADER]: RUNNER_VERSION
+    },
+    body: JSON.stringify({ 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();
@@ -144,6 +176,467 @@ async function safeText(res) {
   }
 }
 
+// src/plugins/socket.ts
+import { exec as execCb } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+
+// 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";
+}
+
+// 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) + `
+
+\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;
+  }
+}
+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) };
+  }
+}
+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 };
+  }
+  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(() => {
+    });
+  }
+  return { dir, reused: false };
+}
+async function discardWorkspace(key) {
+  const dir = workspaceRegistry.get(key);
+  workspaceRegistry.delete(key);
+  if (dir !== void 0) {
+    await cleanup(dir).catch(() => {
+    });
+  }
+}
+async function resetWorkspace(dir) {
+  await git(["-C", dir, "reset", "--hard", "HEAD"]).catch(() => {
+  });
+  await git(["-C", dir, "clean", "-fd"]).catch(() => {
+  });
+}
+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);
+}
+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 {
+    }
+  }
+  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]);
+}
+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 };
+  }
+}
+async function hasChanges(dir) {
+  await git(["-C", dir, "add", "-A"]);
+  const { stdout: stdout2 } = await git(["-C", dir, "status", "--porcelain"]);
+  return stdout2.trim().length > 0;
+}
+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 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 };
+  }
+}
+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 true;
+}
+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 {
+    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: "" })
+    );
+    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);
+  }
+}
+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 };
+  }
+}
+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);
+}
+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);
+}
+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()}`);
+}
+async function cleanup(dir) {
+  await rm(dir, { recursive: true, force: true });
+}
+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 [];
+  }
+}
+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 [];
+  }
+}
+
+// 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 [];
+  }
+  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;
+}
+
+// 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}`);
+    }
+  }
+}
+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 };
+  }
+}
+
 // src/executor.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -252,59 +745,59 @@ var planInputSchema = {
 };
 var planSchema = z2.object(planInputSchema);
 function renderPlan(plan) {
-  const lines = [];
-  lines.push(`# ${plan.title}`);
-  lines.push("");
-  lines.push(`**Scope** \u2014 \`${plan.scope}\``);
-  lines.push("");
-  lines.push(`**Goal** \u2014 ${plan.goal}`);
+  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) {
-    lines.push("");
-    lines.push("**Assumptions**");
+    lines2.push("");
+    lines2.push("**Assumptions**");
     for (const assumption of plan.assumptions) {
-      lines.push(`- ${assumption}`);
+      lines2.push(`- ${assumption}`);
     }
   }
-  lines.push("");
-  lines.push("## Steps");
+  lines2.push("");
+  lines2.push("## Steps");
   for (const [i, step] of plan.steps.entries()) {
-    lines.push("");
-    lines.push(`### ${i + 1}. ${step.title}`);
-    lines.push("");
-    lines.push(step.description);
+    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) {
-        lines.push("");
-        lines.push(`\`${entry.file}\``);
-        lines.push("");
-        lines.push("```");
-        lines.push(entry.pseudoCode);
-        lines.push("```");
+        lines2.push("");
+        lines2.push(`\`${entry.file}\``);
+        lines2.push("");
+        lines2.push("```");
+        lines2.push(entry.pseudoCode);
+        lines2.push("```");
       }
     }
   }
-  lines.push("");
-  lines.push("## Acceptance criteria");
+  lines2.push("");
+  lines2.push("## Acceptance criteria");
   for (const criterion of plan.acceptanceCriteria) {
-    lines.push(`- [ ] ${criterion}`);
+    lines2.push(`- [ ] ${criterion}`);
   }
   if (plan.risks.length > 0) {
-    lines.push("");
-    lines.push("**Risks / open questions**");
+    lines2.push("");
+    lines2.push("**Risks / open questions**");
     for (const risk of plan.risks) {
-      lines.push(`- ${risk}`);
+      lines2.push(`- ${risk}`);
     }
   }
   if (plan.outOfScope.length > 0) {
-    lines.push("");
-    lines.push("**Out of scope**");
+    lines2.push("");
+    lines2.push("**Out of scope**");
     for (const item of plan.outOfScope) {
-      lines.push(`- ${item}`);
+      lines2.push(`- ${item}`);
     }
   }
-  lines.push("");
-  lines.push(PLAN_MARKER);
-  return lines.join("\n");
+  lines2.push("");
+  lines2.push(PLAN_MARKER);
+  return lines2.join("\n");
 }
 var submitPlanInputSchema = {
   plans: z2.array(z2.object(planInputSchema)).min(1).refine(
@@ -379,27 +872,27 @@ var reportInputSchema = {
 };
 var reportSchema = z3.object(reportInputSchema);
 function renderReport(report) {
-  const lines = [];
-  lines.push(report.summary.trim());
-  lines.push("");
-  lines.push(report.prose.trim());
-  lines.push("");
-  lines.push("## Acceptance criteria");
+  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) {
-    lines.push("");
-    lines.push(`### ${STATUS_ICON[ac.status]} ${ac.criterion}`);
-    lines.push("");
-    lines.push(ac.rationale.trim());
+    lines2.push("");
+    lines2.push(`### ${STATUS_ICON[ac.status]} ${ac.criterion}`);
+    lines2.push("");
+    lines2.push(ac.rationale.trim());
     for (const ev of ac.evidence) {
-      lines.push("");
-      lines.push(ev.note ? `\`${ev.file}\` \u2014 ${ev.note}` : `\`${ev.file}\``);
-      lines.push("");
-      lines.push("```diff");
-      lines.push(ev.hunk.replace(/\n+$/, ""));
-      lines.push("```");
+      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 lines.join("\n");
+  return lines2.join("\n");
 }
 function createReportTooling() {
   let submittedReport = null;
@@ -428,6 +921,32 @@ function createReportTooling() {
 
 // 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
+  };
+}
+var usageAcc = emptyUsage();
+function resetUsage() {
+  usageAcc = emptyUsage();
+}
+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");
+  }
+  return JSON.stringify(content);
+}
 async function runClaudeCode(opts) {
   let finalText = "";
   const { mcpServer, collected } = createWidgetTooling();
@@ -463,11 +982,34 @@ async function runClaudeCode(opts) {
         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));
     }
   }
   process.stdout.write("\n");
@@ -527,11 +1069,11 @@ function errorMessage(err) {
 
 // src/rules.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join2 } from "node:path";
+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(join2(RULES_DIR, `${name}.md`), "utf8");
+  const raw = readFileSync3(join4(RULES_DIR, `${name}.md`), "utf8");
   return stripFrontMatter(raw).trim();
 }
 function stripFrontMatter(raw) {
@@ -547,18 +1089,18 @@ function turnHeading(turn, agentName) {
   if (turn.kind === "report") return `${agentName} (implementation report)`;
   return agentName;
 }
-function appendThread(lines, ctx) {
+function appendThread(lines2, ctx) {
   if (!ctx.thread || ctx.thread.length === 0) return;
-  lines.push("", "# Conversation so far");
+  lines2.push("", "# Conversation so far");
   for (const turn of ctx.thread) {
-    lines.push("", `## ${turnHeading(turn, ctx.agentName)}`, turn.content);
+    lines2.push("", `## ${turnHeading(turn, ctx.agentName)}`, turn.content);
   }
 }
 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 lines = [
+  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,
@@ -566,29 +1108,29 @@ function buildPrompt(ctx) {
     widgets
   ];
   if (ctx.permissionMode !== "plan") {
-    lines.push(
+    lines2.push(
       "",
       "These coding guidelines apply to all code produced in this run:",
       "",
       loadRule("coding-guideline")
     );
   }
-  lines.push("", `# Request: ${ctx.request?.title ?? ""}`);
+  lines2.push("", `# Request: ${ctx.request?.title ?? ""}`);
   if (ctx.request?.body) {
-    lines.push("", ctx.request.body);
+    lines2.push("", ctx.request.body);
   }
-  appendThread(lines, ctx);
-  lines.push(
+  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 lines.join("\n");
+  return lines2.join("\n");
 }
 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 lines = [
+  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,
@@ -602,20 +1144,20 @@ function buildRevisePrompt(ctx) {
     `# Plan: ${ctx.request?.title ?? ""}`
   ];
   if (ctx.request?.body) {
-    lines.push("", ctx.request.body);
+    lines2.push("", ctx.request.body);
   }
-  appendThread(lines, ctx);
-  lines.push(
+  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 lines.join("\n");
+  return lines2.join("\n");
 }
-function buildResolvePrompt(ctx) {
+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 lines = [
+  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,
@@ -628,17 +1170,29 @@ function buildResolvePrompt(ctx) {
     `# Plan: ${ctx.request?.title ?? ""}`
   ];
   if (ctx.request?.body) {
-    lines.push("", ctx.request.body);
+    lines2.push("", ctx.request.body);
+  }
+  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."
+    );
+    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);
+    }
   }
-  appendThread(lines, ctx);
-  lines.push(
+  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 lines.join("\n");
+  return lines2.join("\n");
 }
 function buildDocumentPrompt(ctx) {
-  const lines = [
+  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.`,
@@ -646,14 +1200,14 @@ function buildDocumentPrompt(ctx) {
     `# Request: ${ctx.request?.title ?? ""}`
   ];
   if (ctx.request?.body) {
-    lines.push("", ctx.request.body);
+    lines2.push("", ctx.request.body);
   }
-  appendThread(lines, ctx);
-  lines.push("", "When done, reply with a one- or two-line summary of the wiki changes you made.");
-  return lines.join("\n");
+  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 lines = [
+  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.`,
     "",
@@ -669,13 +1223,13 @@ function buildRepairPrompt(ctx, hookLog) {
     "",
     "When done, reply with a one-line summary of what you fixed."
   ];
-  return lines.join("\n");
+  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 lines = [
+  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,
@@ -689,10 +1243,10 @@ function buildReleasePrompt(ctx, baseChecks) {
     `# Release: ${ctx.request?.title ?? ""}`
   ];
   if (ctx.request?.body) {
-    lines.push("", ctx.request.body);
+    lines2.push("", ctx.request.body);
   }
   if (baseChecks && !baseChecks.ok) {
-    lines.push(
+    lines2.push(
       "",
       "# Pre-release check status",
       "",
@@ -708,12 +1262,12 @@ function buildReleasePrompt(ctx, baseChecks) {
       "```"
     );
   }
-  appendThread(lines, ctx);
-  lines.push(
+  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 lines.join("\n");
+  return lines2.join("\n");
 }
 function buildInitPrompt(ctx) {
   return [
@@ -724,273 +1278,6 @@ function buildInitPrompt(ctx) {
   ].join("\n");
 }
 
-// src/types.ts
-function jobTitle(ctx) {
-  return ctx.kind === "init" ? "Initialize FlumeCode wiki" : ctx.request?.title ?? "request";
-}
-
-// 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) {
-  return exec("git", args, { maxBuffer: MAX_BUFFER });
-}
-var RUNNER_GIT_EMAIL = "runner@flumecode.local";
-var RUNNER_GIT_NAME = "FlumeCode Runner";
-async function ensureGitIdentity(dir) {
-  await git(["-C", dir, "config", "user.email", RUNNER_GIT_EMAIL]);
-  await git(["-C", dir, "config", "user.name", RUNNER_GIT_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" };
-  try {
-    await exec(manager, ["install"], { cwd: dir, maxBuffer: MAX_BUFFER, env, timeout: 5 * 6e4 });
-    return { status: "installed", manager };
-  } catch (err) {
-    return { status: "failed", manager, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-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 };
-  }
-  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(() => {
-    });
-  }
-  return { dir, reused: false };
-}
-async function discardWorkspace(key) {
-  const dir = workspaceRegistry.get(key);
-  workspaceRegistry.delete(key);
-  if (dir !== void 0) {
-    await cleanup(dir).catch(() => {
-    });
-  }
-}
-async function resetWorkspace(dir) {
-  await git(["-C", dir, "reset", "--hard", "HEAD"]).catch(() => {
-  });
-  await git(["-C", dir, "clean", "-fd"]).catch(() => {
-  });
-}
-async function prepareAtSha(ctx, dir, reused) {
-  if (!reused) {
-    await cloneAtSha(ctx, dir);
-    await ensureGitIdentity(dir);
-    return;
-  }
-  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
-  await ensureGitIdentity(dir);
-}
-async function prepareResumingBranch(ctx, dir, reused) {
-  if (!reused) {
-    const result = await cloneResumingBranch(ctx, dir);
-    await ensureGitIdentity(dir);
-    return result;
-  }
-  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
-  await ensureGitIdentity(dir);
-  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(join3(base, entry), { recursive: true, force: true });
-      removed++;
-    } catch {
-    }
-  }
-  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]);
-}
-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 };
-  }
-}
-async function hasChanges(dir) {
-  await git(["-C", dir, "add", "-A"]);
-  const { stdout: stdout2 } = await git(["-C", dir, "status", "--porcelain"]);
-  return stdout2.trim().length > 0;
-}
-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 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"]);
-    return { ok: true, log: "", skipped: false };
-  } catch (err) {
-    if (isUnsupportedGitSubcommand(err)) return { ok: true, log: "", skipped: true };
-    return { ok: false, log: commitFailureLog(err), skipped: false };
-  }
-}
-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 true;
-}
-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 {
-    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: "" })
-    );
-    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);
-  }
-}
-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 };
-  }
-}
-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);
-}
-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()}`);
-}
-async function cleanup(dir) {
-  await rm(dir, { recursive: true, force: true });
-}
-
 // src/run.ts
 var IDLE_MS = 5e3;
 var CANCEL_POLL_MS = 2500;
@@ -1001,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 };
@@ -1015,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;
     }
   }
@@ -1024,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;
@@ -1084,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);
@@ -1125,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({
@@ -1136,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.",
@@ -1144,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";
@@ -1186,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);
@@ -1241,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,
@@ -1250,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);
@@ -1290,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 });
   }
@@ -1301,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 += `
@@ -1313,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);
@@ -1351,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 });
   }
@@ -1401,6 +1702,11 @@ async function pollLoop(config) {
         await sleep(IDLE_MS);
         continue;
       }
+      startJobLog({
+        jobId: ctx.jobId,
+        kind: ctx.kind,
+        secrets: [ctx.repo?.cloneToken ?? ""].filter(Boolean)
+      });
       const abort = new AbortController();
       let stopPolling = false;
       const scheduleCancelPoll = () => {
@@ -1419,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) {
@@ -1450,6 +1759,13 @@ async function pollLoop(config) {
         }
       } finally {
         stopPolling = true;
+        if (!abort.signal.aborted) {
+          try {
+            await uploadJobLog(config, ctx.jobId, getJobLog());
+          } catch (e) {
+            console.error(`  (failed to upload logs: ${errorMessage2(e)})`);
+          }
+        }
       }
     }
   } finally {
@@ -1467,9 +1783,9 @@ var MAX_HOOK_LOG_CHARS = 4e3;
 function trimHookLog(log) {
   let trimmed = log.trimEnd();
   let elided = false;
-  const lines = trimmed.split("\n");
-  if (lines.length > MAX_HOOK_LOG_LINES) {
-    trimmed = lines.slice(-MAX_HOOK_LOG_LINES).join("\n");
+  const lines2 = trimmed.split("\n");
+  if (lines2.length > MAX_HOOK_LOG_LINES) {
+    trimmed = lines2.slice(-MAX_HOOK_LOG_LINES).join("\n");
     elided = true;
   }
   if (trimmed.length > MAX_HOOK_LOG_CHARS) {