@flumecode/runner 0.3.2 → 0.6.0

package/dist/cli.js

@@ -97,6 +97,19 @@ async function claimJob(config) {
   if (!res.ok) throw new Error(`claim failed: ${res.status} ${await safeText(res)}`);
   return await res.json();
 }
+async function pollJobCanceling(config, jobId) {
+  const res = await fetch(`${config.serverUrl}/api/runner/jobs/${jobId}/cancel`, {
+    method: "GET",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      [RUNNER_VERSION_HEADER]: RUNNER_VERSION
+    }
+  });
+  noteServerVersion(res);
+  if (!res.ok) return false;
+  const body = await res.json();
+  return body.canceling === true;
+}
 async function reportJob(config, jobId, result) {
   const res = await fetch(`${config.serverUrl}/api/runner/jobs/${jobId}/complete`, {
     method: "POST",
@@ -328,6 +341,7 @@ async function runClaudeCode(opts) {
       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
@@ -358,6 +372,9 @@ async function runClaudeCode(opts) {
     }
   }
   process.stdout.write("\n");
+  if (opts.abortController?.signal.aborted) {
+    throw new Error("Run canceled by user");
+  }
   return { text: finalText, widgets: collected, plans: getPlans() };
 }
 
@@ -424,6 +441,20 @@ function stripFrontMatter(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(lines, ctx) {
+  if (!ctx.thread || ctx.thread.length === 0) return;
+  lines.push("", "# Conversation so far");
+  for (const turn of ctx.thread) {
+    lines.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.`;
@@ -447,12 +478,7 @@ function buildPrompt(ctx) {
   if (ctx.request?.body) {
     lines.push("", ctx.request.body);
   }
-  if (ctx.thread && ctx.thread.length > 0) {
-    lines.push("", "# Conversation so far");
-    for (const turn of ctx.thread) {
-      lines.push("", `## ${turn.role === "agent" ? ctx.agentName : "User"}`, turn.content);
-    }
-  }
+  appendThread(lines, ctx);
   lines.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."
@@ -460,7 +486,7 @@ function buildPrompt(ctx) {
   return lines.join("\n");
 }
 function buildRevisePrompt(ctx) {
-  const task = `Use the \`flumecode:revise-implementation\` skill to handle this turn. The plan below was already implemented (its report is included); 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 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 = [
@@ -479,21 +505,39 @@ function buildRevisePrompt(ctx) {
   if (ctx.request?.body) {
     lines.push("", ctx.request.body);
   }
-  if (ctx.priorReport) {
-    lines.push("", "# Latest implementation report", "", ctx.priorReport);
-  }
-  if (ctx.thread && ctx.thread.length > 0) {
-    lines.push("", "# Conversation so far");
-    for (const turn of ctx.thread) {
-      lines.push("", `## ${turn.role === "agent" ? ctx.agentName : "User"}`, turn.content);
-    }
-  }
+  appendThread(lines, ctx);
   lines.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");
 }
+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 lines = [
+    `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) {
+    lines.push("", ctx.request.body);
+  }
+  appendThread(lines, ctx);
+  lines.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");
+}
 function buildDocumentPrompt(ctx) {
   const lines = [
     `You are "${ctx.agentName}" maintaining the repository wiki for ${ctx.repo.fullName}.`,
@@ -505,12 +549,7 @@ function buildDocumentPrompt(ctx) {
   if (ctx.request?.body) {
     lines.push("", ctx.request.body);
   }
-  if (ctx.thread && ctx.thread.length > 0) {
-    lines.push("", "# Conversation so far");
-    for (const turn of ctx.thread) {
-      lines.push("", `## ${turn.role === "agent" ? ctx.agentName : "User"}`, turn.content);
-    }
-  }
+  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");
 }
@@ -533,6 +572,33 @@ function buildRepairPrompt(ctx, hookLog) {
   ];
   return lines.join("\n");
 }
+function buildReleasePrompt(ctx) {
+  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 = [
+    `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) {
+    lines.push("", ctx.request.body);
+  }
+  appendThread(lines, ctx);
+  lines.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");
+}
 function buildInitPrompt(ctx) {
   return [
     `You are "${ctx.agentName}" initializing FlumeCode for the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
@@ -614,6 +680,12 @@ async function discardWorkspace(key) {
     });
   }
 }
