@nanopm/cli 0.1.11 → 0.1.12

package/dist/index.js

@@ -391,7 +391,7 @@ var SkillManifestSchema = z2.object({
   /**
    * Run only when the founder asks for it on one item, by a click or a command, never by Nano on
    * its own: the autonomy dial, which governs what Nano does unasked, does not cap it
-   * (`capCapabilities`). A build is the one today (docs/⏳nanopm-75-build-it.md, settled 2).
+   * (`capCapabilities`). A build is the one today (docs/⏳nanopm-76-build-it.md, settled 2).
    */
   asked: z2.boolean().default(false),
   /** The first user message sent to the harness, unless the job params provide one. */
@@ -673,6 +673,18 @@ function formatStreamEvent(event) {
       return "\u2298 cancel requested";
     case "error":
       return `\u2717 ${String(p.code ?? "error")}: ${String(p.message ?? "")}`;
+    // A build (docs/⏳nanopm-76-build-it.md): its plan, each step with its commit, a pause, the pull request.
+    case "plan":
+      return ["The plan:", ...(Array.isArray(p.steps) ? p.steps : []).map((s, i) => `  ${i + 1}. ${String(s)}`)].join("\n");
+    case "step":
+      return `\u2713 ${String(p.step ?? "")}. ${String(p.says ?? "")}${p.commit ? ` \xB7 ${String(p.commit)}` : ""}`;
+    case "paused": {
+      const at = new Date(String(p.resets_at ?? ""));
+      const when = Number.isNaN(at.getTime()) ? "when it resets" : `at ${at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+      return `\u25CC paused: your Claude limit is reached. Nano carries on by itself ${when}.`;
+    }
+    case "pr":
+      return `\u2387 draft pull request #${String(p.number ?? "")} \xB7 ${String(p.url ?? "")}`;
     default:
       return null;
   }
@@ -3673,7 +3685,7 @@ function buildSandboxSettings(home) {
   }
   return { permissions: { deny, defaultMode: "default" } };
 }
-function sandboxSettingsFor(home, grantedTools, network = []) {
+function sandboxSettingsFor(home, grantedTools, network = [], answerFile) {
   const settings = buildSandboxSettings(home);
   const granted = new Set(grantedTools);
   settings.permissions.deny = settings.permissions.deny.filter((rule) => !granted.has(rule));
@@ -3685,8 +3697,14 @@ function sandboxSettingsFor(home, grantedTools, network = []) {
       network: { allowedDomains: network.filter((h) => !/(^|\.)github(usercontent)?\.com$/.test(h)) }
     };
   }
+  if (answerFile) settings.hooks = { PreToolUse: [{ matcher: "mcp__nanopm__ask_user", hooks: [{ type: "command", command: askHook(answerFile) }] }] };
   return settings;
 }
+function askHook(answerFile) {
+  const quote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+  const decision = (d) => quote(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: d } }));
+  return `if [ -f ${quote(answerFile)} ]; then mv ${quote(answerFile)} ${quote(`${answerFile}.taken`)}; printf '%s' ${decision("allow")}; else printf '%s' ${decision("defer")}; fi`;
+}
 
 // ../daemon/src/adapters/claude-code/stream.ts
 var RESULT_FAILURES = {
@@ -3704,6 +3722,8 @@ var StreamParser = class {
   model = "unknown";
   toolCalls = /* @__PURE__ */ new Map();
   sawResult = false;
+  /** When the Claude window opens again, from the last rejected `rate_limit_event`. */
+  resetsAt;
   // The read size, counted here because the stream is the one place every call passes.
   contextPeak = 0;
   readCalls = {};
@@ -3714,6 +3734,9 @@ var StreamParser = class {
   get currentSessionId() {
     return this.sessionId;
   }
+  get limitResetsAt() {
+    return this.resetsAt;
+  }
   /** Feed one NDJSON line; get zero or more events. Non-JSON lines are ignored. */
   parseLine(line) {
     const trimmed = line.trim();
@@ -3765,10 +3788,18 @@ var StreamParser = class {
         }
         return events;
       }
+      case "rate_limit_event": {
+        const info = obj.rate_limit_info;
+        if (info?.status === "rejected" && typeof info.resetsAt === "number") this.resetsAt = info.resetsAt;
+        return [];
+      }
       case "result": {
         this.sawResult = true;
         this.sessionId = obj.session_id ?? this.sessionId;
         const usage = this.usageFrom(obj);
+        if (obj.stop_reason === "tool_deferred" && obj.deferred_tool_use?.name) {
+          return [{ type: "deferred", sessionId: this.sessionId ?? "", tool: obj.deferred_tool_use.name, input: obj.deferred_tool_use.input, usage }];
+        }
         if (obj.subtype === "success" && !obj.is_error) {
           if (this.structuredOutput && obj.structured_output === void 0) {
             return [{ type: "failed", sessionId: this.sessionId, code: "harness_error", message: "Claude omitted the required structured output." }];
@@ -3777,7 +3808,7 @@ var StreamParser = class {
         }
         const message = obj.result || `claude ended with ${obj.subtype ?? "an unknown result"}`;
         const code = isRateLimit(message) ? "rate_limit" : RESULT_FAILURES[obj.subtype ?? ""] ?? "harness_error";
-        return [{ type: "failed", sessionId: this.sessionId, code, message }];
+        return [{ type: "failed", sessionId: this.sessionId, code, message, ...code === "rate_limit" && this.resetsAt ? { resetsAt: this.resetsAt } : {} }];
       }
       default:
         return [];
@@ -3993,7 +4024,7 @@ var ClaudeCodeAdapter = class {
     await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers }), { mode: 384 });
     const settingsPath = join3(spec2.runDir, "settings.json");
     const flags = claudeCodeToolFlags(spec2.capabilities, { workspace: spec2.cwd, harnessWeb: spec2.harnessWeb, without: spec2.withoutTools });
-    await writeFile2(settingsPath, JSON.stringify(sandboxSettingsFor(spec2.env.HOME ?? "", flags.tools, spec2.network)), { mode: 384 });
+    await writeFile2(settingsPath, JSON.stringify(sandboxSettingsFor(spec2.env.HOME ?? "", flags.tools, spec2.network, spec2.answerFile)), { mode: 384 });
     const child = spawn(this.claudePath, this.buildArgs(spec2, mcpConfigPath, settingsPath), {
       cwd: spec2.cwd,
       env: spec2.env,
@@ -4024,7 +4055,8 @@ var ClaudeCodeAdapter = class {
       const { code } = await exit;
       if (!parser.finished) {
         const failure2 = classifyExit(stderr, aborted);
-        yield { type: "failed", sessionId: parser.currentSessionId, ...failure2, message: appendExit(failure2.message, code) };
+        const resetsAt = failure2.code === "rate_limit" ? parser.limitResetsAt : void 0;
+        yield { type: "failed", sessionId: parser.currentSessionId, ...failure2, message: appendExit(failure2.message, code), ...resetsAt ? { resetsAt } : {} };
       }
     } finally {
       spec2.signal.removeEventListener("abort", onAbort);
@@ -4052,7 +4084,7 @@ function parsePrintResult(stdout) {
 import { mkdir as mkdir6, readdir as readdir3, readFile as readFile9, rm as rm5, writeFile as writeFile6 } from "fs/promises";
 import { openSync, closeSync, unlinkSync, writeFileSync, readFileSync as readFileSyncNode, mkdirSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 
 // ../daemon/src/awake.ts
@@ -4137,6 +4169,7 @@ function shouldUpdate(s) {
 }
 
 // ../daemon/src/mcp.ts
+import { join as join5 } from "path";
 function memoryMcpCommand(env = process.env) {
   const override = env.NANOPM_MCP_COMMAND;
   if (override) {
@@ -4163,13 +4196,17 @@ function memoryMcpServer(job, auth, askTimeoutMs, workspace) {
       NANOPM_PROJECT_ID: job.project_id,
       NANOPM_USER_ID: auth.userId,
       NANOPM_ACTOR: job.skill,
-      ...workspace ? { NANOPM_WORKSPACE: workspace } : {},
+      // A build: its questions come back through the answer file the hook hands over (buildAnswerFile).
+      ...workspace ? { NANOPM_WORKSPACE: workspace, NANOPM_ANSWER_FILE: buildAnswerFile(job.id) } : {},
       NANOPM_ASK_TIMEOUT_MS: String(askTimeoutMs),
       PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
       HOME: process.env.HOME ?? ""
     }
   };
 }
+function buildAnswerFile(jobId) {
+  return join5(nanopmHome(), "run", jobId, "answer");
+}
 
 // ../connectors/src/postgres.ts
 import postgres from "postgres";
@@ -5286,7 +5323,7 @@ import { promisify as promisify4 } from "util";
 // ../daemon/src/repo.ts
 import { execFile as execFile3 } from "child_process";
 import { readFile as readFile2, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // ../shared/src/build.ts
 var BUILD_SKILL = "build";
@@ -5340,7 +5377,7 @@ async function queueBuild(client, ask7) {
   if (readError) throw new Error(`could not read the solution: ${pgMessage(readError)}`);
   if (!data) throw new Error(`No solution ${ask7.ref} on the Roadmap.`);
   const solution = data;
-  const refused = buildRefusal(solution, { anyway: ask7.anyway });
+  const refused = buildRefusal(solution, { anyway: ask7.anyway || Boolean(ask7.resumeOf) });
   if (refused) throw new Error(refused);
   const { data: job, error } = await client.from("jobs").insert({
     project_id: ask7.projectId,
@@ -5348,12 +5385,53 @@ async function queueBuild(client, ask7) {
     requested_by: ask7.userId,
     trigger: "user",
     target_daemon_id: ask7.daemonId,
-    params: { solution_id: solution.id, repo_path: ask7.repoPath, ...ask7.anyway ? { anyway: true } : {} }
+    // `was`: where the solution goes back on the board if the build stops (`unstart_solution`).
+    // `origin`: the run that made the copy of the code, which every continuation works in.
+    params: { solution_id: solution.id, repo_path: ask7.repoPath, was: ask7.resumeOf?.was ?? solution.status, ...ask7.resumeOf ? { origin: ask7.resumeOf.origin } : {}, ...ask7.anyway ? { anyway: true } : {} },
+    // Continuing a stopped build takes up its worktree, its history and its session.
+    ...ask7.resumeOf ? { resume_of: ask7.resumeOf.id } : {}
   }).select("id").single();
   if (error?.code === "23505") throw new Error("A build of this product is already running. One at a time: `nanopm status` says where it is.");
   if (error || !job) throw new Error(`could not queue the build: ${error ? pgMessage(error) : "no row"}`);
   return { jobId: job.id, solution };
 }
+var DECIDE_FOR_ME = "Decide yourself: pick what you judge best for the users, then say what you decided and why under *Decisions I made*.";
+function answerForAgent(answer) {
+  return /^\s*decide(\s+for\s+me)?\s*\.?\s*$/i.test(answer) ? DECIDE_FOR_ME : answer;
+}
+function trustedPlace(p, at) {
+  const [branch, base, fork] = [p.branch, p.base, p.fork].map((v) => typeof v === "string" ? v : "");
+  if (!/^nano\/[a-z0-9][a-z0-9-]*$/.test(branch) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(base) || !/^[0-9a-f]{7,40}$/.test(fork)) return null;
+  return { dir: buildDir(at.home, at.jobId), branch, base, fork };
+}
+function buildHistory(events, at) {
+  let place = null;
+  let plan = null;
+  const done = /* @__PURE__ */ new Set();
+  let last = null;
+  const answers = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind === "worktree") place = trustedPlace(e.payload, at);
+    else if (e.kind === "plan" && Array.isArray(e.payload.steps)) plan = e.payload.steps;
+    else if (e.kind === "step" && typeof e.payload.step === "number") done.add(e.payload.step - 1);
+    else if (e.kind === "answer") answers.set(e.seq, String(e.payload.answer ?? ""));
+    if (e.kind === "question" || e.kind === "paused") last = e;
+    else if (e.kind === "plan" || e.kind === "step") last = null;
+  }
+  if (!place) return { place, plan, done, resume: null };
+  if (last?.kind === "question" && answers.has(last.seq) && last.payload.about === "usage") return { place, plan, done, resume: { why: "limit" } };
+  if (last?.kind === "question" && answers.has(last.seq)) return { place, plan, done, resume: { why: "answer", answer: answers.get(last.seq) } };
+  if (last?.kind === "paused") return { place, plan, done, resume: { why: "limit" } };
+  return { place, plan, done, resume: { why: "lost" } };
+}
+function wasOf(params) {
+  return params?.was === "proposed" ? "proposed" : "accepted";
+}
+async function loadBuildHistory(client, jobIds, at) {
+  const { data, error } = await client.from("job_events").select("kind, seq, payload").in("job_id", [...jobIds]).in("kind", ["worktree", "plan", "step", "question", "answer", "paused"]).order("id");
+  if (error) throw new Error(`could not read the build's history: ${error.message}`);
+  return buildHistory((data ?? []).map((e) => ({ kind: e.kind, seq: e.seq, payload: e.payload ?? {} })), at);
+}
 
 // ../daemon/src/repo.ts
 import { promisify as promisify3 } from "util";
@@ -5369,10 +5447,10 @@ var LOCKED = {
 };
 async function exec(cmd, repo, args, timeoutMs = TIMEOUT_MS) {
   if (typeof repo === "string") return execFileAsync3(cmd, cmd === "git" ? ["-C", repo, ...args] : args, { cwd: repo, maxBuffer: MAX_BUFFER, timeout: timeoutMs });
-  await writeFile4(join5(repo.dir, ".git"), `gitdir: ${repo.admin}
+  await writeFile4(join6(repo.dir, ".git"), `gitdir: ${repo.admin}
 `);
-  await writeFile4(join5(repo.admin, "commondir"), repo.commondir);
-  await rm3(join5(repo.admin, "config.worktree"), { force: true });
+  await writeFile4(join6(repo.admin, "commondir"), repo.commondir);
+  await rm3(join6(repo.admin, "config.worktree"), { force: true });
   return execFileAsync3(cmd, args, { cwd: repo.dir, env: { ...process.env, GIT_DIR: repo.admin, GIT_WORK_TREE: repo.dir, ...LOCKED }, maxBuffer: MAX_BUFFER, timeout: timeoutMs });
 }
 async function git(repo, args, timeoutMs = TIMEOUT_MS) {
@@ -5441,7 +5519,7 @@ async function addWorktree(clone, dir, branch) {
   const onto = await baseRef(clone, base);
   await git(clone, ["worktree", "add", "-b", branch, dir, onto]);
   const admin = await git(dir, ["rev-parse", "--absolute-git-dir"]);
-  const worktree = { dir, admin, commondir: await readFile2(join5(admin, "commondir"), "utf8") };
+  const worktree = { dir, admin, commondir: await readFile2(join6(admin, "commondir"), "utf8") };
   return { base, fork: await git(worktree, ["rev-parse", "HEAD"]), worktree };
 }
 async function removeWorktree(clone, dir) {
@@ -5550,6 +5628,275 @@ async function reviewDeploys(client, daemonId, now = /* @__PURE__ */ new Date())
   return results;
 }
 
+// ../daemon/src/build-job.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readdir, readFile as readFile3, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename, join as join7 } from "path";
+
+// ../daemon/src/usage.ts
+function sumUsage(a, b) {
+  if (!a) return { ...b };
+  return {
+    ...b,
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0),
+    costUsd: (a.costUsd ?? 0) + (b.costUsd ?? 0),
+    turns: a.turns + b.turns,
+    durationMs: a.durationMs + b.durationMs,
+    ...a.contextPeakTokens || b.contextPeakTokens ? { contextPeakTokens: Math.max(a.contextPeakTokens ?? 0, b.contextPeakTokens ?? 0) } : {},
+    ...a.reads || b.reads ? { reads: sumReads(a.reads, b.reads) } : {}
+  };
+}
+function sumReads(a, b) {
+  const calls = { ...a?.calls ?? {} };
+  for (const [tool, n] of Object.entries(b?.calls ?? {})) calls[tool] = (calls[tool] ?? 0) + n;
+  return { files: (a?.files ?? 0) + (b?.files ?? 0), calls };
+}
+
+// ../daemon/src/build-job.ts
+var PLAN_TOOL = "mcp__nanopm__build_plan";
+var ASK_TOOL = "mcp__nanopm__ask_user";
+var STEP_TOOL = "mcp__nanopm__build_step";
+var CLAUDE_CODE_MIN = "2.1.283";
+async function prepareBuild(client, job, clone, adapter) {
+  const params = job.params ?? {};
+  const dir = buildDir(homedir3(), job.id);
+  let made = false;
+  try {
+    const [solution, machine, history] = await Promise.all([
+      loadSolution(client, job.project_id, String(params.solution_id ?? "")),
+      machineRefusal(adapter),
+      loadHistory(client, job)
+    ]);
+    const refused = buildRefusal(solution, { anyway: params.anyway === true || Boolean(history.place) }) ?? machine;
+    if (refused) return { ok: false, outcome: failed(refused) };
+    const network = async (at) => buildNetwork(await readdir(at));
+    if (history.place) {
+      const { place } = history;
+      if (!existsSync2(place.dir)) return { ok: false, outcome: failed(`this build's copy of the code is gone (${place.dir}): build it again`) };
+      const worktree2 = { dir: place.dir, admin: join7(await commonGitDir(clone), "worktrees", basename(place.dir)), commondir: "../..\n" };
+      await startSolution(client, job.project_id, solution.ref, job.id);
+      return { ok: true, build: { solution, clone, ...place, worktree: worktree2, network: await network(place.dir), history } };
+    }
+    const branch = buildBranch(solution.ref, solution.title);
+    await mkdir2(join7(dir, ".."), { recursive: true, mode: 448 });
+    const { base, fork, worktree } = await addWorktree(clone, dir, branch);
+    made = true;
+    await appendJobEvent(client, job.id, "worktree", { dir, branch, base, fork }, "nanopm");
+    await handOverTheSpec(worktree, solution.agent_spec);
+    await startSolution(client, job.project_id, solution.ref, job.id);
+    return { ok: true, build: { solution, clone, dir, worktree, branch, base, fork, network: await network(dir), history } };
+  } catch (err) {
+    if (made) await removeWorktree(clone, dir);
+    return { ok: false, outcome: failed(errorMessage(err)) };
+  }
+}
+async function runBuildJob(input) {
+  const { client, job, adapter, spec: spec2, events, log, verifyCommand: verifyCommand2 } = input;
+  const { solution, clone, dir, worktree, branch, base, fork, history } = input.build;
+  const was = wasOf(job.params);
+  let plan = history.plan;
+  const done = new Set(history.done);
+  let usage;
+  let said = "";
+  const stop2 = async (message, opts = { keep: true }) => {
+    await unstartSolution(client, job.project_id, solution.ref, was).catch(() => void 0);
+    if (opts.keep) await commitAll(worktree, `${solution.ref}: unfinished \u2014 ${solution.title}`).catch(() => null);
+    else await removeWorktree(clone, dir);
+    return { ...failed(opts.keep ? `${message}. What was done is on ${branch}, in ${dir}.` : message), usage };
+  };
+  const park = async (why) => {
+    if ("ask" in why) {
+      await events.write("question", { ...why.ask, ...plan ? {} : { about: "plan" } });
+      await log("build.ask", `${solution.ref} waits on the founder`);
+    } else if (why.resetsAt) {
+      await events.write("paused", { why: "limit", resets_at: new Date(why.resetsAt * 1e3).toISOString() });
+      await log("build.pause", `${solution.ref} paused until the Claude limit resets`);
+    } else {
+      await events.write("question", { question: "Your Claude usage is used up. Get more in Claude, or wait for it to come back, then answer to carry on.", options: ["Carry on"], about: "usage" });
+    }
+    return { status: "waiting", usage };
+  };
+  const session2 = async (prompt, resume3) => {
+    let end = { stop: failed("the agent produced no result") };
+    for await (const event of adapter.run({ ...spec2, prompt, resumeSessionId: resume3 ? spec2.sessionId : void 0 })) {
+      await input.onEvent(event);
+      if (event.type === "tool_use" && event.tool === PLAN_TOOL && !plan) {
+        plan = stepsOf(event.input);
+        if (plan) await events.write("plan", { steps: plan });
+      } else if (event.type === "tool_result" && event.tool === STEP_TOOL && !event.isError) {
+        const { step, summary } = event.input ?? {};
+        const index = Number(step) - 1;
+        if (Number.isInteger(index) && index >= 0 && !done.has(index)) {
+          const says = plan?.[index] ?? `step ${index + 1}`;
+          const commit = await commitAll(worktree, `${solution.ref}: ${says}`, summary);
+          done.add(index);
+          await events.write("step", { step: index + 1, says, commit: commit?.sha ?? null, files: commit?.files ?? 0 });
+        }
+      } else if (event.type === "finished") {
+        usage = sumUsage(usage, event.usage);
+        said = event.result;
+        end = null;
+      } else if (event.type === "deferred" && event.tool === ASK_TOOL) {
+        usage = sumUsage(usage, event.usage);
+        end = { park: { ask: askOf(event.input) } };
+      } else if (event.type === "failed") {
+        end = event.code === "rate_limit" ? { park: { resetsAt: event.resetsAt } } : { stop: { status: "failed", error: { code: event.code, message: event.message } } };
+      }
+    }
+    return end;
+  };
+  const resume2 = history.resume;
+  const check = verifyCommand2 ? `
+
+The project's own check is \`${verifyCommand2}\`. Run it before your last build_step, fix what it reports, and give its result under *How I checked it*.` : "";
+  const finished = () => Boolean(plan && !stepsLeft(plan, done).length);
+  if (!resume2) {
+    await log("build.start", `building ${solution.ref} on ${branch}, in a copy of your code`);
+    await events.write("text", { text: `Working on ${branch}, in a copy of your code. Your own checkout is not touched.` });
+  } else {
+    await events.write("text", { text: AGAIN[resume2.why].said });
+    if (resume2.why === "answer" && spec2.answerFile) await writeFile5(spec2.answerFile, answerForAgent(resume2.answer), { mode: 384 });
+  }
+  let turn = !resume2 ? await session2(spec2.prompt + check, false) : resume2.why === "answer" ? await session2("", true) : finished() ? null : await session2(`${AGAIN[resume2.why].lead} ${carryOn(plan, done)}`, true);
+  for (let resumes = 0; !turn && !finished(); resumes += 1) {
+    if (resumes >= BUILD_RESUMES_MAX) {
+      const left = stepsLeft(plan, done).length;
+      return stop2(plan ? `Nano stopped with ${left} step${left === 1 ? "" : "s"} of its plan left` : "Nano stopped without saying its plan");
+    }
+    turn = await session2(carryOn(plan, done), true);
+  }
+  if (turn && "park" in turn) return park(turn.park);
+  if (turn) return stop2(turn.stop.error?.message ?? "the build stopped");
+  await commitAll(worktree, `${solution.ref}: ${solution.title}`);
+  if (!await commitsSinceFork(worktree, fork)) return stop2("the build finished without changing anything", { keep: false });
+  const rebased = await rebaseOnto(worktree, base);
+  if (!rebased.ok) return stop2(`${base} moved while Nano was building, and the same files changed on both sides: ${rebased.files.join(", ") || "see git status"}`);
+  const [pushed, noPr, page] = await Promise.all([pushBranch(worktree, branch), ghReady(worktree), solutionPage(client, job.project_id, solution.ref)]);
+  if (!pushed.pushed) return stop2(`the push failed: ${pushed.reason}`);
+  const pr = noPr ? null : await openPullRequest(worktree, { branch, base, title: `${solution.ref}: ${solution.title}`, body: prBody(said, page) });
+  if (pr && !pr.ok) return { ...failed(`the branch ${branch} is pushed, but GitHub refused the pull request: ${pr.reason}${pushed.reviewUrl ? `. Open it yourself: ${pushed.reviewUrl}` : ""}`), usage };
+  if (pr) {
+    await events.write("pr", { number: pr.number, url: pr.url });
+    await log("build.pr", `draft pull request #${pr.number} for ${solution.ref}`);
+  }
+  await removeWorktree(clone, dir);
+  return {
+    status: "succeeded",
+    result: [
+      said.trim(),
+      "",
+      pr ? `Draft pull request #${pr.number} \xB7 ${pr.url}` : `Pushed ${branch}. No pull request: ${noPr}.${pushed.reviewUrl ? ` ${pushed.reviewUrl}` : ""}`
+    ].filter(Boolean).join("\n"),
+    data: { branch, session: spec2.sessionId, ...pr ? { pr: { number: pr.number, url: pr.url } } : { review_url: pushed.reviewUrl ?? null } },
+    usage
+  };
+}
+var failed = (message) => ({ status: "failed", error: { code: "harness_error", message } });
+var AGAIN = {
+  answer: { said: "Your answer is in: carrying on.", lead: "" },
+  limit: { said: "Your Claude limit has reset: carrying on.", lead: "Your Claude limit has reset." },
+  lost: { said: "Picked up again where it stopped.", lead: "You were interrupted: the machine stopped." }
+};
+function askOf(input) {
+  const { question, options, why } = input ?? {};
+  return {
+    question: String(question ?? ""),
+    ...Array.isArray(options) ? { options: options.map(String) } : {},
+    ...typeof why === "string" ? { why } : {}
+  };
+}
+async function loadHistory(client, job) {
+  const named = (job.params ?? {}).origin;
+  const origin = typeof named === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(named) ? named : job.id;
+  const { data: runs } = await client.from("jobs").select("id").eq("project_id", job.project_id).eq("skill", BUILD_SKILL).or(`id.eq.${origin},params->>origin.eq.${origin}`);
+  return loadBuildHistory(client, [.../* @__PURE__ */ new Set([origin, job.id, ...(runs ?? []).map((r) => r.id)])], { home: homedir3(), jobId: origin });
+}
+async function loadSolution(client, projectId, id) {
+  const { data, error } = await client.from("solutions").select(BUILD_COLUMNS).eq("id", id).eq("project_id", projectId).is("superseded_by", null).maybeSingle();
+  if (error) throw new Error(`could not read the solution: ${error.message}`);
+  if (!data) throw new Error("that solution is not on this project any more");
+  return data;
+}
+async function machineRefusal(adapter) {
+  const found = await adapter.detect();
+  const version = /\d+\.\d+\.\d+/.exec(found.version ?? "")?.[0];
+  if (version && !newer(CLAUDE_CODE_MIN, version)) return null;
+  return `a build needs Claude Code ${CLAUDE_CODE_MIN} or later on this machine${found.version ? ` (it has ${found.version})` : ""}: run claude update`;
+}
+async function handOverTheSpec(worktree, agentSpec) {
+  await mkdir2(join7(worktree.dir, ".nanopm"), { recursive: true });
+  await writeFile5(join7(worktree.dir, ".nanopm", "SPEC.md"), agentSpec);
+  const exclude = join7(await commonGitDir(worktree), "info", "exclude");
+  const current = await readFile3(exclude, "utf8").catch(() => "");
+  if (!current.split("\n").includes(".nanopm/")) {
+    await mkdir2(join7(exclude, ".."), { recursive: true });
+    await writeFile5(exclude, `${current}${current && !current.endsWith("\n") ? "\n" : ""}.nanopm/
+`);
+  }
+}
+function stepsOf(input) {
+  const steps = input?.steps;
+  return Array.isArray(steps) && steps.length && steps.every((s) => typeof s === "string") ? steps : null;
+}
+function carryOn(plan, done) {
+  if (!plan) return "You stopped before saying your plan. Call build_plan with it now, then build it step by step, calling build_step after each.";
+  const left = stepsLeft(plan, done);
+  return [
+    `Steps ${left.map((i) => i + 1).join(", ")} of your plan are not done yet:`,
+    ...left.map((i) => `${i + 1}. ${plan[i]}`),
+    "",
+    "Check git log and git status to see where you are, then carry on: finish each step, run its checks, and call build_step after it. Do not run anything in the background."
+  ].join("\n");
+}
+async function solutionPage(client, projectId, ref) {
+  const { data } = await client.from("projects").select("slug").eq("id", projectId).maybeSingle();
+  return data?.slug ? `${webUrl()}/p/${data.slug}/roadmap/${ref}` : null;
+}
+function prBody(said, page) {
+  return [
+    said.trim(),
+    page ? `
+The solution and its spec: ${page}` : "",
+    "\n\u2014 Built by NanoPM with Claude Code. A draft: review before merging."
+  ].filter(Boolean).join("\n");
+}
+async function startSolution(client, projectId, ref, jobId) {
+  const { error } = await client.rpc("start_solution", { p_project_id: projectId, p_ref: ref, p_job_id: jobId });
+  if (error) throw new Error(pgMessage(error));
+}
+async function unstartSolution(client, projectId, ref, was) {
+  await client.rpc("unstart_solution", { p_project_id: projectId, p_ref: ref, p_to: was });
+}
+async function requeueLostBuild(client, job) {
+  const params = job.params ?? {};
+  if ((job.attempt ?? 1) < 2) {
+    const { data } = await client.from("jobs").update({ status: "queued", attempt: (job.attempt ?? 1) + 1, assigned_daemon_id: null }).eq("id", job.id).eq("status", "running").select("id");
+    if (data?.length) return true;
+  }
+  const { data: solution } = await client.from("solutions").select("ref").eq("id", params.solution_id ?? "").maybeSingle();
+  if (job.project_id && solution) await unstartSolution(client, job.project_id, solution.ref, wasOf(job.params)).catch(() => void 0);
+  return false;
+}
+async function resumePausedBuilds(client, daemonId, now = Date.now()) {
+  const { data: parked } = await client.from("jobs").select("id").eq("skill", BUILD_SKILL).eq("status", "waiting").eq("assigned_daemon_id", daemonId);
+  const ids = (parked ?? []).map((j) => j.id);
+  if (!ids.length) return [];
+  const { data: stops } = await client.from("job_events").select("job_id, kind, payload").in("job_id", ids).in("kind", ["paused", "question"]).order("id", { ascending: false });
+  const last = /* @__PURE__ */ new Map();
+  for (const e of stops ?? []) if (!last.has(e.job_id)) last.set(e.job_id, e);
+  const due = ids.filter((id) => {
+    const stop2 = last.get(id);
+    return stop2?.kind === "paused" && Date.parse(String(stop2.payload?.resets_at ?? "")) <= now;
+  });
+  if (!due.length) return [];
+  const { data } = await client.from("jobs").update({ status: "queued", assigned_daemon_id: null }).in("id", due).eq("status", "waiting").select("id");
+  return (data ?? []).map((j) => j.id);
+}
+
 // ../daemon/src/review-preflight.ts
 async function reviewWithoutData(client, job) {
   if (job.skill !== "review" || !job.project_id) return null;
@@ -5579,17 +5926,17 @@ async function reviewWithoutData(client, job) {
 }
 
 // ../daemon/src/skills.ts
-import { existsSync as existsSync2, readdirSync } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname2, join as join6, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname2, join as join8, resolve as resolve2 } from "path";
 function findSkillsDir(env = process.env) {
   if (env.NANOPM_SKILLS_DIR) return env.NANOPM_SKILLS_DIR;
   const candidates = [
-    join6(process.cwd(), "skills"),
+    join8(process.cwd(), "skills"),
     ...process.argv[1] ? [resolve2(dirname2(process.argv[1]), "..", "skills")] : []
   ];
   for (const dir of candidates) {
-    if (existsSync2(join6(dir, "onboard", "skill.json"))) return dir;
+    if (existsSync3(join8(dir, "onboard", "skill.json"))) return dir;
   }
   throw new Error(`Cannot find the skills directory (tried ${candidates.join(", ")}). Set NANOPM_SKILLS_DIR.`);
 }
@@ -5599,9 +5946,9 @@ function skillDirs(skillsDir, env = process.env) {
 }
 async function loadSkill(name, skillsDir = findSkillsDir()) {
   if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new Error(`Invalid skill name "${name}"`);
-  const dir = skillDirs(skillsDir).map((d) => join6(d, name)).find((d) => existsSync2(join6(d, "skill.json")));
+  const dir = skillDirs(skillsDir).map((d) => join8(d, name)).find((d) => existsSync3(join8(d, "skill.json")));
   if (!dir) throw new Error(`Unknown skill "${name}"`);
-  const raw = JSON.parse(await readFile3(join6(dir, "skill.json"), "utf8"));
+  const raw = JSON.parse(await readFile4(join8(dir, "skill.json"), "utf8"));
   let manifest;
   try {
     manifest = parseSkillManifest(raw);
@@ -5610,7 +5957,7 @@ async function loadSkill(name, skillsDir = findSkillsDir()) {
   }
   const tainted = taintedByTheWeb(manifest);
   if (tainted) throw new Error(`the "${name}" skill cannot be loaded: ${tainted}`);
-  const body = await readFile3(join6(dir, "SKILL.md"), "utf8");
+  const body = await readFile4(join8(dir, "SKILL.md"), "utf8");
   return { manifest, body, dir };
 }
 var NOT_WITH_READ_WEB = ["write_memory", "problems", "propose", "review", "write_repo", "run_commands"];
@@ -5645,7 +5992,7 @@ function renderPrompt(template, params) {
 var NEEDS_THE_REQUESTERS_CLONE = ["write_repo", "run_commands"];
 var NEEDS_THE_REQUESTERS_IDENTITY = /* @__PURE__ */ new Set(["want", "start"]);
 async function clonelessSkills(skillsDir = findSkillsDir()) {
-  const names = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync2(join6(skillsDir, d.name, "skill.json"))).map((d) => d.name);
+  const names = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync3(join8(skillsDir, d.name, "skill.json"))).map((d) => d.name);
   const out = [];
   for (const name of names) {
     try {
@@ -5699,30 +6046,6 @@ ${JSON.stringify(mappingOutputSchema(input.role))}`,
 
 // ../daemon/src/problem-mapping.ts
 import { createHash as createHash2 } from "crypto";
-
-// ../daemon/src/usage.ts
-function sumUsage(a, b) {
-  if (!a) return { ...b };
-  return {
-    ...b,
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
-    cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0),
-    costUsd: (a.costUsd ?? 0) + (b.costUsd ?? 0),
-    turns: a.turns + b.turns,
-    durationMs: a.durationMs + b.durationMs,
-    ...a.contextPeakTokens || b.contextPeakTokens ? { contextPeakTokens: Math.max(a.contextPeakTokens ?? 0, b.contextPeakTokens ?? 0) } : {},
-    ...a.reads || b.reads ? { reads: sumReads(a.reads, b.reads) } : {}
-  };
-}
-function sumReads(a, b) {
-  const calls = { ...a?.calls ?? {} };
-  for (const [tool, n] of Object.entries(b?.calls ?? {})) calls[tool] = (calls[tool] ?? 0) + n;
-  return { files: (a?.files ?? 0) + (b?.files ?? 0), calls };
-}
-
-// ../daemon/src/problem-mapping.ts
 var MAPPING_TURN_LIMIT = 40;
 var MAPPING_TIMEOUT_MS = 20 * 6e4;
 async function runProblemMapping(ports) {
@@ -5974,8 +6297,8 @@ async function askAgainIfUnanswered(attempt7, say, role7) {
 var UNANSWERED = /structured[ _]output|returned no result/i;
 
 // ../daemon/src/site.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join9 } from "path";
 var SITE_PATHS = ["/", "/about", "/pricing"];
 var PAGE_CHARS = 6e3;
 var SITE_TIMEOUT_MS = 2e4;
@@ -6098,7 +6421,7 @@ function siteFromSearch(name, hits) {
 }
 async function read(repoRoot, name) {
   try {
-    const text2 = await readFile4(join7(repoRoot, name), "utf8");
+    const text2 = await readFile5(join9(repoRoot, name), "utf8");
     return text2.length > 2e5 ? null : text2;
   } catch {
     return null;
@@ -6152,8 +6475,8 @@ async function fromReadme(repoRoot) {
 }
 
 // ../daemon/src/repo-docs.ts
-import { readFile as readFile5, readdir, stat } from "fs/promises";
-import { join as join8, relative } from "path";
+import { readFile as readFile6, readdir as readdir2, stat } from "fs/promises";
+import { join as join10, relative } from "path";
 var WRITTEN = /(persona|audience|customer|user-research|research\/|icp|segment)/i;
 var ABOUT_PEOPLE = /(persona|audience|customer|user-research|research\/|interview|feedback|survey|verbatim|voice|icp|segment)/i;
 var DOC = /\.(md|mdx|txt)$/i;
@@ -6166,12 +6489,12 @@ async function readDocs(cwd, opts = {}) {
     if (depth > 3 || found.length >= DOCS_MAX * 4) return;
     let entries;
     try {
-      entries = await readdir(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join8(dir, entry.name);
+      const full = join10(dir, entry.name);
       if (SKIP.test(`/${relative(cwd, full)}`)) continue;
       if (entry.isDirectory()) await walk(full, depth + 1);
       else if (DOC.test(entry.name) && (!opts.onlyAboutPeople || ABOUT_PEOPLE.test(relative(cwd, full)))) found.push(full);
@@ -6183,7 +6506,7 @@ async function readDocs(cwd, opts = {}) {
   for (const path of found.slice(0, DOCS_MAX)) {
     try {
       if ((await stat(path)).size > 4e5) continue;
-      out.push({ path: relative(cwd, path), text: (await readFile5(path, "utf8")).slice(0, DOC_CHARS) });
+      out.push({ path: relative(cwd, path), text: (await readFile6(path, "utf8")).slice(0, DOC_CHARS) });
     } catch {
     }
   }
@@ -7985,8 +8308,8 @@ ${body}
 
 // ../daemon/src/crew.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join9 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join11 } from "path";
 var READ_ONLY = {
   read_repo: /^(Read|Glob|Grep)$/,
   read_data: /(^|__)(list_connections|describe_source|query)$/
@@ -8001,8 +8324,8 @@ async function attempt6({ adapter, spec: spec2, onEvent, skill: skillName, name,
   if (skill.manifest.capabilities.some((c) => !holds.includes(c))) throw new Error(`The ${name} may not hold tools.`);
   const refused = grant.find((c) => !READ_ONLY[c] || !skill.manifest.capabilities.includes(c));
   if (refused) throw new Error(`The ${name} may not hold ${refused}.`);
-  const runDir = dir ? join9(spec2.runDir, dir) : spec2.runDir;
-  if (dir) await mkdir2(runDir, { recursive: true, mode: 448 });
+  const runDir = dir ? join11(spec2.runDir, dir) : spec2.runDir;
+  if (dir) await mkdir3(runDir, { recursive: true, mode: 448 });
   let result;
   let usage = null;
   await onEvent({ type: "text", text: say });
@@ -10059,9 +10382,9 @@ var told = (r) => ({
 // ../daemon/src/objective-definitions.ts
 import { execFile as execFile6 } from "child_process";
 import { randomUUID as randomUUID11 } from "crypto";
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
-import { join as join10 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir4, readFile as readFile7 } from "fs/promises";
+import { join as join12 } from "path";
 import { promisify as promisify6 } from "util";
 var execFileAsync6 = promisify6(execFile6);
 var DEFINITIONS_TIMEOUT_MS = 9e4;
@@ -10097,7 +10420,7 @@ function pickLines(raw) {
 }
 async function killRecorded(runDir) {
   try {
-    const pid = Number((await readFile6(join10(runDir, "harness.pid"), "utf8")).trim());
+    const pid = Number((await readFile7(join12(runDir, "harness.pid"), "utf8")).trim());
     if (pid > 1) process.kill(pid, "SIGKILL");
   } catch {
   }
@@ -10117,8 +10440,8 @@ async function readDefinitions({ adapter, spec: spec2, publish: publish5, journa
   if (!hasRepo) return give({}, "No repository to read: the card offers the common definitions.", "ok");
   try {
     const skill = await loadSkill("define-objective");
-    const runDir = join10(spec2.runDir, "definitions");
-    await mkdir3(runDir, { recursive: true, mode: 448 });
+    const runDir = join12(spec2.runDir, "definitions");
+    await mkdir4(runDir, { recursive: true, mode: 448 });
     const schema = definitionsOutputSchema();
     const [lines, listed] = await Promise.all([countingLines(spec2.cwd), listTrackedFiles(spec2.cwd)]);
     const signal = AbortSignal.any([spec2.signal, AbortSignal.timeout(timeoutMs)]);
@@ -10179,7 +10502,7 @@ ${renderTrackedFiles(listed.files, void 0, listed.wiki)}
     if (!result) throw new Error("no answer");
     const parsed = DefinitionsAnswer.safeParse(JSON.parse(result));
     if (!parsed.success) throw new Error("an answer in the wrong shape");
-    const checked = checkProposals(parsed.data, (file) => existsSync3(join10(spec2.cwd, file)));
+    const checked = checkProposals(parsed.data, (file) => existsSync4(join12(spec2.cwd, file)));
     const definitions2 = lever ? checked[lever] ? { [lever]: checked[lever] } : {} : checked;
     const kept = Object.values(definitions2).reduce((n, list) => n + (list?.length ?? 0), 0);
     const read6 = Object.values(definitions2).flat().filter((d) => d?.found).length;
@@ -10452,10 +10775,10 @@ function localDate(timezone, at) {
 
 // ../daemon/src/run-job.ts
 import { randomUUID as randomUUID12 } from "crypto";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir5, readFile as readFile8, rm as rm4 } from "fs/promises";
 import { homedir as homedir4, tmpdir } from "os";
-import { join as join12, resolve as resolve4 } from "path";
+import { join as join13, resolve as resolve4 } from "path";
 
 // ../daemon/src/events.ts
 var JobEventWriter = class {
@@ -10535,168 +10858,6 @@ function lighten(value) {
   return value ?? null;
 }
 
-// ../daemon/src/build-job.ts
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join11 } from "path";
-var PLAN_TOOL = "mcp__nanopm__build_plan";
-var STEP_TOOL = "mcp__nanopm__build_step";
-var CLAUDE_CODE_MIN = "2.1.283";
-async function prepareBuild(client, job, clone, adapter) {
-  const params = job.params ?? {};
-  const dir = buildDir(homedir3(), job.id);
-  let made = false;
-  try {
-    const [solution, machine] = await Promise.all([loadSolution(client, job.project_id, String(params.solution_id ?? "")), machineRefusal(adapter)]);
-    const refused = buildRefusal(solution, { anyway: params.anyway === true }) ?? machine;
-    if (refused) return { ok: false, outcome: failed(refused) };
-    const branch = buildBranch(solution.ref, solution.title);
-    await mkdir4(join11(dir, ".."), { recursive: true, mode: 448 });
-    const { base, fork, worktree } = await addWorktree(clone, dir, branch);
-    made = true;
-    await handOverTheSpec(worktree, solution.agent_spec);
-    await startSolution(client, job.project_id, solution.ref, job.id);
-    return { ok: true, build: { solution, clone, dir, worktree, branch, base, fork, network: buildNetwork(await readdir2(dir)) } };
-  } catch (err) {
-    if (made) await removeWorktree(clone, dir);
-    return { ok: false, outcome: failed(errorMessage(err)) };
-  }
-}
-async function runBuildJob(input) {
-  const { client, job, adapter, spec: spec2, events, log, verifyCommand: verifyCommand2 } = input;
-  const { solution, clone, dir, worktree, branch, base, fork } = input.build;
-  await log("build.start", `building ${solution.ref} on ${branch}, in a copy of your code`);
-  await events.write("text", { text: `Working on ${branch}, in a copy of your code. Your own checkout is not touched.` });
-  let plan = null;
-  const done = /* @__PURE__ */ new Set();
-  let usage;
-  let said = "";
-  const stop2 = async (message, opts = { keep: true }) => {
-    await unstartSolution(client, job.project_id, solution.ref, solution.status).catch(() => void 0);
-    if (opts.keep) await commitAll(worktree, `${solution.ref}: unfinished \u2014 ${solution.title}`).catch(() => null);
-    else await removeWorktree(clone, dir);
-    return { ...failed(opts.keep ? `${message}. What was done is on ${branch}, in ${dir}.` : message), usage };
-  };
-  const session2 = async (prompt, resume2) => {
-    let end;
-    for await (const event of adapter.run({ ...spec2, prompt, resumeSessionId: resume2 ? spec2.sessionId : void 0 })) {
-      await input.onEvent(event);
-      if (event.type === "tool_use" && event.tool === PLAN_TOOL && !plan) {
-        plan = stepsOf(event.input);
-        if (plan) await events.write("plan", { steps: plan });
-      } else if (event.type === "tool_result" && event.tool === STEP_TOOL && !event.isError) {
-        const { step, summary } = event.input ?? {};
-        const index = Number(step) - 1;
-        if (Number.isInteger(index) && index >= 0 && !done.has(index)) {
-          const says = plan?.[index] ?? `step ${index + 1}`;
-          const commit = await commitAll(worktree, `${solution.ref}: ${says}`, summary);
-          done.add(index);
-          await events.write("step", { step: index + 1, says, commit: commit?.sha ?? null, files: commit?.files ?? 0 });
-        }
-      } else if (event.type === "finished") {
-        usage = sumUsage(usage, event.usage);
-        said = event.result;
-        end = { status: "succeeded" };
-      } else if (event.type === "failed") {
-        end = { status: "failed", error: { code: event.code, message: event.message } };
-      }
-    }
-    return end?.status === "succeeded" ? null : end ?? failed("the agent produced no result");
-  };
-  const check = verifyCommand2 ? `
-
-The project's own check is \`${verifyCommand2}\`. Run it before your last build_step, fix what it reports, and give its result under *How I checked it*.` : "";
-  let ended = await session2(spec2.prompt + check, false);
-  for (let resumes = 0; !ended && !(plan && !stepsLeft(plan, done).length); resumes += 1) {
-    if (resumes >= BUILD_RESUMES_MAX) {
-      const left = stepsLeft(plan, done).length;
-      return stop2(plan ? `Nano stopped with ${left} step${left === 1 ? "" : "s"} of its plan left` : "Nano stopped without saying its plan");
-    }
-    ended = await session2(carryOn(plan, done), true);
-  }
-  if (ended) return stop2(ended.error?.message ?? "the build stopped");
-  await commitAll(worktree, `${solution.ref}: ${solution.title}`);
-  if (!await commitsSinceFork(worktree, fork)) return stop2("the build finished without changing anything", { keep: false });
-  const rebased = await rebaseOnto(worktree, base);
-  if (!rebased.ok) return stop2(`${base} moved while Nano was building, and the same files changed on both sides: ${rebased.files.join(", ") || "see git status"}`);
-  const [pushed, noPr, page] = await Promise.all([pushBranch(worktree, branch), ghReady(worktree), solutionPage(client, job.project_id, solution.ref)]);
-  if (!pushed.pushed) return stop2(`the push failed: ${pushed.reason}`);
-  const pr = noPr ? null : await openPullRequest(worktree, { branch, base, title: `${solution.ref}: ${solution.title}`, body: prBody(said, page) });
-  if (pr && !pr.ok) return { ...failed(`the branch ${branch} is pushed, but GitHub refused the pull request: ${pr.reason}${pushed.reviewUrl ? `. Open it yourself: ${pushed.reviewUrl}` : ""}`), usage };
-  if (pr) {
-    await events.write("pr", { number: pr.number, url: pr.url });
-    await log("build.pr", `draft pull request #${pr.number} for ${solution.ref}`);
-  }
-  await removeWorktree(clone, dir);
-  return {
-    status: "succeeded",
-    result: [
-      said.trim(),
-      "",
-      pr ? `Draft pull request #${pr.number} \xB7 ${pr.url}` : `Pushed ${branch}. No pull request: ${noPr}.${pushed.reviewUrl ? ` ${pushed.reviewUrl}` : ""}`
-    ].filter(Boolean).join("\n"),
-    data: { branch, session: spec2.sessionId, ...pr ? { pr: { number: pr.number, url: pr.url } } : { review_url: pushed.reviewUrl ?? null } },
-    usage
-  };
-}
-var failed = (message) => ({ status: "failed", error: { code: "harness_error", message } });
-async function loadSolution(client, projectId, id) {
-  const { data, error } = await client.from("solutions").select(BUILD_COLUMNS).eq("id", id).eq("project_id", projectId).is("superseded_by", null).maybeSingle();
-  if (error) throw new Error(`could not read the solution: ${error.message}`);
-  if (!data) throw new Error("that solution is not on this project any more");
-  return data;
-}
-async function machineRefusal(adapter) {
-  const found = await adapter.detect();
-  const version = /\d+\.\d+\.\d+/.exec(found.version ?? "")?.[0];
-  if (version && !newer(CLAUDE_CODE_MIN, version)) return null;
-  return `a build needs Claude Code ${CLAUDE_CODE_MIN} or later on this machine${found.version ? ` (it has ${found.version})` : ""}: run claude update`;
-}
-async function handOverTheSpec(worktree, agentSpec) {
-  await mkdir4(join11(worktree.dir, ".nanopm"), { recursive: true });
-  await writeFile5(join11(worktree.dir, ".nanopm", "SPEC.md"), agentSpec);
-  const exclude = join11(await commonGitDir(worktree), "info", "exclude");
-  const current = await readFile7(exclude, "utf8").catch(() => "");
-  if (!current.split("\n").includes(".nanopm/")) {
-    await mkdir4(join11(exclude, ".."), { recursive: true });
-    await writeFile5(exclude, `${current}${current && !current.endsWith("\n") ? "\n" : ""}.nanopm/
-`);
-  }
-}
-function stepsOf(input) {
-  const steps = input?.steps;
-  return Array.isArray(steps) && steps.length && steps.every((s) => typeof s === "string") ? steps : null;
-}
-function carryOn(plan, done) {
-  if (!plan) return "You stopped before saying your plan. Call build_plan with it now, then build it step by step, calling build_step after each.";
-  const left = stepsLeft(plan, done);
-  return [
-    `Steps ${left.map((i) => i + 1).join(", ")} of your plan are not done yet:`,
-    ...left.map((i) => `${i + 1}. ${plan[i]}`),
-    "",
-    "Check git log and git status to see where you are, then carry on: finish each step, run its checks, and call build_step after it. Do not run anything in the background."
-  ].join("\n");
-}
-async function solutionPage(client, projectId, ref) {
-  const { data } = await client.from("projects").select("slug").eq("id", projectId).maybeSingle();
-  return data?.slug ? `${webUrl()}/p/${data.slug}/roadmap/${ref}` : null;
-}
-function prBody(said, page) {
-  return [
-    said.trim(),
-    page ? `
-The solution and its spec: ${page}` : "",
-    "\n\u2014 Built by NanoPM with Claude Code. A draft: review before merging."
-  ].filter(Boolean).join("\n");
-}
-async function startSolution(client, projectId, ref, jobId) {
-  const { error } = await client.rpc("start_solution", { p_project_id: projectId, p_ref: ref, p_job_id: jobId });
-  if (error) throw new Error(pgMessage(error));
-}
-async function unstartSolution(client, projectId, ref, was) {
-  await client.rpc("unstart_solution", { p_project_id: projectId, p_ref: ref, p_to: was === "proposed" ? "proposed" : "accepted" });
-}
-
 // ../daemon/src/run-job.ts
 import { hostname } from "os";
 
@@ -10731,11 +10892,13 @@ async function runJob(job, ctx) {
     };
   }
   const durationMs = Date.now() - startedAt;
+  const over = outcome.status !== "waiting";
   await events.status(outcome.status, outcome.error ? { error: outcome.error } : crewRun(job) && outcome.result ? { text: outcome.result } : {});
   await withRetry(
     () => ctx.client.from("jobs").update({
       status: outcome.status,
-      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      // A parked job is not over: it waits, with no heartbeat, for the founder or the limit.
+      finished_at: over ? (/* @__PURE__ */ new Date()).toISOString() : null,
       // A mapping run's root row belongs to SQL: checkpoints, receipt and text land there
       // with the publication. A resumed job's own row is free to carry the text.
       ...job.skill === "problems" && !job.resume_of ? {} : { result: outcome.result !== void 0 ? { text: outcome.result, ...outcome.data } : null },
@@ -10748,7 +10911,7 @@ async function runJob(job, ctx) {
     ctx,
     job,
     "job.end",
-    outcome.status === "succeeded" ? `finished ${job.skill}` : outcome.status === "cancelled" ? `${job.skill} cancelled by the user` : `${job.skill} failed: ${outcome.error?.message}`,
+    outcome.status === "succeeded" ? `finished ${job.skill}` : outcome.status === "waiting" ? `${job.skill} waits, with nothing running` : outcome.status === "cancelled" ? `${job.skill} cancelled by the user` : `${job.skill} failed: ${outcome.error?.message}`,
     {
       usage: {
         tokens: usageTokens(outcome.usage),
@@ -10757,15 +10920,15 @@ async function runJob(job, ctx) {
         ...outcome.usage?.contextPeakTokens ? { context_peak: outcome.usage.contextPeakTokens } : {},
         ...outcome.usage?.reads ? { files_read: outcome.usage.reads.files, calls: outcome.usage.reads.calls } : {}
       },
-      outcome: outcome.status === "succeeded" ? "ok" : "error"
+      outcome: outcome.status === "succeeded" || !over ? "ok" : "error"
     }
   );
   return outcome;
 }
 async function execute(job, skill, ctx, events) {
-  const runDir = join12(nanopmHome(), "run", job.id);
+  const runDir = join13(nanopmHome(), "run", job.id);
   await mkdir5(runDir, { recursive: true, mode: 448 });
-  const resumeSessionId = job.resume_of ? await sessionOf(ctx.client, job.resume_of) : void 0;
+  const resumeSessionId = job.resume_of ? await sessionOf(ctx.client, job.resume_of) : job.harness_session_id ?? void 0;
   const sessionId = resumeSessionId ?? randomUUID12();
   await ctx.client.from("jobs").update({ harness_session_id: sessionId }).eq("id", job.id);
   const adapter = ctx.adapter ?? new ClaudeCodeAdapter();
@@ -10894,6 +11057,7 @@ async function execute(job, skill, ctx, events) {
     capabilities,
     harnessWeb,
     network: build2?.network,
+    answerFile: build2 ? buildAnswerFile(job.id) : void 0,
     withoutTools: skill.manifest.withoutTools,
     // The workspace reaches the memory server only for a job that changes files; that is
     // what lets the build's tools refuse everywhere else.
@@ -11075,7 +11239,7 @@ function harnessWebFor(searchProvider, machineCanSearch) {
 }
 async function machineWebSearch() {
   try {
-    const parsed = JSON.parse(await readFile8(join12(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile8(join13(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.webSearch === true;
   } catch {
     return false;
@@ -11117,7 +11281,7 @@ function buildHeader(job, project, cwd, harnessWeb = false, memory = false) {
   return lines.join("\n");
 }
 function scratchDir(jobId) {
-  return join12(tmpdir(), `nanopm-run-${jobId}`);
+  return join13(tmpdir(), `nanopm-run-${jobId}`);
 }
 async function resolveCwd(ctx, job, params, fallback, mustBeTheClone = false) {
   const refuse2 = (why) => {
@@ -11142,7 +11306,7 @@ async function resolveCwd(ctx, job, params, fallback, mustBeTheClone = false) {
     await mkdir5(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
-  if (existsSync4(allowed)) return resolve4(allowed);
+  if (existsSync5(allowed)) return resolve4(allowed);
   if (mustBeTheClone) refuse2(`${allowed} is not on this machine any more`);
   await mkdir5(fallback, { recursive: true, mode: 448 });
   return fallback;
@@ -11156,7 +11320,7 @@ function harnessEnv(timeoutMs, source = process.env) {
   const home = source.HOME ?? homedir4();
   const env = {
     HOME: home,
-    PATH: [source.PATH ?? "/usr/local/bin:/usr/bin:/bin", join12(home, ".local", "bin")].join(":"),
+    PATH: [source.PATH ?? "/usr/local/bin:/usr/bin:/bin", join13(home, ".local", "bin")].join(":"),
     MCP_TOOL_TIMEOUT: String(timeoutMs)
   };
   for (const key of ["USER", "LANG", "TMPDIR", "SHELL", "ANTHROPIC_API_KEY", "CLAUDE_CONFIG_DIR"]) {
@@ -11236,6 +11400,8 @@ async function runDaemon(options = {}) {
   const startedAt = Date.now();
   let lastDeployCheck = 0;
   const DEPLOY_CHECK_MS = 30 * 6e4;
+  const PAUSE_CHECK_MS = 6e4;
+  let lastPauseCheck = 0;
   const UPDATE_CHECK_MS = 60 * 6e4;
   const updatable = !options.once && installKind() === "installer";
   let lastUpdateCheck = Date.now() - UPDATE_CHECK_MS + 5 * 6e4;
@@ -11293,6 +11459,10 @@ async function runDaemon(options = {}) {
         continue;
       }
       if (options.once && Date.now() - startedAt > onceTimeoutMs) break;
+      if (!options.once && Date.now() - lastPauseCheck > PAUSE_CHECK_MS) {
+        lastPauseCheck = Date.now();
+        for (const id of await resumePausedBuilds(auth.client, daemonId).catch(() => [])) log(`build ${id}: the Claude limit reset, carrying on`);
+      }
       if (!options.once && Date.now() - lastDeployCheck > DEPLOY_CHECK_MS) {
         lastDeployCheck = Date.now();
         for (const check of await reviewDeploys(auth.client, daemonId).catch(() => [])) {
@@ -11421,7 +11591,7 @@ var heldInThisProcess = false;
 function acquireLock() {
   if (heldInThisProcess) throw new Error("a nanopm daemon is already running in this process");
   mkdirSync(nanopmHome(), { recursive: true, mode: 448 });
-  const path = join13(nanopmHome(), "daemon.pid");
+  const path = join14(nanopmHome(), "daemon.pid");
   for (; ; ) {
     try {
       const fd = openSync(path, "wx");
@@ -11493,10 +11663,11 @@ async function claimNext(client, daemonId, skills) {
   return rows2[0] ?? null;
 }
 async function reclaimOwnJobs(client, daemonId) {
-  const { data: stale } = await client.from("jobs").select("id, project_id, skill").eq("assigned_daemon_id", daemonId).in("status", ["running", "waiting"]);
+  const { data: stale } = await client.from("jobs").select("id, project_id, skill, status, attempt, params").eq("assigned_daemon_id", daemonId).in("status", ["running", "waiting"]);
   const ids = [];
   for (const job of stale ?? []) {
     await killOrphanedHarness(job.id);
+    if (job.skill === BUILD_SKILL && (job.status === "waiting" || await requeueLostBuild(client, job))) continue;
     const error = { code: "interrupted", message: "the daemon stopped while this job was running" };
     await client.from("jobs").update({ status: "failed", finished_at: (/* @__PURE__ */ new Date()).toISOString(), error }).eq("id", job.id).in("status", ["running", "waiting"]);
     await client.from("job_events").insert({ job_id: job.id, seq: 0, kind: "status", payload: { status: "failed", error }, author_kind: "nanopm" });
@@ -11508,13 +11679,13 @@ async function reclaimOwnJobs(client, daemonId) {
 async function harnessPids(runDir) {
   const dirs = [runDir];
   try {
-    for (const d of await readdir3(runDir, { withFileTypes: true })) if (d.isDirectory()) dirs.push(join13(runDir, d.name));
+    for (const d of await readdir3(runDir, { withFileTypes: true })) if (d.isDirectory()) dirs.push(join14(runDir, d.name));
   } catch {
   }
   const pids = [];
   for (const dir of dirs) {
     try {
-      const pid = Number((await readFile9(join13(dir, "harness.pid"), "utf8")).trim());
+      const pid = Number((await readFile9(join14(dir, "harness.pid"), "utf8")).trim());
       if (pid > 1) pids.push(pid);
     } catch {
     }
@@ -11522,7 +11693,7 @@ async function harnessPids(runDir) {
   return pids;
 }
 async function killOrphanedHarness(jobId) {
-  const runDir = join13(nanopmHome(), "run", jobId);
+  const runDir = join14(nanopmHome(), "run", jobId);
   for (const pid of await harnessPids(runDir)) {
     try {
       process.kill(pid, "SIGTERM");
@@ -11532,7 +11703,7 @@ async function killOrphanedHarness(jobId) {
   await rm5(runDir, { recursive: true, force: true });
 }
 async function registerDaemon(auth, version, opts = {}) {
-  const path = join13(nanopmHome(), "daemon.json");
+  const path = join14(nanopmHome(), "daemon.json");
   let identity = null;
   try {
     identity = JSON.parse(await readFile9(path, "utf8"));
@@ -11574,7 +11745,7 @@ async function registerDaemon(auth, version, opts = {}) {
 }
 async function rememberDaemon(id, shared = false) {
   await mkdir6(nanopmHome(), { recursive: true, mode: 448 });
-  await writeFile6(join13(nanopmHome(), "daemon.json"), JSON.stringify({ id, shared }, null, 2) + "\n", { mode: 384 });
+  await writeFile6(join14(nanopmHome(), "daemon.json"), JSON.stringify({ id, shared }, null, 2) + "\n", { mode: 384 });
 }
 async function heartbeat(client, daemonId) {
   await client.from("daemons").update({ status: "online", last_seen_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", daemonId);
@@ -11628,13 +11799,15 @@ function contextFromEnv(env = process.env) {
     userId: env.NANOPM_USER_ID,
     actor: env.NANOPM_ACTOR,
     askTimeoutMs: Number(env.NANOPM_ASK_TIMEOUT_MS ?? 3 * 60 * 60 * 1e3),
-    workspace: env.NANOPM_WORKSPACE || void 0
+    workspace: env.NANOPM_WORKSPACE || void 0,
+    answerFile: env.NANOPM_ANSWER_FILE || void 0
   };
 }
 
 // ../memory-mcp/src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { randomUUID as randomUUID13 } from "crypto";
+import { readFile as readFile10, unlink } from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
 import { z as z21 } from "zod";
 
@@ -12160,6 +12333,8 @@ ${renderMap()}`,
       }
     },
     async ({ question, options, why }, extra) => {
+      const handed = ctx.answerFile ? await takeAnswer(ctx.answerFile) : null;
+      if (handed !== null) return json({ answer: handed, skipped: false });
       const answer = await askUser(ctx, { question, options, why }, extra.signal);
       if (answer === null) return failure("No answer arrived in time, or the job was cancelled. Do not ask again; continue with what you have.");
       return json({ answer, skipped: /^\s*(skip|passe?r?)\s*$/i.test(answer) || answer.trim() === "" });
@@ -12724,6 +12899,12 @@ async function writeContext(ctx, items, refused = []) {
   await logActivity2(ctx, "memory.write", `wrote ${written.length} items under ${topics}: ${written.map((w) => w.key).join(", ")}${refusedNote}`);
   return { written };
 }
+async function takeAnswer(answerFile) {
+  const taken = `${answerFile}.taken`;
+  const answer = await readFile10(taken, "utf8").catch(() => null);
+  if (answer !== null) await unlink(taken).catch(() => void 0);
+  return answer;
+}
 async function askUser(ctx, q, signal) {
   const seq = await nextSeq(ctx);
   const { error } = await ctx.client.from("job_events").insert({ job_id: ctx.jobId, seq, kind: "question", payload: { question: q.question, options: q.options ?? null, why: q.why ?? null }, author_kind: "nanopm" });
@@ -13509,19 +13690,19 @@ async function startMemoryServer(env = process.env) {
 }
 
 // src/commands/add.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 
 // src/project.ts
 import { execFile as execFile7 } from "child_process";
-import { basename } from "path";
+import { basename as basename2 } from "path";
 import { promisify as promisify7 } from "util";
 
 // src/local.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join15 } from "path";
 async function localDaemonId() {
   try {
-    const parsed = JSON.parse(await readFile10(join14(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile11(join15(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.id ?? null;
   } catch {
     return null;
@@ -13546,7 +13727,7 @@ async function detectRepo(cwd) {
   } catch {
     remote = null;
   }
-  const name = remote ? remote.split("/").pop() : basename(root2);
+  const name = remote ? remote.split("/").pop() : basename2(root2);
   return { root: root2, remote, name, empty: await repoIsEmpty(root2) };
 }
 async function repoIsEmpty(root2) {
@@ -13557,7 +13738,7 @@ async function repoIsEmpty(root2) {
   }
   const files = (await execFileAsync7("git", ["-C", root2, "ls-files"])).stdout.split("\n").filter(Boolean);
   return files.every((f) => {
-    const base = basename(f);
+    const base = basename2(f);
     return base.startsWith(".") || /^(readme|licen[cs]e)(\.|$)/i.test(base);
   });
 }
@@ -13656,7 +13837,7 @@ async function add(file, opts) {
     text2 = await readStdin();
   } else {
     try {
-      text2 = await readFile11(file, "utf8");
+      text2 = await readFile12(file, "utf8");
     } catch {
       throw new Error(`could not read ${file}`);
     }
@@ -13671,7 +13852,7 @@ async function add(file, opts) {
 }
 
 // src/commands/run.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
 import { setTimeout as sleep3 } from "timers/promises";
 
@@ -14003,7 +14184,7 @@ function questionBlock(p) {
 
 // src/commands/run.ts
 async function answersFromFile(path) {
-  const raw = JSON.parse(await readFile12(path, "utf8"));
+  const raw = JSON.parse(await readFile13(path, "utf8"));
   const entries = raw.map((a) => typeof a === "string" ? { answer: a } : a);
   return scriptedAnswerer(entries);
 }
@@ -14087,6 +14268,7 @@ async function streamJob(client, jobId, opts) {
   const shownAnswers = /* @__PURE__ */ new Set();
   for (; ; ) {
     const { data: events } = await client.from("job_events").select("id, seq, kind, payload, author_kind").eq("job_id", jobId).gt("id", lastId).order("id", { ascending: true });
+    for (const ev of events ?? []) if (ev.kind === "answer") answered.add(ev.seq);
     for (const ev of events ?? []) {
       lastId = Math.max(lastId, Number(ev.id));
       const payload = ev.payload ?? {};
@@ -14225,16 +14407,16 @@ async function askOne(auth, projectId, question, daemonId, opts, out) {
 
 // src/commands/daemon-service.ts
 import { execFile as execFile8 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir7, readFile as readFile13, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir7, readFile as readFile14, rm as rm6, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { promisify as promisify8 } from "util";
 
 // package.json
 var package_default = {
   name: "@nanopm/cli",
-  version: "0.1.11",
+  version: "0.1.12",
   description: "An autonomous product manager for builders who run several small products. Runs on your machine, drives your own coding harness.",
   type: "module",
   license: "MIT",
@@ -14286,10 +14468,10 @@ var VERSION = package_default.version;
 var execFileAsync8 = promisify8(execFile8);
 var LAUNCHD_LABEL = "pm.nano.daemon";
 function plistPath() {
-  return join15(homedir5(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return join16(homedir5(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function daemonLogPath() {
-  return join15(nanopmHome(), "daemon.log");
+  return join16(nanopmHome(), "daemon.log");
 }
 function renderPlist(opts) {
   const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -14349,8 +14531,8 @@ async function installDaemon(out = (l) => console.log(l), opts = {}) {
   const bin = process.argv[1];
   if (!bin) throw new Error("cannot locate the nanopm binary");
   const home = homedir5();
-  const path = [process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", join15(home, ".local", "bin")].join(":");
-  await mkdir7(join15(home, "Library", "LaunchAgents"), { recursive: true });
+  const path = [process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", join16(home, ".local", "bin")].join(":");
+  await mkdir7(join16(home, "Library", "LaunchAgents"), { recursive: true });
   await mkdir7(nanopmHome(), { recursive: true, mode: 448 });
   if (opts.shared !== void 0) await rememberShared(opts.shared);
   await found({ ...detection, authenticated: true });
@@ -14367,7 +14549,7 @@ function guiTarget() {
   return `gui/${process.getuid?.() ?? 501}`;
 }
 async function restartDaemon() {
-  if (!existsSync5(plistPath())) return false;
+  if (!existsSync6(plistPath())) return false;
   await execFileAsync8("launchctl", ["kickstart", "-k", `${guiTarget()}/${LAUNCHD_LABEL}`]);
   return true;
 }
@@ -14380,7 +14562,7 @@ async function uninstallDaemon(out = (l) => console.log(l)) {
 }
 async function daemonStatus(out = (l) => console.log(l)) {
   const id = await localDaemonId();
-  const installed = process.platform === "darwin" && existsSync5(plistPath());
+  const installed = process.platform === "darwin" && existsSync6(plistPath());
   out(`launchd: ${installed ? "installed" : "not installed"}`);
   if (!id) {
     out("daemon: never registered on this machine");
@@ -14402,7 +14584,7 @@ async function daemonStatus(out = (l) => console.log(l)) {
 }
 async function daemonLogs(lines = 50) {
   try {
-    const text2 = await readFile13(daemonLogPath(), "utf8");
+    const text2 = await readFile14(daemonLogPath(), "utf8");
     return text2.trimEnd().split("\n").slice(-lines).join("\n");
   } catch {
     return `no log at ${daemonLogPath()} yet`;
@@ -14410,17 +14592,17 @@ async function daemonLogs(lines = 50) {
 }
 async function localWebSearch() {
   try {
-    const parsed = JSON.parse(await readFile13(join15(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile14(join16(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.webSearch === true;
   } catch {
     return false;
   }
 }
 async function rememberWebSearch(webSearch2) {
-  const path = join15(nanopmHome(), "daemon.json");
+  const path = join16(nanopmHome(), "daemon.json");
   let parsed = {};
   try {
-    parsed = JSON.parse(await readFile13(path, "utf8"));
+    parsed = JSON.parse(await readFile14(path, "utf8"));
   } catch {
     parsed = {};
   }
@@ -14429,17 +14611,17 @@ async function rememberWebSearch(webSearch2) {
 }
 async function localShared() {
   try {
-    const parsed = JSON.parse(await readFile13(join15(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile14(join16(nanopmHome(), "daemon.json"), "utf8"));
     return Boolean(parsed.shared);
   } catch {
     return false;
   }
 }
 async function rememberShared(shared) {
-  const path = join15(nanopmHome(), "daemon.json");
+  const path = join16(nanopmHome(), "daemon.json");
   let parsed = {};
   try {
-    parsed = JSON.parse(await readFile13(path, "utf8"));
+    parsed = JSON.parse(await readFile14(path, "utf8"));
   } catch {
     parsed = {};
   }
@@ -14751,6 +14933,12 @@ async function verifyCommand(command, opts) {
   return [`${project.name} will verify with:`, "", `  ${next}`, "", "A build runs it in its sandboxed copy of the repository before its last step."].join("\n");
 }
 
+// src/commands/build.ts
+import { execFile as execFile10 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { promisify as promisify9 } from "util";
+
 // src/format/opportunities.ts
 function renderOpportunities(rows2, lens, opts) {
   const paint = painter(opts.color);
@@ -15625,35 +15813,64 @@ function normalizeRef(input, items) {
 }
 
 // src/commands/build.ts
+var execFileAsync9 = promisify9(execFile10);
 async function build(ref, opts) {
   const { renderer, out } = rendererFor(opts.out);
   const auth = await authenticate();
   const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
   const repo = await detectRepo(opts.cwd);
   if (!repo) throw new Error("run this inside the repository, so NanoPM builds from the clone you are looking at");
-  const [daemon, local, { data: refs }] = await Promise.all([
-    awakeDaemon(auth.client, auth.userId),
-    localDaemonId(),
-    auth.client.from("solutions").select("ref").eq("project_id", project.id).is("superseded_by", null)
-  ]);
+  const { data: solutions } = await auth.client.from("solutions").select("id, ref, title, status").eq("project_id", project.id).is("superseded_by", null);
+  const wanted = normalizeRef(ref, solutions ?? []);
+  const solution = (solutions ?? []).find((s) => s.ref === wanted);
+  if (!solution) throw new Error(`No solution ${wanted} on the Roadmap.`);
+  const stream = async (jobId2) => {
+    out(`${solution.ref}  ${solution.title}`);
+    const answerer = opts.answersFile ? await answersFromFile(opts.answersFile) : answersFromTerminal(out);
+    return streamJob(auth.client, jobId2, { pollMs: 700, out, renderer, cancelSignal: opts.cancelSignal, answerer, verbose: verboseWanted() });
+  };
+  const live = await buildOf(auth.client, project.id, [...ACTIVE_STATUSES]);
+  if (live) {
+    if (live.solutionId !== solution.id) throw new Error(`${project.name} already has a build on its way: one at a time. \`nanopm build\` on that solution comes back to it.`);
+    if (opts.throwAway) throw new Error(`${solution.ref}'s build is still on its way: stop it first (\`nanopm stop\`).`);
+    return stream(live.id);
+  }
+  const stopped = opts.continue || opts.throwAway ? await buildOf(auth.client, project.id, ["failed", "cancelled"], solution.id) : null;
+  if ((opts.continue || opts.throwAway) && !stopped) throw new Error(`${solution.ref} has no stopped build to ${opts.continue ? "continue" : "throw away"}.`);
+  if (opts.throwAway) return throwAway(auth.client, stopped.origin, repo.root, out);
+  const [daemon, local] = await Promise.all([awakeDaemon(auth.client, auth.userId), localDaemonId()]);
   if (!local || daemon?.id !== local) throw new Error("This machine\u2019s daemon is asleep, so nothing was queued. `nanopm daemon install` starts it; then build again.");
   await rememberClone(auth.client, project.id, repo.root);
-  const { jobId, solution } = await queueBuild(auth.client, {
+  const { jobId } = await queueBuild(auth.client, {
     projectId: project.id,
     userId: auth.userId,
     daemonId: local,
-    ref: normalizeRef(ref, refs ?? []),
+    ref: solution.ref,
     repoPath: repo.root,
-    anyway: opts.anyway
+    anyway: opts.anyway,
+    ...stopped ? { resumeOf: { id: stopped.id, was: stopped.was, origin: stopped.origin } } : {}
   });
-  out(`${solution.ref}  ${solution.title}`);
-  const answerer = opts.answersFile ? await answersFromFile(opts.answersFile) : answersFromTerminal(out);
-  return streamJob(auth.client, jobId, { pollMs: 700, out, renderer, cancelSignal: opts.cancelSignal, answerer, verbose: verboseWanted() });
+  return stream(jobId);
+}
+async function buildOf(client, projectId, statuses, solutionId) {
+  let query = client.from("jobs").select("id, params").eq("project_id", projectId).eq("skill", BUILD_SKILL).in("status", statuses);
+  if (solutionId) query = query.eq("params->>solution_id", solutionId);
+  const { data } = await query.order("created_at", { ascending: false }).limit(1).maybeSingle();
+  const params = data?.params ?? {};
+  return data ? { id: data.id, solutionId: params.solution_id ?? "", was: wasOf(data.params), origin: params.origin ?? data.id } : null;
+}
+async function throwAway(client, jobId, clone, out) {
+  const { place } = await loadBuildHistory(client, [jobId], { home: homedir6(), jobId });
+  if (!place) throw new Error("that build left nothing on this machine.");
+  if (existsSync7(place.dir)) await execFileAsync9("git", ["-C", clone, "worktree", "remove", "--force", place.dir]);
+  await execFileAsync9("git", ["-C", clone, "branch", "-D", place.branch]).catch(() => void 0);
+  out(`Thrown away: the copy of the code and the local branch ${place.branch}.`);
+  return 0;
 }
 
 // src/detect-sources.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join17 } from "path";
 var ENV_FILES = [".env", ".env.local", ".env.development.local", ".env.development", ".env.example"];
 var POSTGRES_KEYS = [
   "DATABASE_URL",
@@ -15703,7 +15920,7 @@ async function envFiles(repoRoot) {
   const out = [];
   for (const file of ENV_FILES) {
     try {
-      out.push({ file, env: parseEnv(await readFile14(join16(repoRoot, file), "utf8")) });
+      out.push({ file, env: parseEnv(await readFile15(join17(repoRoot, file), "utf8")) });
     } catch {
       continue;
     }
@@ -16472,7 +16689,7 @@ async function seedWatches(watches2, read6) {
 }
 
 // src/commands/watch.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 function cursorFor(source, watchId) {
   const all = source.cursor ?? {};
   return all[watchId] ?? {};
@@ -16533,7 +16750,7 @@ async function addWatch(labelOrId, id, opts) {
   const paint = painter(color);
   if (!labelOrId || !id) throw new Error('say which feed and what to call it: nanopm watch add <source> <id> --query "\u2026"');
   if (opts.query && opts.queryFile) throw new Error("--query or --query-file, not both");
-  const query = opts.queryFile ? await readFile15(opts.queryFile, "utf8") : opts.query ?? "";
+  const query = opts.queryFile ? await readFile16(opts.queryFile, "utf8") : opts.query ?? "";
   const watch = watchInput(id, query, opts);
   const auth = await authenticate();
   const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
@@ -17466,7 +17683,7 @@ async function invite(email, opts) {
   const [, ...rest] = inviteLines({ name: project.name, code, email: email.trim().toLowerCase(), web: webUrl() });
   return [`Invite to ${paint(ANSI.bold, project.name)}: ${paint(ANSI.bold, code)}`, ...rest.map((l) => l ? paint(ANSI.dim, l) : l)].join("\n");
 }
-async function join17(code, opts) {
+async function join18(code, opts) {
   const normalized2 = code.trim().toUpperCase();
   if (!INVITE_CODE.test(normalized2)) throw new Error(`that does not look like an invite code: ten letters and digits, like ${"K7PQ2XM9RT"}`);
   const repo = await detectRepo(opts.cwd);
@@ -17751,7 +17968,7 @@ async function showSchedule(opts) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 async function status(opts) {
   const auth = await authenticate();
   const color = opts.color ?? useColor();
@@ -17804,7 +18021,7 @@ async function projectStatus(client, project) {
     openProblems: (problems2.data ?? []).length,
     unprovenProblems: (problems2.data ?? []).filter((p) => p.importance_basis === "judgment").length,
     search: describeSearch(search, await localWebSearch()),
-    onThisMachine: Boolean(project.repoPath && existsSync6(project.repoPath)),
+    onThisMachine: Boolean(project.repoPath && existsSync8(project.repoPath)),
     measures: measures({
       solutionStatuses: (roadmap2.data ?? []).map((r) => r.status),
       decisions: decisions2.data ?? [],
@@ -18167,7 +18384,7 @@ function buildProgram() {
     console.log(await invite(email, { cwd: process.cwd(), projectId: opts.project, color: colorOf(opts) }));
   });
   program.command("join <code>").description("Join a project you were invited to, from inside your clone of its repository").option("--no-color", "plain output").action(async (code, opts) => {
-    console.log(await join17(code, { cwd: process.cwd(), color: colorOf(opts) }));
+    console.log(await join18(code, { cwd: process.cwd(), color: colorOf(opts) }));
   });
   program.command("members").description("Who is on this project, and whether their daemon is awake").option("--project <id>", "project id (default: the project of the current repo)").option("--no-color", "plain output").action(async (opts) => {
     console.log(await members({ cwd: process.cwd(), projectId: opts.project, color: colorOf(opts) }));
@@ -18189,10 +18406,11 @@ function buildProgram() {
   program.command("status").description("What is happening with this product: next review, what is waiting on you, whether the daemon is awake").option("--project <id>", "project id (default: the project of the current repo)").option("--no-color", "plain output").action(async (opts) => {
     console.log(await status({ cwd: process.cwd(), projectId: opts.project, color: colorOf(opts) }));
   });
-  program.command("build <ref>").description("Build a solution from its agent spec, in a copy of this repository, to a draft pull request").option("--project <id>", "project id (default: the project of the current repo)").option("--anyway", "build although its questions for you are not answered").option("--answers <file>", "answer its questions from a file instead of the terminal").action(async (ref, opts) => {
+  program.command("build <ref>").description("Build a solution from its agent spec, in a copy of this repository, to a draft pull request").option("--project <id>", "project id (default: the project of the current repo)").option("--anyway", "build although its questions for you are not answered").option("--continue", "take up a stopped build where it was").option("--throw-away", "delete a stopped build's copy of the code and its local branch").option("--answers <file>", "answer its questions from a file instead of the terminal").action(async (ref, opts) => {
     const cancel = new AbortController();
     process.once("SIGINT", () => cancel.abort());
-    process.exitCode = await build(ref, { cwd: process.cwd(), projectId: opts.project, anyway: opts.anyway, answersFile: opts.answers, cancelSignal: cancel.signal });
+    if (opts.continue && opts.throwAway) throw new Error("--continue or --throw-away, not both.");
+    process.exitCode = await build(ref, { cwd: process.cwd(), projectId: opts.project, anyway: opts.anyway, continue: opts.continue, throwAway: opts.throwAway, answersFile: opts.answers, cancelSignal: cancel.signal });
   });
   program.command("autonomy [level]").description("How far NanoPM may go on its own: read it, or set it").option("--project <id>", "project id (default: the project of the current repo)").action(async (level, opts) => {
     console.log(await autonomy(level, { cwd: process.cwd(), projectId: opts.project }));