@nanopm/cli 0.1.11 → 0.1.13

package/dist/index.js

@@ -67,7 +67,7 @@ var Constants = {
       opportunity_next_action: ["investigate", "explore_solutions"],
       opportunity_priority: ["low", "medium", "high"],
       opportunity_status: ["proposed", "confirmed", "set_aside", "replaced"],
-      notification_kind: ["review", "stalled"],
+      notification_kind: ["review", "stalled", "build_question", "build_pr"],
       problem_status: ["candidate", "confirmed", "addressed", "dropped"],
       provenance: ["observed", "stated", "inferred"],
       source_kind: ["postgres_watch", "posthog_watch"],
@@ -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;
   }
@@ -2177,12 +2189,14 @@ function boardOf(all, solutions) {
   walk(tree);
   const cards2 = [];
   for (const [leafId, list] of byLeaf) {
-    const standing = list.filter((s) => s.status === "proposed");
-    const pick3 = standing.find((s) => s.horizon) ?? null;
+    const standing = list.filter((s) => s.status === "proposed" || s.status === "building");
+    const placed = list.find((s) => s.horizon && s.status !== "rejected") ?? null;
+    const shipped = list.filter((s) => s.status === "done").at(-1);
+    const pick3 = standing.find((s) => s.status === "building") ?? shipped ?? placed;
     const leaf = nodes.get(leafId);
     const branch = leaf ? branchOf(tree, leaf.id) : null;
-    if (!pick3 || !leaf || !branch) continue;
-    cards2.push({ leaf, branch, pick: pick3, others: standing.filter((s) => s.id !== pick3.id), horizon: pick3.horizon, place: pick3.place ?? 1 });
+    if (!pick3 || !placed || !leaf || !branch) continue;
+    cards2.push({ leaf, branch, pick: pick3, others: standing.filter((s) => s.id !== pick3.id), horizon: placed.horizon, place: placed.place ?? 1 });
   }
   const col = (h) => HORIZONS.indexOf(h);
   cards2.sort((a, b) => col(a.horizon) - col(b.horizon) || a.place - b.place || a.pick.created_at.localeCompare(b.pick.created_at));
@@ -3673,7 +3687,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 +3699,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 +3724,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 +3736,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 +3790,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 +3810,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 +4026,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 +4057,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 +4086,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
@@ -4111,11 +4145,14 @@ async function latestVersion(fetchImpl = fetch) {
     return null;
   }
 }