+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);
@@ -716,17 +788,45 @@ async function rebaseOntoMergeBranch(ctx, dir) {
   if (!mergeBranch) return;
   await git(["-C", dir, "fetch", "--quiet", "origin", mergeBranch]);
   try {
-    await git(["-C", dir, "rebase", "FETCH_HEAD"]);
-  } catch {
+    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,
+      "-c",
+      "user.email=runner@flumecode.local",
+      "-c",
+      "user.name=FlumeCode Runner",
+      "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;
@@ -772,21 +872,56 @@ async function cleanup(dir) {
 
 // src/run.ts
 var IDLE_MS = 5e3;
+var CANCEL_POLL_MS = 2500;
 var ORCHESTRATOR_MODEL = "sonnet";
 var ORCHESTRATOR_MAX_TURNS = 80;
 var MAX_COMMIT_REPAIRS = 2;
 var INIT_MAX_TURNS = 200;
 var DOCUMENT_MAX_TURNS = 120;
 var HEARTBEAT_MS = 5 * 6e4;
-async function pushAndOpenPr(ctx, dir, opts = { rebase: true }) {
-  const committed = await commitWithRepair(ctx, dir);
-  if (!committed) return { kind: "none" };
-  if (opts.rebase) await rebaseOntoMergeBranch(ctx, dir);
+async function pushAndOpenPr(ctx, dir, 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 };
+  let autoMerged = false;
+  if (opts.rebase) {
+    try {
+      await rebaseOntoMergeBranch(ctx, dir);
+    } catch (err) {
+      if (!(err instanceof RebaseConflictError)) throw err;
+      if (abort.signal.aborted) throw new Error("Run canceled by user");
+      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);
+      autoMerged = true;
+    }
+  }
   await pushBranch(ctx, dir);
   const pr = await openPullRequest(ctx);
-  return pr ? { kind: "pr", pr } : { kind: "pushed" };
+  return { outcome: pr ? { kind: "pr", pr } : { kind: "pushed" }, autoMerged };
 }
-async function commitWithRepair(ctx, dir) {
+async function mergeAndResolveConflicts(ctx, dir, abort) {
+  const { conflicted } = await mergeInMergeBranch(ctx, dir);
+  if (!conflicted) return { resolved: false, text: null };
+  const result = await runClaudeCode({
+    cwd: dir,
+    prompt: buildResolvePrompt(ctx),
+    permissionMode: ctx.permissionMode,
+    model: ORCHESTRATOR_MODEL,
+    maxTurns: ORCHESTRATOR_MAX_TURNS,
+    abortController: abort
+  });
+  const unresolved = await listUnmergedPaths(dir);
+  if (unresolved.length > 0) {
+    throw new Error(
+      `Could not fully resolve the merge \u2014 ${unresolved.length} file(s) still conflict: ${unresolved.join(", ")}`
+    );
+  }
+  return { resolved: true, text: result.text.trim() || null };
+}
+async function commitWithRepair(ctx, dir, abort) {
   for (let attempt = 1; ; attempt++) {
     try {
       return await commitChanges(ctx, dir);
@@ -800,24 +935,26 @@ async function commitWithRepair(ctx, dir) {
         prompt: buildRepairPrompt(ctx, err.log),
         permissionMode: ctx.permissionMode,
         model: ORCHESTRATOR_MODEL,
-        maxTurns: ORCHESTRATOR_MAX_TURNS
+        maxTurns: ORCHESTRATOR_MAX_TURNS,
+        abortController: abort
       });
     }
   }
 }
 function outcomeBanner(outcome, opts) {
   const wikiNote = opts.documented ? " (with wiki updates)" : "";
+  const mergeNote = opts.autoMerged ? "\n\u{1F500} The base branch had advanced with conflicting changes \u2014 merged it in and resolved the conflicts automatically." : "";
   switch (outcome.kind) {
     case "pr":
       return `
 
 ---
-\u2705 Opened pull request from \`${opts.branch}\`${wikiNote} \xB7 [View pull request](${outcome.pr.url})`;
+\u2705 Opened pull request from \`${opts.branch}\`${wikiNote} \xB7 [View pull request](${outcome.pr.url})${mergeNote}`;
     case "pushed":
       return `
 
 ---
-\u26A0\uFE0F Pushed \`${opts.branch}\`${wikiNote}, but couldn't open a pull request (no diff against the base branch, or one is already open).`;
+\u26A0\uFE0F Pushed \`${opts.branch}\`${wikiNote}, but couldn't open a pull request (no diff against the base branch, or one is already open).${mergeNote}`;
     case "none":
       return `
 
@@ -825,51 +962,67 @@ 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) {
+async function processJob(ctx, 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);
+      return await processInitJob(ctx, dir, abort);
     }
     if (ctx.kind === "implement") {
       const { resumed } = await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processImplementJob(ctx, dir, resumed);
+      return await processImplementJob(ctx, dir, resumed, abort);
     }
     if (ctx.kind === "revise") {
       const { resumed } = await prepareResumingBranch(ctx, dir, reused);
       prepared = true;
-      return await processReviseJob(ctx, dir, resumed);
+      return await processReviseJob(ctx, dir, resumed, abort);
+    }
+    if (ctx.kind === "resolve") {
+      await prepareResumingBranch(ctx, dir, reused);
+      prepared = true;
+      return await processResolveJob(ctx, dir, abort);
+    }
+    if (ctx.kind === "release") {
+      const { resumed } = await prepareResumingBranch(ctx, dir, reused);
+      prepared = true;
+      return await processReleaseJob(ctx, dir, resumed, abort);
     }
     await prepareAtSha(ctx, dir, reused);
     prepared = true;
-    return await processChatJob(ctx, dir);
+    return await processChatJob(ctx, dir, abort);
   } catch (err) {
-    if (!prepared) await discardWorkspace(ctx.workspaceKey);
+    if (abort.signal.aborted && prepared) {
+      await resetWorkspace(dir);
+    } else if (!prepared) {
+      await discardWorkspace(ctx.workspaceKey);
+    }
     throw err;
   }
 }
-async function processInitJob(ctx, dir) {
+async function processInitJob(ctx, dir, abort) {
   console.log(`
 \u25B6 Init ${ctx.jobId} \u2014 ${ctx.repo.fullName} on ${ctx.repo.checkoutBranch}`);
   const summary = (await runClaudeCode({
     cwd: dir,
     prompt: buildInitPrompt(ctx),
     permissionMode: ctx.permissionMode,
-    maxTurns: INIT_MAX_TURNS
+    maxTurns: INIT_MAX_TURNS,
+    abortController: abort
   })).text.trim();
   let reply = summary || "(the agent produced no summary)";
-  const outcome = await pushAndOpenPr(ctx, dir);
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort);
   reply += outcomeBanner(outcome, {
     branch: ctx.repo.checkoutBranch,
-    noChange: "no files were generated; the wiki may already exist."
+    noChange: "no files were generated; the wiki may already exist.",
+    autoMerged
   });
   return { text: reply, widgets: [] };
 }
-async function processChatJob(ctx, dir) {
+async function processChatJob(ctx, dir, abort) {
   console.log(`
 \u25B6 Job ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const orchestrating = ctx.permissionMode !== "plan";
@@ -878,6 +1031,7 @@ async function processChatJob(ctx, dir) {
     cwd: dir,
     prompt: buildPrompt(ctx),
     permissionMode: ctx.permissionMode,
+    abortController: abort,
     ...orchestrating ? { model: ORCHESTRATOR_MODEL, maxTurns: ORCHESTRATOR_MAX_TURNS } : {}
   });
   const summary = result.text.trim();
@@ -902,18 +1056,19 @@ async function processChatJob(ctx, dir) {
         cwd: dir,
         prompt: buildDocumentPrompt(ctx),
         permissionMode: ctx.permissionMode,
-        maxTurns: DOCUMENT_MAX_TURNS
+        maxTurns: DOCUMENT_MAX_TURNS,
+        abortController: abort
       });
       documented = true;
     } catch (err) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const outcome = await pushAndOpenPr(ctx, dir);
-  reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort);
+  reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   return { text: reply, widgets: [] };
 }
-async function processImplementJob(ctx, dir, resumed) {
+async function processImplementJob(ctx, dir, resumed, abort) {
   console.log(`
 \u25B6 Implement ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
@@ -922,7 +1077,8 @@ async function processImplementJob(ctx, dir, resumed) {
     prompt: buildPrompt(ctx),
     permissionMode: ctx.permissionMode,
     model: ORCHESTRATOR_MODEL,
-    maxTurns: ORCHESTRATOR_MAX_TURNS
+    maxTurns: ORCHESTRATOR_MAX_TURNS,
+    abortController: abort
   });
   let reply = result.text.trim() || "(the agent produced no report)";
   if (installResult.status === "failed") {
@@ -938,18 +1094,19 @@ async function processImplementJob(ctx, dir, resumed) {
         cwd: dir,
         prompt: buildDocumentPrompt(ctx),
         permissionMode: ctx.permissionMode,
-        maxTurns: DOCUMENT_MAX_TURNS
+        maxTurns: DOCUMENT_MAX_TURNS,
+        abortController: abort
       });
       documented = true;
     } catch (err) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const outcome = await pushAndOpenPr(ctx, dir, { rebase: !resumed });
-  reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
+  reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   return { text: reply, widgets: [], ...outcome.kind === "pr" ? { pr: outcome.pr } : {} };
 }
-async function processReviseJob(ctx, dir, resumed) {
+async function processReviseJob(ctx, dir, resumed, abort) {
   console.log(`
 \u25B6 Revise ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
   const installResult = await installDependencies(dir);
@@ -958,7 +1115,8 @@ async function processReviseJob(ctx, dir, resumed) {
     prompt: buildRevisePrompt(ctx),
     permissionMode: ctx.permissionMode,
     model: ORCHESTRATOR_MODEL,
-    maxTurns: ORCHESTRATOR_MAX_TURNS
+    maxTurns: ORCHESTRATOR_MAX_TURNS,
+    abortController: abort
   });
   const summary = result.text.trim();
   let reply = summary || "(the agent produced no reply)";
@@ -980,16 +1138,17 @@ async function processReviseJob(ctx, dir, resumed) {
         cwd: dir,
         prompt: buildDocumentPrompt(ctx),
         permissionMode: ctx.permissionMode,
-        maxTurns: DOCUMENT_MAX_TURNS
+        maxTurns: DOCUMENT_MAX_TURNS,
+        abortController: abort
       });
       documented = true;
     } catch (err) {
       console.warn(`  wiki update skipped: ${errorMessage2(err)}`);
     }
   }