+function installArgs(version, home = homedir2()) {
+  return ["install", "-g", "--prefix", appDir(home), `${PACKAGE}@${version}`, "--prefer-online", "--no-fund", "--no-audit", "--loglevel=error"];
+}
 async function installVersion(version, home = homedir2()) {
   if (!RELEASE.test(version)) return { ok: false, why: `not a version: ${version}` };
   const runtime = join4(root(home), "runtime", "bin");
   try {
-    await execFileAsync2(join4(runtime, "npm"), ["install", "-g", "--prefix", appDir(home), `${PACKAGE}@${version}`, "--no-fund", "--no-audit", "--loglevel=error"], {
+    await execFileAsync2(join4(runtime, "npm"), installArgs(version, home), {
       timeout: 5 * 6e4,
       env: { ...process.env, PATH: `${runtime}:${process.env.PATH ?? ""}`, NPM_CONFIG_UPDATE_NOTIFIER: "false" }
     });
@@ -4137,6 +4174,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 +4201,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 +5328,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";
@@ -5296,11 +5338,26 @@ var BUILD_STEP_MAX = 120;
 var BUILD_RESUMES_MAX = 3;
 var BUILD_TRAILER = "Co-Authored-By: NanoPM <noreply@nanopm.app>";
 var BUILD_COLUMNS = "id, ref, title, status, actor, agent_spec, spec";
+var answered = (q) => typeof q?.answer === "string" && Boolean(q.answer.trim()) && typeof q.ask === "string";
+function openQuestions(spec2) {
+  return (spec2?.questions ?? []).filter((q) => !answered(q)).length;
+}
+function specForAgent(agentSpec, spec2) {
+  const said = (spec2?.questions ?? []).filter(answered);
+  if (!said.length) return agentSpec;
+  return `${agentSpec.trimEnd()}
+
+## The founder's answers
+
+${said.map((q) => `- ${q.ask.trim()}
+  ${q.answer.trim()}`).join("\n")}
+`;
+}
 function buildRefusal(solution, opts = {}) {
   if (solution.actor === "founder") return `${solution.ref} is yours to do, not Nano's to build.`;
   if (!["proposed", "accepted", "building"].includes(solution.status)) return `${solution.ref} is ${solution.status}: only a solution on the roadmap can be built.`;
   if (!solution.agent_spec) return `${solution.ref} has no agent spec yet. Write its specs first: nanopm spec ${solution.ref} --write`;
-  const open = solution.spec?.questions?.length ?? 0;
+  const open = openQuestions(solution.spec);
   if (open && !opts.anyway) {
     return `${solution.ref} still has ${open} question${open === 1 ? "" : "s"} for you. Answer ${open === 1 ? "it" : "them"} in its spec, or build anyway: nanopm build ${solution.ref} --anyway`;
   }
@@ -5340,7 +5397,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 +5405,55 @@ 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*.";
+var isDecideForMe = (answer) => /^\s*decide(\s+for\s+me)?\s*\.?\s*$/i.test(answer);
+function answerForAgent(answer) {
+  return isDecideForMe(answer) ? DECIDE_FOR_ME : answer;
+}
+var BUILD_HISTORY_KINDS = ["worktree", "plan", "step", "question", "answer", "paused", "pr"];
+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", [...BUILD_HISTORY_KINDS]).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 +5469,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 +5541,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) {
@@ -5476,6 +5576,13 @@ async function ghReady(cwd) {
     return /ENOENT/.test(errorMessage(err)) ? "the GitHub CLI is not installed on this machine: brew install gh, then gh auth login" : "the GitHub CLI is not signed in on this machine: run gh auth login in your terminal";
   }
 }
+async function pullRequestMerged(cwd, number) {
+  try {
+    return await gh(cwd, ["pr", "view", String(number), "--json", "state", "--jq", ".state"]) === "MERGED";
+  } catch {
+    return false;
+  }
+}
 async function openPullRequest(cwd, pr) {
   try {
     const out = await gh(cwd, ["pr", "create", "--draft", "--head", pr.branch, "--base", pr.base, "--title", pr.title, "--body", pr.body]);
@@ -5550,46 +5657,27 @@ async function reviewDeploys(client, daemonId, now = /* @__PURE__ */ new Date())
   return results;
 }
 
-// ../daemon/src/review-preflight.ts
-async function reviewWithoutData(client, job) {
-  if (job.skill !== "review" || !job.project_id) return null;
-  if (job.trigger === "user") return null;
-  const { data: connections } = await client.from("connections").select("id, status").eq("project_id", job.project_id).is("removed_at", null);
-  const usable = (connections ?? []).filter((c) => c.status === "ok");
-  if (usable.length) return null;
-  const attached = (connections ?? []).length;
-  const summary = attached ? `No review this time: ${attached} data source${attached === 1 ? " is" : "s are"} attached but none is working. Run \`nanopm connect --list\` to see what is wrong.` : "No review this time: nothing is connected, so there was nothing to read. Run `nanopm connect` to attach your database.";
-  const { error } = await client.from("reviews").insert({
-    project_id: job.project_id,
-    summary,
-    confirms: [],
-    contradicts: [],
-    job_id: job.id
-  });
-  if (error) return { status: "failed", error: { code: "harness_error", message: `could not record that there was nothing to read: ${error.message}` } };
-  await client.from("activity_log").insert({
-    project_id: job.project_id,
-    job_id: job.id,
-    actor: "daemon",
-    step: "review.skipped",
-    summary: attached ? "no working data source" : "nothing connected",
-    outcome: "ok"
-  });
-  return { status: "succeeded", result: summary };
-}
+// ../daemon/src/build-job.ts
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { basename, join as join13 } from "path";
+
+// ../daemon/src/problem-mapping-harness.ts
+import { randomUUID as randomUUID2 } from "crypto";
 
 // ../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 { dirname as dirname2, join as join7, 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"),
+    join7(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 (existsSync2(join7(dir, "onboard", "skill.json"))) return dir;
   }
   throw new Error(`Cannot find the skills directory (tried ${candidates.join(", ")}). Set NANOPM_SKILLS_DIR.`);
 }
@@ -5599,9 +5687,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) => join7(d, name)).find((d) => existsSync2(join7(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 readFile3(join7(dir, "skill.json"), "utf8"));
   let manifest;
   try {
     manifest = parseSkillManifest(raw);
@@ -5610,7 +5698,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 readFile3(join7(dir, "SKILL.md"), "utf8");
   return { manifest, body, dir };
 }
 var NOT_WITH_READ_WEB = ["write_memory", "problems", "propose", "review", "write_repo", "run_commands"];
@@ -5645,7 +5733,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() && existsSync2(join7(skillsDir, d.name, "skill.json"))).map((d) => d.name);
   const out = [];
   for (const name of names) {
     try {
@@ -5659,7 +5747,6 @@ async function clonelessSkills(skillsDir = findSkillsDir()) {
 }
 
 // ../daemon/src/problem-mapping-harness.ts
-import { randomUUID as randomUUID2 } from "crypto";
 function mappingHarnessRunner(options) {
   return async (input) => {
     const skill = await loadSkill(`problem-${input.role}`);
@@ -5975,7 +6062,7 @@ 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 { join as join8 } from "path";
 var SITE_PATHS = ["/", "/about", "/pricing"];
 var PAGE_CHARS = 6e3;
 var SITE_TIMEOUT_MS = 2e4;
@@ -6098,7 +6185,7 @@ function siteFromSearch(name, hits) {
 }
 async function read(repoRoot, name) {
   try {
-    const text2 = await readFile4(join7(repoRoot, name), "utf8");
+    const text2 = await readFile4(join8(repoRoot, name), "utf8");
     return text2.length > 2e5 ? null : text2;
   } catch {
     return null;
@@ -6153,7 +6240,7 @@ 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 { join as join9, 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;
@@ -6171,7 +6258,7 @@ async function readDocs(cwd, opts = {}) {
       return;
     }
     for (const entry of entries) {
-      const full = join8(dir, entry.name);
+      const full = join9(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);
@@ -6658,8 +6745,8 @@ function rank(candidates, readings, verdict, faults) {
     const failed2 = v?.failed ?? [];
     const fatal = failed2.filter((t) => MUST_PASS_TESTS.includes(t.test));
     const gates = faults.get(candidate.lands) ?? [];
-    const answered = /* @__PURE__ */ new Set([...v?.passed ?? [], ...failed2.map((t) => t.test)]);
-    const unanswered = MUST_PASS_TESTS.filter((t) => !answered.has(t));
+    const answered2 = /* @__PURE__ */ new Set([...v?.passed ?? [], ...failed2.map((t) => t.test)]);
+    const unanswered = MUST_PASS_TESTS.filter((t) => !answered2.has(t));
     const reservations = [
       ...fatal.map((t) => `${t.test} \u2014 ${t.because}`),
       ...gates,
@@ -7599,7 +7686,7 @@ function gateProposal(input) {
     for (let hops = 0; n && n.status === "replaced" && n.replaced_by && hops < 50; hops += 1) n = byId.get(n.replaced_by);
     return n && n.status !== "replaced" ? n : void 0;
   };
-  const answered = (r) => r.status === "confirmed" || r.author_kind === "user";
+  const answered2 = (r) => r.status === "confirmed" || r.author_kind === "user";
   const under = scopeRow ? new Set(descendants(rows2, scopeRow).map((r) => r.id)) : null;
   const needOf = (r) => {
     let n = r;
@@ -7718,13 +7805,13 @@ function gateProposal(input) {
         keptIds.add(target.id);
         continue;
       }
-      if (input.hook && !answered(target) && target.provenance === "observed" && draft.provenance === "inferred") {
+      if (input.hook && !answered2(target) && target.provenance === "observed" && draft.provenance === "inferred") {
         placed.set(node.key, { kind: "existing", row: target, branch: home });
         keptIds.add(target.id);
         kept.push(`"${target.label}"`);
         continue;
       }
-      if (answered(target)) {
+      if (answered2(target)) {
         home.nodes.push(outgoing(node.key, draft, outside, parent, nextRank(parent), { next_of: target.id }));
         proposals += 1;
         placed.set(node.key, { kind: "existing", row: target, branch: home });
@@ -7751,7 +7838,7 @@ function gateProposal(input) {
       if (input.resumeOf && r.job_id === input.resumeOf) return false;
       if (within && needOf(r).id !== within) return false;
       if (input.hook && r.provenance === "observed") return false;
-      return !descendants(rows2, r).some((d) => d.id !== r.id && d.status !== "dropped" && (answered(d) || keptIds.has(d.id) || input.hook && d.provenance === "observed"));
+      return !descendants(rows2, r).some((d) => d.id !== r.id && d.status !== "dropped" && (answered2(d) || keptIds.has(d.id) || input.hook && d.provenance === "observed"));
     });
   }
   return { branches: [...branches.values()].filter((b) => b.nodes.length), cut, kept, proposals, sweepable };
@@ -7986,7 +8073,7 @@ ${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 { join as join10 } from "path";
 var READ_ONLY = {
   read_repo: /^(Read|Glob|Grep)$/,
   read_data: /(^|__)(list_connections|describe_source|query)$/
@@ -8001,7 +8088,7 @@ 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;
+  const runDir = dir ? join10(spec2.runDir, dir) : spec2.runDir;
   if (dir) await mkdir2(runDir, { recursive: true, mode: 448 });
   let result;
   let usage = null;
@@ -9281,8 +9368,8 @@ async function flashBranch(ctx, w, n, places) {
   }
   return out;
 }
-function answersFor(answered, leaf) {
-  return answered.find((a) => a.ref.trim().toUpperCase() === leaf.ref.toUpperCase())?.solutions ?? [];
+function answersFor(answered2, leaf) {
+  return answered2.find((a) => a.ref.trim().toUpperCase() === leaf.ref.toUpperCase())?.solutions ?? [];
 }
 async function deepDive(ctx, leaf, place, reads) {
   const whole = deepMaterial(ctx.known, leaf);
@@ -10061,7 +10148,7 @@ 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 { join as join11 } from "path";
 import { promisify as promisify6 } from "util";
 var execFileAsync6 = promisify6(execFile6);
 var DEFINITIONS_TIMEOUT_MS = 9e4;
@@ -10097,7 +10184,7 @@ function pickLines(raw) {
 }
 async function killRecorded(runDir) {
   try {
-    const pid = Number((await readFile6(join10(runDir, "harness.pid"), "utf8")).trim());
+    const pid = Number((await readFile6(join11(runDir, "harness.pid"), "utf8")).trim());
     if (pid > 1) process.kill(pid, "SIGKILL");
   } catch {
   }
@@ -10117,7 +10204,7 @@ 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");
+    const runDir = join11(spec2.runDir, "definitions");
     await mkdir3(runDir, { recursive: true, mode: 448 });
     const schema = definitionsOutputSchema();
     const [lines, listed] = await Promise.all([countingLines(spec2.cwd), listTrackedFiles(spec2.cwd)]);
@@ -10179,7 +10266,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) => existsSync3(join11(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;
@@ -10453,8 +10540,8 @@ function localDate(timezone, at) {
 // ../daemon/src/run-job.ts
 import { randomUUID as randomUUID12 } from "crypto";
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, readFile as readFile8, rm as rm4 } from "fs/promises";
-import { homedir as homedir4, tmpdir } from "os";
+import { mkdir as mkdir4, readFile as readFile7, rm as rm4 } from "fs/promises";
+import { homedir as homedir3, tmpdir } from "os";
 import { join as join12, resolve as resolve4 } from "path";
 
 // ../daemon/src/events.ts
@@ -10535,168 +10622,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 +10656,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 +10675,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 +10684,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);
-  await mkdir5(runDir, { recursive: true, mode: 448 });
-  const resumeSessionId = job.resume_of ? await sessionOf(ctx.client, job.resume_of) : void 0;
+  await mkdir4(runDir, { recursive: true, mode: 448 });
+  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();
@@ -10815,7 +10742,7 @@ async function execute(job, skill, ctx, events) {
   if (quickRun2) {
     const cwd2 = scratchDir(job.id);
     try {
-      await mkdir5(cwd2, { recursive: true, mode: 448 });
+      await mkdir4(cwd2, { recursive: true, mode: 448 });
       const caps = skill.manifest.capabilities;
       return await quickRun2({
         client: ctx.client,
@@ -10894,6 +10821,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 +11003,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 readFile7(join12(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.webSearch === true;
   } catch {
     return false;
@@ -11126,12 +11054,12 @@ async function resolveCwd(ctx, job, params, fallback, mustBeTheClone = false) {
   const requested = params.repo_path;
   if (typeof requested !== "string" || !requested) {
     if (mustBeTheClone) refuse2("the job named no repository");
-    await mkdir5(fallback, { recursive: true, mode: 448 });
+    await mkdir4(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
   if (!job.project_id) {
     if (mustBeTheClone) refuse2("the job belongs to no project");
-    await mkdir5(fallback, { recursive: true, mode: 448 });
+    await mkdir4(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
   const { data: clone } = await ctx.client.from("clones").select("repo_path").eq("project_id", job.project_id).eq("daemon_id", ctx.daemonId).maybeSingle();
@@ -11139,12 +11067,12 @@ async function resolveCwd(ctx, job, params, fallback, mustBeTheClone = false) {
   if (!allowed || resolve4(allowed) !== resolve4(requested)) {
     if (mustBeTheClone) refuse2(`${requested} is not the clone recorded for this project on this machine. Run any \`nanopm\` command inside your clone here to record it`);
     console.error(`job ${job.id}: repo_path ${requested} is not this machine's clone; running in a scratch directory instead`);
-    await mkdir5(fallback, { recursive: true, mode: 448 });
+    await mkdir4(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
   if (existsSync4(allowed)) return resolve4(allowed);
   if (mustBeTheClone) refuse2(`${allowed} is not on this machine any more`);
-  await mkdir5(fallback, { recursive: true, mode: 448 });
+  await mkdir4(fallback, { recursive: true, mode: 448 });
   return fallback;
 }
 function asData8(label, body) {
@@ -11153,7 +11081,7 @@ ${body}
 </${label}>`;
 }
 function harnessEnv(timeoutMs, source = process.env) {
-  const home = source.HOME ?? homedir4();
+  const home = source.HOME ?? homedir3();
   const env = {
     HOME: home,
     PATH: [source.PATH ?? "/usr/local/bin:/usr/bin:/bin", join12(home, ".local", "bin")].join(":"),
@@ -11187,6 +11115,309 @@ function usageTokens(usage) {
   return usage.inputTokens + (usage.cacheWriteTokens ?? 0) + usage.outputTokens;
 }
 
+// ../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(homedir4(), 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 readdir2(at));
+    if (history.place) {
+      const { place } = history;
+      if (!existsSync5(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: join13(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 mkdir5(join13(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, specForAgent(solution.agent_spec, solution.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: homedir4(), 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 mkdir5(join13(worktree.dir, ".nanopm"), { recursive: true });
+  await writeFile5(join13(worktree.dir, ".nanopm", "SPEC.md"), agentSpec);
+  const exclude = join13(await commonGitDir(worktree), "info", "exclude");
+  const current = await readFile8(exclude, "utf8").catch(() => "");
+  if (!current.split("\n").includes(".nanopm/")) {
+    await mkdir5(join13(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);
+}
+async function shippedBuilds(client, daemonId, userId) {
+  const { data: building } = await client.from("solutions").select("id, ref, project_id").eq("status", "building");
+  if (!building?.length) return [];
+  const [{ data: built }, { data: clones }] = await Promise.all([
+    client.from("jobs").select("id, params, pr:result->pr").eq("skill", BUILD_SKILL).eq("status", "succeeded").eq("assigned_daemon_id", daemonId).eq("requested_by", userId).in("params->>solution_id", building.map((s) => s.id)),
+    client.from("clones").select("project_id, repo_path").eq("daemon_id", daemonId)
+  ]);
+  const cloneOf = new Map((clones ?? []).map((c) => [c.project_id, c.repo_path]));
+  const shipped = [];
+  for (const j of built ?? []) {
+    const solution = building.find((s) => s.id === j.params?.solution_id);
+    const number = j.pr?.number;
+    const clone = solution ? cloneOf.get(solution.project_id) : void 0;
+    if (!solution || typeof number !== "number" || number <= 0 || !clone || !existsSync5(clone) || !await pullRequestMerged(clone, number)) continue;
+    const { error } = await client.rpc("finish_solution", { p_project_id: solution.project_id, p_ref: solution.ref, p_job_id: j.id });
+    if (error) continue;
+    await logActivity({ client }, { id: j.id, project_id: solution.project_id }, "shipped", `Pull request #${number} merged: ${solution.ref} shipped`);
+    shipped.push(j.id);
+  }
+  return shipped;
+}
+async function tellTheApp(accessToken, jobId, fetchImpl = fetch) {
+  try {
+    const response = await fetchImpl(`${webUrl()}/api/build/news`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${accessToken}` },
+      body: JSON.stringify({ job_id: jobId })
+    });
+    const body = await response.json().catch(() => ({}));
+    return response.ok ? body.said ?? "nothing to say" : `not said \u2014 ${body.error ?? `the app answered ${response.status}`}`;
+  } catch (err) {
+    return `not said \u2014 ${errorMessage(err)}`;
+  }
+}
+
+// ../daemon/src/review-preflight.ts
+async function reviewWithoutData(client, job) {
+  if (job.skill !== "review" || !job.project_id) return null;
+  if (job.trigger === "user") return null;
+  const { data: connections } = await client.from("connections").select("id, status").eq("project_id", job.project_id).is("removed_at", null);
+  const usable = (connections ?? []).filter((c) => c.status === "ok");
+  if (usable.length) return null;
+  const attached = (connections ?? []).length;
+  const summary = attached ? `No review this time: ${attached} data source${attached === 1 ? " is" : "s are"} attached but none is working. Run \`nanopm connect --list\` to see what is wrong.` : "No review this time: nothing is connected, so there was nothing to read. Run `nanopm connect` to attach your database.";
+  const { error } = await client.from("reviews").insert({
+    project_id: job.project_id,
+    summary,
+    confirms: [],
+    contradicts: [],
+    job_id: job.id
+  });
+  if (error) return { status: "failed", error: { code: "harness_error", message: `could not record that there was nothing to read: ${error.message}` } };
+  await client.from("activity_log").insert({
+    project_id: job.project_id,
+    job_id: job.id,
+    actor: "daemon",
+    step: "review.skipped",
+    summary: attached ? "no working data source" : "nothing connected",
+    outcome: "ok"
+  });
+  return { status: "succeeded", result: summary };
+}
+
 // ../daemon/src/daemon.ts
 var SESSION_HEADROOM_MS = 10 * 60 * 1e3;
 var LONGEST_CAP_MS = 3 * 60 * 60 * 1e3;
@@ -11236,6 +11467,10 @@ 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 SHIP_CHECK_MS = 10 * 6e4;
+  let lastShipCheck = 0;
   const UPDATE_CHECK_MS = 60 * 6e4;
   const updatable = !options.once && installKind() === "installer";
   let lastUpdateCheck = Date.now() - UPDATE_CHECK_MS + 5 * 6e4;
@@ -11287,12 +11522,23 @@ async function runDaemon(options = {}) {
           const digest = await sendDigestFor(auth.client, auth.accessToken, job.id);
           if (digest) log(`digest for job ${job.id}: ${digest.ok ? digest.detail : `not sent \u2014 ${digest.detail}`}`);
         }
+        if (job.skill === BUILD_SKILL && (outcome.status === "waiting" || outcome.status === "succeeded")) {
+          log(`build ${job.id}: ${await tellTheApp(auth.accessToken, job.id)}`);
+        }
         await chainAfter(auth, job, outcome, log);
         processed += 1;
         if (options.once) break;
         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() - lastShipCheck > SHIP_CHECK_MS) {
+        lastShipCheck = Date.now();
+        for (const id of await shippedBuilds(auth.client, daemonId, auth.userId).catch(() => [])) log(`build ${id}: its pull request merged, shipped`);
+      }
       if (!options.once && Date.now() - lastDeployCheck > DEPLOY_CHECK_MS) {
         lastDeployCheck = Date.now();
         for (const check of await reviewDeploys(auth.client, daemonId).catch(() => [])) {
@@ -11421,7 +11667,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 +11739,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 +11755,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 +11769,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 +11779,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 +11821,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 +11875,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 +12409,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 +12975,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 +13766,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 +13803,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 +13814,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 +13913,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 +13928,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 +14260,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);
 }
@@ -14083,23 +14340,24 @@ async function streamJob(client, jobId, opts) {
   let cancelSent = false;
   let cancelDeadline = Infinity;
   let finalStatus = null;
-  const answered = /* @__PURE__ */ new Set();
+  const answered2 = /* @__PURE__ */ new Set();
   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") answered2.add(ev.seq);
     for (const ev of events ?? []) {
       lastId = Math.max(lastId, Number(ev.id));
       const payload = ev.payload ?? {};
       if (ev.kind === "answer" && shownAnswers.has(Number(ev.id))) continue;
       show(progress.feed({ kind: ev.kind, payload, author_kind: ev.author_kind }));
-      if (ev.kind === "question" && payload.about === "site" && !answered.has(ev.seq)) {
-        answered.add(ev.seq);
+      if (ev.kind === "question" && payload.about === "site" && !answered2.has(ev.seq)) {
+        answered2.add(ev.seq);
         renderer.settle("  (answer in the browser)");
         continue;
       }
-      if (ev.kind === "question" && opts.answerer && !cancelSent && !answered.has(ev.seq)) {
-        if (answered.size === 0 && opts.link) renderer.settle(`  (answer here, or in the browser: ${opts.link})`);
-        answered.add(ev.seq);
+      if (ev.kind === "question" && opts.answerer && !cancelSent && !answered2.has(ev.seq)) {
+        if (answered2.size === 0 && opts.link) renderer.settle(`  (answer here, or in the browser: ${opts.link})`);
+        answered2.add(ev.seq);
         const q = payload;
         renderer.pause();
         const outcome = await answerOrWatch(client, jobId, ev.seq, q, opts.answerer, opts.cancelSignal, opts.pollMs);
@@ -14225,16 +14483,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.13",
   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 +14544,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 +14607,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 +14625,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 +14638,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 +14660,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 +14668,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 +14687,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 +15009,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 +15889,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 +15996,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;
     }
@@ -15915,13 +16208,13 @@ async function spec(ref, opts) {
   const auth = await authenticate();
   const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
   const wanted = ref.trim().toUpperCase();
-  const { data: solution } = await auth.client.from("solutions").select("id, ref, title, agent_spec").eq("project_id", project.id).eq("ref", wanted).maybeSingle();
+  const { data: solution } = await auth.client.from("solutions").select("id, ref, title, agent_spec, spec").eq("project_id", project.id).eq("ref", wanted).maybeSingle();
   if (!solution) throw new Error(`no solution ${wanted}. Run \`nanopm roadmap\` to see them.`);
   if (opts.write && opts.rework) throw new Error("--write or --rework, not both.");
   const mode = opts.rework ? "rework" : opts.write ? "write" : null;
   if (!mode) {
     if (!solution.agent_spec) return `${solution.ref} has no specs yet: \`nanopm spec ${solution.ref} --write\`, or *Write the specs* on its sheet.`;
-    return solution.agent_spec.trimEnd();
+    return specForAgent(solution.agent_spec, solution.spec).trimEnd();
   }
   const daemon = await awakeDaemon(auth.client, auth.userId);
   if (!daemon) throw new Error("Your machine is asleep: none of your daemons has been seen in the last two minutes, so nothing was queued. `nanopm daemon install` starts it; then ask again.");
@@ -16472,7 +16765,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 +16826,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 });
@@ -16807,7 +17100,7 @@ Review this suggestion on the Problems page.`);
 async function problemList(client, projectId, color) {
   const list = await problemRows(client, projectId);
   const { count: manualMerges } = await client.from("decisions").select("id", { count: "exact", head: true }).eq("project_id", projectId).eq("kind", "merge");
-  return renderProblems(list, await openQuestions(client, projectId, list), {
+  return renderProblems(list, await openQuestions2(client, projectId, list), {
     color,
     manualMerges: manualMerges ?? 0
   });
@@ -16842,7 +17135,7 @@ async function keptSeparate(client, projectId) {
     return a && b ? [a, b].sort().join("|") : null;
   }).filter((k) => Boolean(k));
 }
-async function openQuestions(client, projectId, list) {
+async function openQuestions2(client, projectId, list) {
   const { data } = await client.from("questions").select("refs, problems!questions_problem_id_fkey(ref)").eq("project_id", projectId).eq("kind", "same").is("answered_at", null).order("created_at", { ascending: false });
   const open = new Set(list.map((p) => p.ref));
   const pairs = [];
@@ -17466,7 +17759,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 +18044,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 +18097,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 +18460,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 +18482,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 }));