-  const outcome = await pushAndOpenPr(ctx, dir, { rebase: !resumed });
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
   if (outcome.kind !== "none") {
-    reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented });
+    reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented, autoMerged });
   }
   return {
     text: reply,
@@ -998,6 +1157,59 @@ async function processReviseJob(ctx, dir, resumed) {
     ...result.plans?.length ? { plans: result.plans } : {}
   };
 }
+async function processResolveJob(ctx, dir, 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);
+  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 += `
+
+> \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 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) {
+  console.log(`
+\u25B6 Release ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
+  const installResult = await installDependencies(dir);
+  const result = await runClaudeCode({
+    cwd: dir,
+    prompt: buildReleasePrompt(ctx),
+    permissionMode: ctx.permissionMode,
+    model: ORCHESTRATOR_MODEL,
+    maxTurns: ORCHESTRATOR_MAX_TURNS,
+    abortController: abort
+  });
+  let reply = result.text.trim() || "(the agent produced no reply)";
+  if (installResult.status === "failed") {
+    reply += `
+
+> \u26A0\uFE0F Dependencies failed to install (\`${installResult.manager}\`); tests may not have run.`;
+  }
+  if (result.widgets.length > 0) {
+    console.log(
+      `  \u2026release ${ctx.jobId} posted ${result.widgets.length} widget(s); awaiting reply`
+    );
+    return { text: reply, widgets: result.widgets };
+  }
+  const { outcome, autoMerged } = await pushAndOpenPr(ctx, dir, abort, { rebase: !resumed });
+  if (outcome.kind !== "none") {
+    reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, autoMerged });
+  }
+  return {
+    text: reply,
+    widgets: [],
+    ...outcome.kind === "pr" ? { pr: outcome.pr } : {}
+  };
+}
 async function heartbeat(config) {
   const health = await checkClaudeCode();
   if (health.ready) {
@@ -1016,43 +1228,78 @@ async function pollLoop(config) {
   const swept = await sweepWorkspaces();
   if (swept > 0) console.log(`Cleared ${swept} stale workspace${swept === 1 ? "" : "s"}.`);
   await heartbeat(config);
-  let nextHeartbeatAt = Date.now() + HEARTBEAT_MS;
-  for (; ; ) {
-    if (Date.now() >= nextHeartbeatAt) {
+  let heartbeatTimer;
+  const scheduleHeartbeat = () => {
+    heartbeatTimer = setTimeout(async () => {
       await heartbeat(config);
-      nextHeartbeatAt = Date.now() + HEARTBEAT_MS;
-    }
-    let ctx = null;
-    try {
-      ctx = await claimJob(config);
-    } catch (err) {
-      console.error(`Claim error: ${errorMessage2(err)}`);
-      await sleep(IDLE_MS);
-      continue;
-    }
-    if (!ctx) {
-      await sleep(IDLE_MS);
-      continue;
-    }
-    try {
-      const { text, widgets, pr, plans } = await processJob(ctx);
-      await reportJob(config, ctx.jobId, {
-        status: "done",
-        text,
-        widgets,
-        pr,
-        ...plans?.length ? { plans } : {}
-      });
-      console.log(`\u2713 Job ${ctx.jobId} done`);
-    } catch (err) {
-      const message = errorMessage2(err);
-      console.error(`\u2717 Job ${ctx.jobId} failed: ${message}`);
+      scheduleHeartbeat();
+    }, HEARTBEAT_MS);
+  };
+  scheduleHeartbeat();
+  try {
+    for (; ; ) {
+      let ctx = null;
       try {
-        await reportJob(config, ctx.jobId, { status: "error", error: message });
-      } catch (reportErr) {
-        console.error(`  (also failed to report the error: ${errorMessage2(reportErr)})`);
+        ctx = await claimJob(config);
+      } catch (err) {
+        console.error(`Claim error: ${errorMessage2(err)}`);
+        await sleep(IDLE_MS);
+        continue;
+      }
+      if (!ctx) {
+        await sleep(IDLE_MS);
+        continue;
+      }
+      const abort = new AbortController();
+      let stopPolling = false;
+      const scheduleCancelPoll = () => {
+        setTimeout(async () => {
+          if (stopPolling) return;
+          try {
+            if (await pollJobCanceling(config, ctx.jobId)) {
+              console.log(`\u23F9 Stop requested for job ${ctx.jobId} \u2014 aborting\u2026`);
+              abort.abort();
+              return;
+            }
+          } catch {
+          }
+          if (!stopPolling) scheduleCancelPoll();
+        }, CANCEL_POLL_MS);
+      };
+      scheduleCancelPoll();
+      try {
+        const { text, widgets, pr, plans } = await processJob(ctx, abort);
+        await reportJob(config, ctx.jobId, {
+          status: "done",
+          text,
+          widgets,
+          pr,
+          ...plans?.length ? { plans } : {}
+        });
+        console.log(`\u2713 Job ${ctx.jobId} done`);
+      } catch (err) {
+        if (abort.signal.aborted) {
+          console.log(`\u23F9 Job ${ctx.jobId} canceled`);
+          try {
+            await reportJob(config, ctx.jobId, { status: "canceled" });
+          } catch (reportErr) {
+            console.error(`  (failed to report the cancellation: ${errorMessage2(reportErr)})`);
+          }
+        } else {
+          const message = errorMessage2(err);
+          console.error(`\u2717 Job ${ctx.jobId} failed: ${message}`);
+          try {
+            await reportJob(config, ctx.jobId, { status: "error", error: message });
+          } catch (reportErr) {
+            console.error(`  (also failed to report the error: ${errorMessage2(reportErr)})`);
+          }
+        }
+      } finally {
+        stopPolling = true;
       }
     }
+  } finally {
+    if (heartbeatTimer) clearTimeout(heartbeatTimer);
   }
 }
 function sleep(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flumecode/runner",
-  "version": "0.3.2",
+  "version": "0.6.0",
   "type": "module",
   "description": "FlumeCode local runner — claims jobs and drives your local Claude Code against a real checkout.",
   "bin": {

package/skills-plugin/skills/create-release/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: create-release
+description: >-
+  Draft release notes and version suggestions for a release, then (after the
+  user confirms) open a bump PR that updates package.json version(s) and
+  CHANGELOG.md. Two-turn flow: first turn asks the user to confirm versions via
+  widgets; second turn (answers in thread) writes the bumps and opens the PR.
+---
+
+# create-release
+
+You are driving a FlumeCode release. This skill has two distinct phases; detect
+which one applies before acting.
+
+## Phase detection
+
+Check the thread (`# Conversation so far` in the prompt). If **no widget answers**
+appear in any prior agent turn, this is **Phase 1** — propose versions and ask.
+If a prior turn contains widget-answer selections (the user picked a version), this
+is **Phase 2** — apply the bumps and report.
+
+---
+
+## Phase 1 — Propose versions and ask
+
+### 1. Find the last release tags
+
+For `@flumecode/web`, find the most recent `v*` tag:
+
+```
+git tag -l --sort=-version:refname 'v*' | head -1
+```
+
+For `@flumecode/runner`, find the most recent `runner-v*` tag:
+
+```
+git tag -l --sort=-version:refname 'runner-v*' | head -1
+```
+
+If no matching tag exists for a package, treat the current version in that
+package's `package.json` as the baseline.
+
+### 2. List commits since the last tag, split by package
+
+Get all commits since the tag (or all commits if no tag):
+
+```
+git log <lastWebTag>..HEAD --oneline
+```
+
+Then split by what they touch:
+
+```
+# web + shared packages
+git log <lastWebTag>..HEAD --oneline -- apps/web/ packages/
+
+# runner only
+git log <lastRunnerTag>..HEAD --oneline -- apps/runner/
+```
+
+If a package has no commits, mark it **unchanged** — do not bump it.
+
+### 3. Infer bump level per package
+
+For each package that has commits:
+
+- `feat:` in a commit subject, or any breaking change → **minor** (or major if
+  explicitly breaking).
+- `fix:`, `chore:`, `docs:`, `refactor:`, `test:` → **patch**.
+- When in doubt, default to **patch**.
+
+### 4. Compute suggested next versions
+
+Read current versions from `apps/web/package.json` and `apps/runner/package.json`.
+Apply the inferred bump (semver: patch = last digit +1, minor = middle digit +1 +
+reset patch to 0). For unchanged packages, keep the current version.
+
+### 5. Draft concise release notes
+
+3–10 user-readable bullet points summarising what changed. Group by theme; skip
+internal chore commits unless they affect the user.
+
+### 6. Ask the user to confirm
+
+For **each package that has commits** (skip unchanged ones), call
+`mcp__flume_widgets__single_select` with:
+
+- `question`: e.g. `@flumecode/web version for this release?`
+- `options`: the suggested next version, plus the two sibling semver levels (e.g.
+  if patch suggested: also offer minor and major), plus the current version as
+  "No change (keep X.Y.Z)".
+
+Also present the drafted release notes in your reply text so the user can read
+them, then call `mcp__flume_widgets__single_select` for a confirmatory question:
+`Do the release notes look correct?` with options `Yes, use these notes` and
+`I'll edit them in the PR`.
+
+**After calling widgets, end your turn.** Do NOT open a PR in Phase 1.
+
+---
+
+## Phase 2 — Apply the bumps and report
+
+### 1. Read the widget answers
+
+The user's confirmed version selections appear in the `# Conversation so far`
+thread as agent messages (the widget-answer turn). Extract the chosen version for
+each package from those selections.
+
+### 2. Update package.json files
+
+For each package whose version changed, edit the `"version"` field in:
+
+- `apps/web/package.json` — for `@flumecode/web`
+- `apps/runner/package.json` — for `@flumecode/runner`
+
+Change only the `"version"` line; do not reformat the file.
+
+### 3. Update CHANGELOG.md
+
+Edit (or create) `CHANGELOG.md` at the repo root. Insert a new section at the
+top, below any existing `# Changelog` title line:
+
+```
+## [X.Y.Z / runner-X.Y.Z] - YYYY-MM-DD
+
+- Bullet point from release notes
+- Another bullet point
+```
+
+Use the ISO date format (`YYYY-MM-DD`). Preserve all existing entries — do not
+delete or rewrite prior sections.
+
+If both packages are bumped, list both versions in the heading (e.g.
+`## [0.9.0 / runner-0.5.0] - 2026-06-06`). If only one package is bumped, list
+only that version in the heading.
+
+### 4. Stop — do not commit or push
+
+Leave the edited files in the working tree. The runner commits them and opens the
+pull request.
+
+### 5. End with this exact report format
+
+Your final message must match this shape (adjust versions and files to match what
+actually changed):
+
+```
+**Bumped versions:**
+- `@flumecode/web`: `0.8.0` → `0.9.0`
+- `@flumecode/runner`: `0.4.0` → `0.5.0`
+
+**CHANGELOG updated** with release notes.
+
+**Files changed:** `apps/web/package.json`, `apps/runner/package.json`, `CHANGELOG.md`
+
+<!-- flumecode:versions {"@flumecode/web":"0.9.0","@flumecode/runner":"0.5.0"} -->
+```
+
+The `<!-- flumecode:versions {...} -->` comment is machine-readable and **must be
+the last line** of your message body (before any trailing newline). The runner
+reads it to persist the confirmed versions on the release entity. Use the exact
+JSON key names `@flumecode/web` and `@flumecode/runner`; omit a package if its
+version did not change.
+
+---
+
+## Notes
+
+- **Runner-only bump:** if only `apps/runner/` has commits, bump only
+  `apps/runner/package.json`. Leave `apps/web/package.json` unchanged.
+- **Clear Phase 1 text:** be explicit about what changed since the last tag so the
+  user can confidently confirm or override your suggestions.
+- **Never edit** any file other than `apps/web/package.json`,
+  `apps/runner/package.json`, and `CHANGELOG.md`.
+- **Never commit, push, or open a PR** — the runner does that.

package/skills-plugin/skills/resolve-merge-conflict/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: resolve-merge-conflict
+description: >-
+  Resolve the merge conflicts left by an in-progress merge of a coding session's
+  merge branch into its pull-request branch. Use in resolve-job runs. The working
+  tree already has conflict markers; integrate both sides of every conflict
+  correctly, verify the build/tests, and leave the resolved changes in the working
+  tree. Never `git add`, commit, push, or open a PR — the runner finalizes the merge.
+---
+
+# resolve-merge-conflict
+
+The plan in the context above was **already implemented** and has an open pull
+request. Its merge branch (e.g. `main`) has since advanced and now **conflicts** with
+the PR branch. The runner has already started a `git merge` of the merge branch into
+your current branch, so your working tree contains the **conflict markers**
+(`<<<<<<<`, `=======`, `>>>>>>>`). Your job is to resolve every conflict so the PR
+becomes mergeable again — without losing this session's work or the incoming changes.
+
+## You are stateless — orient yourself first
+
+You see the whole session thread (the plan and its implementation report) but keep
+**no memory** between turns. Read it first: the plan and report tell you what this
+branch was building, which is exactly the intent you must preserve when you choose how
+to integrate each conflict. Check the FlumeCode wiki (`.flumecode/wiki/README.md`) if
+one exists to understand the conflicting code.
+
+## Step 1 — Find every conflict
+
+- `git status` shows the unmerged paths; `git diff --diff-filter=U` shows the
+  conflicting hunks. Work through **all** of them — a single leftover marker fails the
+  run.
+
+## Step 2 — Resolve each conflict correctly
+
+For each conflicted file, understand **both** sides before editing:
+
+- **Ours** (the conflict's first side) is this session's implementation — the change
+  the plan/report describes.
+- **Theirs** (the second side) is what landed on the merge branch since.
+
+Integrate them so **both** intents survive. Do **not** blindly pick a side or delete
+one half to make the markers go away — that silently drops work. When the two changes
+are genuinely incompatible, prefer keeping this session's implementation intent while
+adapting it to the incoming code (e.g. a renamed function, a moved file, a new
+signature). Remove every conflict marker; the file must read as clean, correct code.
+
+You may delegate isolated, well-scoped resolutions to **Task** subagents, but give
+each a self-contained prompt (the conflicting file's content, both intents, and the
+coding guidelines verbatim) — subagents start blank.
+
+## Step 3 — Verify
+
+Run the project's build and tests to confirm the resolved tree is correct (the
+runner's commit will also run the repo's pre-commit hook, so failing checks would
+block the merge anyway). Fix anything the merge broke.
+
+## Never
+
+- Never `git add`, `git commit`, `git merge --continue`, `git push`, or open a PR —
+  the runner stages the resolved tree, finalizes the merge commit, and updates the
+  **existing** pull request. A new PR must never be created.
+- Never leave a conflict marker behind, and never resolve a conflict by discarding one
+  side's intent.
+
+## Your final reply
+
+Your last message **is** the report posted to the session thread. Write it for the
+user: list which files conflicted and, briefly, how you resolved each, plus how you
+verified (build/tests). The runner appends the pull-request link, so don't add one.