@nanopm/cli 0.1.10 → 0.1.12

package/dist/index.js

@@ -156,7 +156,8 @@ var NEEDS_GO_AHEAD = /* @__PURE__ */ new Set(["execute_after_validation"]);
 function requiresGoAhead(autonomy2) {
   return NEEDS_GO_AHEAD.has(autonomy2);
 }
-function capCapabilities(requested, autonomy2) {
+function capCapabilities(requested, autonomy2, opts = {}) {
+  if (opts.asked) return [...requested];
   const denied = CAPPED_BELOW[autonomy2];
   const granted = requested.filter((c) => !denied.has(c));
   if (granted.includes("write_repo") && requiresGoAhead(autonomy2) && !granted.includes("ask_user")) {
@@ -387,6 +388,12 @@ var SkillManifestSchema = z2.object({
     },
     { message: "timeout_deep must look like 3h, 5m, 90s" }
   ).optional(),
+  /**
+   * 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-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. */
   prompt: z2.string().min(1),
   /**
@@ -628,14 +635,6 @@ var SECRET_PATTERNS = [
   "**/credentials.json",
   "**/service-account*.json"
 ];
-function looksLikeASecret(path) {
-  const base = path.replace(/\\/g, "/").split("/").pop() ?? "";
-  return SECRET_PATTERNS.some((pattern) => {
-    const glob = pattern.replace(/^\*\*\//, "");
-    const re = new RegExp(`^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
-    return re.test(base);
-  });
-}
 
 // ../shared/src/stream.ts
 function formatStreamEvent(event) {
@@ -674,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;
   }
@@ -944,7 +955,7 @@ var AFTER_DEEP = {
 function daemonQueues(skill, depth = 0, parent = null, deep = false) {
   if (deep) return depth >= CHAIN_DEPTH_MAX ? [] : AFTER_DEEP[skill] ?? [];
   const theirs = new Set(SQL_OWNED[skill] ?? []);
-  return chainedAfter(skill, depth, parent).filter((next2) => !theirs.has(next2));
+  return chainedAfter(skill, depth, parent).filter((next) => !theirs.has(next));
 }
 var NOT_CHAINED_BY_DAEMON = ["ingest"];
 var CHAIN_DEPTH_MAX = 3;
@@ -954,7 +965,7 @@ function chainedAfter(skill, depth = 0, parent = null) {
   const gates = ONLY_AFTER[skill] ?? {};
   const bars2 = NEVER_AFTER[skill] ?? {};
   return (CHAINED[skill] ?? []).filter(
-    (next2) => (!gates[next2] || parent !== null && gates[next2].includes(parent)) && !(parent !== null && bars2[next2]?.includes(parent))
+    (next) => (!gates[next] || parent !== null && gates[next].includes(parent)) && !(parent !== null && bars2[next]?.includes(parent))
   );
 }
 var CHAINED_SKILLS = [...new Set(Object.values(CHAINED).flatMap((s) => s ?? []))];
@@ -974,7 +985,7 @@ var SKILL_SENTENCE = {
   direction: "working out where this is going",
   solutions: "proposing options",
   review: "reviewing",
-  next: "building",
+  build: "building",
   ask: "answering a question",
   want: "shaping what you want",
   ingest: "watching the numbers",
@@ -982,22 +993,22 @@ var SKILL_SENTENCE = {
   spec: "writing specs"
 };
 function skillSentence(skill, opts = {}) {
-  if (skill === "next") return opts.ref ? `building ${opts.ref}` : "building an option";
+  if (skill === "build") return opts.ref ? `building ${opts.ref}` : "building an option";
   return SKILL_SENTENCE[skill] ?? `running ${skill}`;
 }
 
 // ../shared/src/time.ts
 var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 function describeNextRun(schedule, now = /* @__PURE__ */ new Date(), opts = {}) {
-  const next2 = new Date(schedule.next_due_at);
+  const next = new Date(schedule.next_due_at);
   const local = new Intl.DateTimeFormat("en-GB", {
     timeZone: schedule.timezone,
     weekday: "long",
     hour: "2-digit",
     minute: "2-digit",
     hour12: false
-  }).format(next2);
-  const hours = Math.round((next2.getTime() - now.getTime()) / 36e5);
+  }).format(next);
+  const hours = Math.round((next.getTime() - now.getTime()) / 36e5);
   const when = hours < 1 ? "any minute" : hours < 36 ? `in ${hours}h` : `in ${Math.round(hours / 24)} days`;
   return opts.timezone === false ? `${local}, ${when}` : `${local} ${schedule.timezone}, ${when}`;
 }
@@ -2018,10 +2029,10 @@ function placeRanks(crew, pinned) {
     while (slots[at] !== null && at > 0) at -= 1;
     slots[at] = id;
   }
-  let next2 = 0;
+  let next = 0;
   for (let i = 0; i < total; i += 1) {
     if (slots[i] !== null) continue;
-    slots[i] = loose[next2++] ?? null;
+    slots[i] = loose[next++] ?? null;
   }
   const out = /* @__PURE__ */ new Map();
   slots.forEach((id, i) => id && out.set(id, i + 1));
@@ -2672,7 +2683,7 @@ import { z as z9 } from "zod";
 var PITCH_LINE_KEYS = ["what", "who", "need"];
 var PITCH_TOPIC = "identity";
 var PITCH_KEY = /^pitch-/;
-var pitchKey = (line, next2 = false) => `pitch-${line}${next2 ? "-next" : ""}`;
+var pitchKey = (line, next = false) => `pitch-${line}${next ? "-next" : ""}`;
 var PITCH_LINE_TITLE = { what: "What it is", who: "Who it is for", need: "What they come for" };
 
 // ../shared/src/pitch-crew.ts
@@ -2724,7 +2735,7 @@ var DIRECTION_ROWS = ["mission", "vision"];
 var MISSION_TOPIC = "mission";
 var VISION_TOPIC = "vision";
 var DIRECTION_KEY = /^(?:mission|vision)(?:-next)?$/;
-var directionKey = (row, next2 = false) => `${row}${next2 ? "-next" : ""}`;
+var directionKey = (row, next = false) => `${row}${next ? "-next" : ""}`;
 var DIRECTION_ROW_TITLE = { mission: "Mission", vision: "Vision" };
 
 // ../shared/src/direction-crew.ts
@@ -3483,7 +3494,7 @@ function foldRound(r) {
     }
   }
   const answer = TalkAnswer.safeParse(r.result);
-  const failed = r.status === "failed" || r.status === "cancelled";
+  const failed2 = r.status === "failed" || r.status === "cancelled";
   const error = r.error ?? {};
   return {
     id: r.id,
@@ -3494,8 +3505,8 @@ function foldRound(r) {
     depth: params.data.depth,
     actions: [...actions.values()],
     answer: answer.success ? answer.data : null,
-    state: r.status === "succeeded" ? "done" : failed ? "failed" : "working",
-    ...failed ? { error: error.code === "timeout" ? "That took too long. Send it again?" : r.status === "cancelled" ? "Stopped." : `I couldn\u2019t answer${error.message ? `: ${clip(error.message, 140)}` : "."}` } : {},
+    state: r.status === "succeeded" ? "done" : failed2 ? "failed" : "working",
+    ...failed2 ? { error: error.code === "timeout" ? "That took too long. Send it again?" : r.status === "cancelled" ? "Stopped." : `I couldn\u2019t answer${error.message ? `: ${clip(error.message, 140)}` : "."}` } : {},
     ...doing ? { doing } : {}
   };
 }
@@ -3522,7 +3533,7 @@ var PROBLEM_TOOLS = ["propose_problems", "add_evidence", "flag_duplicate", "file
 var READ_WEB_TOOLS = ["web_search", "web_fetch"];
 var STORE_TOOLS = ["app_store_search", "play_store_search"];
 var MARKET_TOOLS = ["write_market"];
-var WRITE_REPO_TOOLS = ["remove_files"];
+var BUILD_TOOLS = ["build_plan", "build_step"];
 var ALL_MEMORY_TOOLS = [
   ...MEMORY_READ_TOOLS,
   ...MEMORY_WRITE_TOOLS,
@@ -3532,7 +3543,7 @@ var ALL_MEMORY_TOOLS = [
   ...PROBLEM_TOOLS,
   ...READ_WEB_TOOLS,
   ...MARKET_TOOLS,
-  ...WRITE_REPO_TOOLS,
+  ...BUILD_TOOLS,
   ...TALK_TOOLS,
   "last_review",
   "list_problems",
@@ -3574,7 +3585,7 @@ function claudeCodeToolFlags(capabilities, opts = {}) {
       tools.add(t);
       allowed.add(`${t}(${pathRule(workspace)})`);
     }
-    for (const t of WRITE_REPO_TOOLS) allowed.add(mcpTool(t));
+    for (const t of BUILD_TOOLS) allowed.add(mcpTool(t));
   } else {
     for (const t of WRITE_TOOLS) disallowed.add(t);
   }
@@ -3632,7 +3643,7 @@ function claudeCodeToolFlags(capabilities, opts = {}) {
     allowed.delete(t);
     disallowed.add(t);
   }
-  return { tools: [...tools], allowedTools: [...allowed], disallowedTools: [...disallowed] };
+  return { tools: [...tools], allowedTools: [...allowed], disallowedTools: [...disallowed], permissionMode: tools.has("Bash") ? "auto" : "default" };
 }
 
 // ../daemon/src/adapters/claude-code/sandbox.ts
@@ -3674,12 +3685,26 @@ function buildSandboxSettings(home) {
   }
   return { permissions: { deny, defaultMode: "default" } };
 }
-function sandboxSettingsFor(home, grantedTools) {
+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));
+  if (granted.has("Bash")) {
+    settings.sandbox = {
+      enabled: true,
+      allowUnsandboxedCommands: false,
+      failIfUnavailable: true,
+      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 = {
@@ -3697,6 +3722,8 @@ var StreamParser = class {
   model = "unknown";
   toolCalls = /* @__PURE__ */ new Map();
   sawResult = false;
+  /** When the Claude window opens again, from the last rejected `rate_limit_event`. */
+  resetsAt;
   // The read size, counted here because the stream is the one place every call passes.
   contextPeak = 0;
   readCalls = {};
@@ -3707,6 +3734,9 @@ var StreamParser = class {
   get currentSessionId() {
     return this.sessionId;
   }
+  get limitResetsAt() {
+    return this.resetsAt;
+  }
   /** Feed one NDJSON line; get zero or more events. Non-JSON lines are ignored. */
   parseLine(line) {
     const trimmed = line.trim();
@@ -3758,10 +3788,18 @@ var StreamParser = class {
         }
         return events;
       }
+      case "rate_limit_event": {
+        const info = obj.rate_limit_info;
+        if (info?.status === "rejected" && typeof info.resetsAt === "number") this.resetsAt = info.resetsAt;
+        return [];
+      }
       case "result": {
         this.sawResult = true;
         this.sessionId = obj.session_id ?? this.sessionId;
         const usage = this.usageFrom(obj);
+        if (obj.stop_reason === "tool_deferred" && obj.deferred_tool_use?.name) {
+          return [{ type: "deferred", sessionId: this.sessionId ?? "", tool: obj.deferred_tool_use.name, input: obj.deferred_tool_use.input, usage }];
+        }
         if (obj.subtype === "success" && !obj.is_error) {
           if (this.structuredOutput && obj.structured_output === void 0) {
             return [{ type: "failed", sessionId: this.sessionId, code: "harness_error", message: "Claude omitted the required structured output." }];
@@ -3770,7 +3808,7 @@ var StreamParser = class {
         }
         const message = obj.result || `claude ended with ${obj.subtype ?? "an unknown result"}`;
         const code = isRateLimit(message) ? "rate_limit" : RESULT_FAILURES[obj.subtype ?? ""] ?? "harness_error";
-        return [{ type: "failed", sessionId: this.sessionId, code, message }];
+        return [{ type: "failed", sessionId: this.sessionId, code, message, ...code === "rate_limit" && this.resetsAt ? { resetsAt: this.resetsAt } : {} }];
       }
       default:
         return [];
@@ -3818,8 +3856,8 @@ function classifyExit(stderr, aborted) {
   if (t.includes("not logged in") || t.includes("invalid api key") || t.includes("authentication") || t.includes("subscription") || t.includes("please run /login") || t.includes("oauth")) {
     return { code: "auth", message: "Claude Code is not logged in on this machine. Run `claude login` or set ANTHROPIC_API_KEY." };
   }
-  const tail2 = stderr.trim().split("\n").slice(-3).join(" ").trim();
-  return { code: "harness_error", message: tail2 || "claude exited without a result" };
+  const tail = stderr.trim().split("\n").slice(-3).join(" ").trim();
+  return { code: "harness_error", message: tail || "claude exited without a result" };
 }
 
 // ../daemon/src/adapters/claude-code/index.ts
@@ -3856,10 +3894,10 @@ var ClaudeCodeAdapter = class {
       const result = parsePrintResult(stdout);
       return result?.is_error ? { ok: false, message: result.result ?? "claude reported an error" } : { ok: true, message: `claude answered in ${result?.subtype ?? "success"}` };
     } catch (err) {
-      const failed = err;
-      const reported = parsePrintResult(failed.stdout)?.result;
+      const failed2 = err;
+      const reported = parsePrintResult(failed2.stdout)?.result;
       if (reported) return { ok: false, message: reported };
-      const text2 = failed.stderr?.trim() || failed.message || String(err);
+      const text2 = failed2.stderr?.trim() || failed2.message || String(err);
       return { ok: false, message: classifyExit(text2, false).message };
     }
   }
@@ -3895,9 +3933,9 @@ var ClaudeCodeAdapter = class {
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    const exit = new Promise((resolve6) => {
-      child.on("close", (code) => resolve6(code));
-      child.on("error", () => resolve6(127));
+    const exit = new Promise((resolve5) => {
+      child.on("close", (code) => resolve5(code));
+      child.on("error", () => resolve5(127));
     });
     const parser = new StreamParser();
     let searched = false;
@@ -3937,7 +3975,7 @@ var ClaudeCodeAdapter = class {
       "--append-system-prompt",
       spec2.systemPrompt,
       "--permission-mode",
-      "default",
+      flags.permissionMode,
       "--max-turns",
       String(spec2.maxTurns),
       "--setting-sources",
@@ -3986,7 +4024,7 @@ var ClaudeCodeAdapter = class {
     await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers }), { mode: 384 });
     const settingsPath = join3(spec2.runDir, "settings.json");
     const flags = claudeCodeToolFlags(spec2.capabilities, { workspace: spec2.cwd, harnessWeb: spec2.harnessWeb, without: spec2.withoutTools });
-    await writeFile2(settingsPath, JSON.stringify(sandboxSettingsFor(spec2.env.HOME ?? "", flags.tools)), { 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,
@@ -4005,9 +4043,9 @@ var ClaudeCodeAdapter = class {
       stderr += chunk.toString();
       if (stderr.length > 64e3) stderr = stderr.slice(-32e3);
     });
-    const exit = new Promise((resolve6) => {
-      child.on("close", (code, signal) => resolve6({ code, signal }));
-      child.on("error", () => resolve6({ code: 127, signal: null }));
+    const exit = new Promise((resolve5) => {
+      child.on("close", (code, signal) => resolve5({ code, signal }));
+      child.on("error", () => resolve5({ code: 127, signal: null }));
     });
     const parser = new StreamParser(spec2.outputSchema !== void 0);
     try {
@@ -4017,7 +4055,8 @@ var ClaudeCodeAdapter = class {
       const { code } = await exit;
       if (!parser.finished) {
         const failure2 = classifyExit(stderr, aborted);
-        yield { type: "failed", sessionId: parser.currentSessionId, ...failure2, message: appendExit(failure2.message, code) };
+        const resetsAt = failure2.code === "rate_limit" ? parser.limitResetsAt : void 0;
+        yield { type: "failed", sessionId: parser.currentSessionId, ...failure2, message: appendExit(failure2.message, code), ...resetsAt ? { resetsAt } : {} };
       }
     } finally {
       spec2.signal.removeEventListener("abort", onAbort);
@@ -4042,10 +4081,10 @@ function parsePrintResult(stdout) {
 }
 
 // ../daemon/src/daemon.ts
-import { mkdir as mkdir5, readdir as readdir2, readFile as readFile7, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+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 join11 } from "path";
+import { join as join14 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 
 // ../daemon/src/awake.ts
@@ -4114,8 +4153,8 @@ async function installVersion(version, home = homedir2()) {
     });
     return { ok: true };
   } catch (err) {
-    const failed = err;
-    return { ok: false, why: (failed.stderr?.trim() || failed.message || String(err)).split("\n").slice(-3).join(" ") };
+    const failed2 = err;
+    return { ok: false, why: (failed2.stderr?.trim() || failed2.message || String(err)).split("\n").slice(-3).join(" ") };
   }
 }
 function autoUpdateOff(home = homedir2()) {
@@ -4130,6 +4169,7 @@ function shouldUpdate(s) {
 }
 
 // ../daemon/src/mcp.ts
+import { join as join5 } from "path";
 function memoryMcpCommand(env = process.env) {
   const override = env.NANOPM_MCP_COMMAND;
   if (override) {
@@ -4156,13 +4196,17 @@ function memoryMcpServer(job, auth, askTimeoutMs, workspace) {
       NANOPM_PROJECT_ID: job.project_id,
       NANOPM_USER_ID: auth.userId,
       NANOPM_ACTOR: job.skill,
-      ...workspace ? { NANOPM_WORKSPACE: workspace } : {},
+      // A build: its questions come back through the answer file the hook hands over (buildAnswerFile).
+      ...workspace ? { NANOPM_WORKSPACE: workspace, NANOPM_ANSWER_FILE: buildAnswerFile(job.id) } : {},
       NANOPM_ASK_TIMEOUT_MS: String(askTimeoutMs),
       PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
       HOME: process.env.HOME ?? ""
     }
   };
 }
+function buildAnswerFile(jobId) {
+  return join5(nanopmHome(), "run", jobId, "answer");
+}
 
 // ../connectors/src/postgres.ts
 import postgres from "postgres";
@@ -4177,15 +4221,15 @@ function stripLiterals(sql) {
   };
   while (i < n) {
     const c = sql[i];
-    const next2 = sql[i + 1];
-    if (c === "-" && next2 === "-") {
+    const next = sql[i + 1];
+    if (c === "-" && next === "-") {
       const end = sql.indexOf("\n", i);
       const stop2 = end === -1 ? n : end;
       blank(i, stop2);
       i = stop2;
       continue;
     }
-    if (c === "/" && next2 === "*") {
+    if (c === "/" && next === "*") {
       let depth = 1;
       let k = i + 2;
       while (k < n && depth > 0) {
@@ -5273,14 +5317,183 @@ async function sendDigestFor(client, accessToken, jobId, fetchImpl = fetch) {
 }
 
 // ../daemon/src/deploys.ts
+import { execFile as execFile4 } from "child_process";
+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 join6 } from "path";
+
+// ../shared/src/build.ts
+var BUILD_SKILL = "build";
+var BUILD_STEPS_MIN = 1;
+var BUILD_STEPS_MAX = 8;
+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";
+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;
+  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`;
+  }
+  return null;
+}
+function stepsLeft(plan, done) {
+  return (plan ?? []).map((_, i) => i).filter((i) => !done.has(i));
+}
+function buildDir(home, jobId) {
+  return `${home.replace(/\/+$/, "")}/.cache/nanopm/builds/${jobId}`;
+}
+function buildBranch(ref, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+  return `nano/${ref.toLowerCase()}${slug ? `-${slug}` : ""}`;
+}
+var REGISTRIES = {
+  "package-lock.json": ["registry.npmjs.org"],
+  "npm-shrinkwrap.json": ["registry.npmjs.org"],
+  "pnpm-lock.yaml": ["registry.npmjs.org"],
+  "yarn.lock": ["registry.yarnpkg.com", "registry.npmjs.org"],
+  "bun.lockb": ["registry.npmjs.org"],
+  "bun.lock": ["registry.npmjs.org"],
+  "poetry.lock": ["pypi.org", "files.pythonhosted.org"],
+  "uv.lock": ["pypi.org", "files.pythonhosted.org"],
+  "Pipfile.lock": ["pypi.org", "files.pythonhosted.org"],
+  "requirements.txt": ["pypi.org", "files.pythonhosted.org"],
+  "Cargo.lock": ["crates.io", "index.crates.io", "static.crates.io"],
+  "Gemfile.lock": ["rubygems.org", "index.rubygems.org"],
+  "go.sum": ["proxy.golang.org", "sum.golang.org"],
+  "composer.lock": ["repo.packagist.org"]
+};
+function buildNetwork(rootFiles) {
+  return [...new Set(rootFiles.flatMap((f) => REGISTRIES[f] ?? []))].sort();
+}
+async function queueBuild(client, ask7) {
+  const { data, error: readError } = await client.from("solutions").select(BUILD_COLUMNS).eq("project_id", ask7.projectId).eq("ref", ask7.ref).is("superseded_by", null).maybeSingle();
+  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 || Boolean(ask7.resumeOf) });
+  if (refused) throw new Error(refused);
+  const { data: job, error } = await client.from("jobs").insert({
+    project_id: ask7.projectId,
+    skill: BUILD_SKILL,
+    requested_by: ask7.userId,
+    trigger: "user",
+    target_daemon_id: ask7.daemonId,
+    // `was`: where the solution goes back on the board if the build stops (`unstart_solution`).
+    // `origin`: the run that made the copy of the code, which every continuation works in.
+    params: { solution_id: solution.id, repo_path: ask7.repoPath, was: ask7.resumeOf?.was ?? solution.status, ...ask7.resumeOf ? { origin: ask7.resumeOf.origin } : {}, ...ask7.anyway ? { anyway: true } : {} },
+    // Continuing a stopped build takes up its worktree, its history and its session.
+    ...ask7.resumeOf ? { resume_of: ask7.resumeOf.id } : {}
+  }).select("id").single();
+  if (error?.code === "23505") throw new Error("A build of this product is already running. One at a time: `nanopm status` says where it is.");
+  if (error || !job) throw new Error(`could not queue the build: ${error ? pgMessage(error) : "no row"}`);
+  return { jobId: job.id, solution };
+}
+var DECIDE_FOR_ME = "Decide yourself: pick what you judge best for the users, then say what you decided and why under *Decisions I made*.";
+function answerForAgent(answer) {
+  return /^\s*decide(\s+for\s+me)?\s*\.?\s*$/i.test(answer) ? DECIDE_FOR_ME : answer;
+}
+function trustedPlace(p, at) {
+  const [branch, base, fork] = [p.branch, p.base, p.fork].map((v) => typeof v === "string" ? v : "");
+  if (!/^nano\/[a-z0-9][a-z0-9-]*$/.test(branch) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(base) || !/^[0-9a-f]{7,40}$/.test(fork)) return null;
+  return { dir: buildDir(at.home, at.jobId), branch, base, fork };
+}
+function buildHistory(events, at) {
+  let place = null;
+  let plan = null;
+  const done = /* @__PURE__ */ new Set();
+  let last = null;
+  const answers = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind === "worktree") place = trustedPlace(e.payload, at);
+    else if (e.kind === "plan" && Array.isArray(e.payload.steps)) plan = e.payload.steps;
+    else if (e.kind === "step" && typeof e.payload.step === "number") done.add(e.payload.step - 1);
+    else if (e.kind === "answer") answers.set(e.seq, String(e.payload.answer ?? ""));
+    if (e.kind === "question" || e.kind === "paused") last = e;
+    else if (e.kind === "plan" || e.kind === "step") last = null;
+  }
+  if (!place) return { place, plan, done, resume: null };
+  if (last?.kind === "question" && answers.has(last.seq) && last.payload.about === "usage") return { place, plan, done, resume: { why: "limit" } };
+  if (last?.kind === "question" && answers.has(last.seq)) return { place, plan, done, resume: { why: "answer", answer: answers.get(last.seq) } };
+  if (last?.kind === "paused") return { place, plan, done, resume: { why: "limit" } };
+  return { place, plan, done, resume: { why: "lost" } };
+}
+function wasOf(params) {
+  return params?.was === "proposed" ? "proposed" : "accepted";
+}
+async function loadBuildHistory(client, jobIds, at) {
+  const { data, error } = await client.from("job_events").select("kind, seq, payload").in("job_id", [...jobIds]).in("kind", ["worktree", "plan", "step", "question", "answer", "paused"]).order("id");
+  if (error) throw new Error(`could not read the build's history: ${error.message}`);
+  return buildHistory((data ?? []).map((e) => ({ kind: e.kind, seq: e.seq, payload: e.payload ?? {} })), at);
+}
+
+// ../daemon/src/repo.ts
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile3);
-var SETTLE_HOURS = 3;
-var MIN_COMMITS = 3;
-async function git(cwd, args) {
-  const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args], { timeout: 2e4, maxBuffer: 1024 * 1024 });
-  return stdout.trim();
+var MAX_BUFFER = 4 * 1024 * 1024;
+var TIMEOUT_MS = 6e4;
+var LOCKED = {
+  GIT_CONFIG_COUNT: "2",
+  GIT_CONFIG_KEY_0: "core.hooksPath",
+  GIT_CONFIG_VALUE_0: "/dev/null",
+  GIT_CONFIG_KEY_1: "core.fsmonitor",
+  GIT_CONFIG_VALUE_1: "false"
+};
+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(join6(repo.dir, ".git"), `gitdir: ${repo.admin}
+`);
+  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) {
+  return (await exec("git", repo, args, timeoutMs)).stdout.trim();
+}
+var RepoError = class extends Error {
+};
+async function commitAll(cwd, message, note) {
+  await git(cwd, ["add", "-A"]);
+  const staged = await git(cwd, ["diff", "--cached", "--name-only"]).catch(() => "");
+  if (!staged) return null;
+  await git(cwd, ["commit", "--no-verify", "-m", message, ...note ? ["-m", note] : [], "-m", `Written by NanoPM. Review before merging.
+
+${BUILD_TRAILER}`]);
+  const sha = await git(cwd, ["rev-parse", "--short", "HEAD"]);
+  return { sha, ...await diffStat(cwd) };
+}
+async function diffStat(cwd) {
+  const numstat = await git(cwd, ["show", "--numstat", "--format=", "HEAD"]).catch(() => "");
+  let files = 0;
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of numstat.split("\n").filter(Boolean)) {
+    const [add2 = "", del = ""] = line.split("	");
+    files += 1;
+    insertions += Number(add2) || 0;
+    deletions += Number(del) || 0;
+  }
+  return { files, insertions, deletions };
+}
+async function pushBranch(cwd, name) {
+  if (!await originUrl(cwd)) return { pushed: false, reason: "this repository has no origin remote" };
+  try {
+    const { stderr } = await exec("git", cwd, ["push", "--no-verify", "--set-upstream", "origin", name], 12e4);
+    return { pushed: true, reviewUrl: reviewUrlFrom(stderr) };
+  } catch (err) {
+    const text2 = errorMessage(err);
+    return { pushed: false, reason: text2.split("\n").slice(-3).join(" ").trim() || "git push failed" };
+  }
+}
+function reviewUrlFrom(pushOutput) {
+  const match = /https?:\/\/\S+/.exec(pushOutput);
+  return match?.[0]?.replace(/[).,]+$/, "");
 }
 async function defaultBranch(cwd) {
   try {
@@ -5290,9 +5503,78 @@ async function defaultBranch(cwd) {
     return git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).catch(() => "HEAD");
   }
 }
+async function originUrl(cwd) {
+  return git(cwd, ["remote", "get-url", "origin"]).catch(() => "");
+}
+async function baseRef(cwd, branch) {
+  if (!await originUrl(cwd)) return branch;
+  await git(cwd, ["fetch", "--quiet", "origin", branch], 12e4).catch(() => "");
+  return await git(cwd, ["rev-parse", "--verify", "--quiet", `origin/${branch}`]).catch(() => "") ? `origin/${branch}` : branch;
+}
+async function addWorktree(clone, dir, branch) {
+  if (!await git(clone, ["rev-parse", "HEAD"]).catch(() => "")) throw new RepoError("this repository has no commits yet; make the first commit, then build");
+  const existing = await git(clone, ["branch", "--list", branch]).catch(() => "");
+  if (existing.trim()) throw new RepoError(`branch ${branch} already exists. Delete it or finish what is on it first.`);
+  const base = await defaultBranch(clone);
+  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(join6(admin, "commondir"), "utf8") };
+  return { base, fork: await git(worktree, ["rev-parse", "HEAD"]), worktree };
+}
+async function removeWorktree(clone, dir) {
+  await git(clone, ["worktree", "remove", "--force", dir]).catch(() => "");
+}
+async function commonGitDir(cwd) {
+  return git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+}
+async function commitsSinceFork(cwd, fork) {
+  return Number(await git(cwd, ["rev-list", "--count", `${fork}..HEAD`]).catch(() => "0")) || 0;
+}
+async function rebaseOnto(cwd, base) {
+  const onto = await baseRef(cwd, base);
+  try {
+    await git(cwd, ["rebase", "--no-verify", onto], 12e4);
+    return { ok: true };
+  } catch {
+    const files = (await git(cwd, ["diff", "--name-only", "--diff-filter=U"]).catch(() => "")).split("\n").filter(Boolean);
+    await git(cwd, ["rebase", "--abort"]).catch(() => "");
+    return { ok: false, files };
+  }
+}
+async function gh(cwd, args) {
+  return (await exec("gh", cwd, args, 12e4)).stdout.trim();
+}
+async function ghReady(cwd) {
+  if (!/github\.com[:/]/.test(await originUrl(cwd))) return "this repository has no GitHub origin, so there is nowhere to open a pull request";
+  try {
+    await gh(cwd, ["auth", "status"]);
+    return null;
+  } catch (err) {
+    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 openPullRequest(cwd, pr) {
+  try {
+    const out = await gh(cwd, ["pr", "create", "--draft", "--head", pr.branch, "--base", pr.base, "--title", pr.title, "--body", pr.body]);
+    const url = reviewUrlFrom(out) ?? out.split("\n").at(-1) ?? "";
+    return { ok: true, url, number: Number(/\/pull\/(\d+)/.exec(url)?.[1] ?? 0) };
+  } catch (err) {
+    return { ok: false, reason: errorMessage(err).split("\n").filter(Boolean).slice(-2).join(" ") || "gh pr create failed" };
+  }
+}
+
+// ../daemon/src/deploys.ts
+var execFileAsync4 = promisify4(execFile4);
+var SETTLE_HOURS = 3;
+var MIN_COMMITS = 3;
+async function git2(cwd, args) {
+  const { stdout } = await execFileAsync4("git", ["-C", cwd, ...args], { timeout: 2e4, maxBuffer: 1024 * 1024 });
+  return stdout.trim();
+}
 async function commitsSince(cwd, since) {
   const branch = await defaultBranch(cwd);
-  const out = await git(cwd, ["log", branch, `--since=${since.toISOString()}`, "--format=%cI"]);
+  const out = await git2(cwd, ["log", branch, `--since=${since.toISOString()}`, "--format=%cI"]);
   const stamps = out.split("\n").filter(Boolean);
   return { count: stamps.length, newestAt: stamps[0] ? new Date(stamps[0]) : null };
 }
@@ -5346,6 +5628,275 @@ async function reviewDeploys(client, daemonId, now = /* @__PURE__ */ new Date())
   return results;
 }
 
+// ../daemon/src/build-job.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readdir, readFile as readFile3, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename, join as join7 } from "path";
+
+// ../daemon/src/usage.ts
+function sumUsage(a, b) {
+  if (!a) return { ...b };
+  return {
+    ...b,
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0),
+    costUsd: (a.costUsd ?? 0) + (b.costUsd ?? 0),
+    turns: a.turns + b.turns,
+    durationMs: a.durationMs + b.durationMs,
+    ...a.contextPeakTokens || b.contextPeakTokens ? { contextPeakTokens: Math.max(a.contextPeakTokens ?? 0, b.contextPeakTokens ?? 0) } : {},
+    ...a.reads || b.reads ? { reads: sumReads(a.reads, b.reads) } : {}
+  };
+}
+function sumReads(a, b) {
+  const calls = { ...a?.calls ?? {} };
+  for (const [tool, n] of Object.entries(b?.calls ?? {})) calls[tool] = (calls[tool] ?? 0) + n;
+  return { files: (a?.files ?? 0) + (b?.files ?? 0), calls };
+}
+
+// ../daemon/src/build-job.ts
+var PLAN_TOOL = "mcp__nanopm__build_plan";
+var ASK_TOOL = "mcp__nanopm__ask_user";
+var STEP_TOOL = "mcp__nanopm__build_step";
+var CLAUDE_CODE_MIN = "2.1.283";
+async function prepareBuild(client, job, clone, adapter) {
+  const params = job.params ?? {};
+  const dir = buildDir(homedir3(), job.id);
+  let made = false;
+  try {
+    const [solution, machine, history] = await Promise.all([
+      loadSolution(client, job.project_id, String(params.solution_id ?? "")),
+      machineRefusal(adapter),
+      loadHistory(client, job)
+    ]);
+    const refused = buildRefusal(solution, { anyway: params.anyway === true || Boolean(history.place) }) ?? machine;
+    if (refused) return { ok: false, outcome: failed(refused) };
+    const network = async (at) => buildNetwork(await readdir(at));
+    if (history.place) {
+      const { place } = history;
+      if (!existsSync2(place.dir)) return { ok: false, outcome: failed(`this build's copy of the code is gone (${place.dir}): build it again`) };
+      const worktree2 = { dir: place.dir, admin: join7(await commonGitDir(clone), "worktrees", basename(place.dir)), commondir: "../..\n" };
+      await startSolution(client, job.project_id, solution.ref, job.id);
+      return { ok: true, build: { solution, clone, ...place, worktree: worktree2, network: await network(place.dir), history } };
+    }
+    const branch = buildBranch(solution.ref, solution.title);
+    await mkdir2(join7(dir, ".."), { recursive: true, mode: 448 });
+    const { base, fork, worktree } = await addWorktree(clone, dir, branch);
+    made = true;
+    await appendJobEvent(client, job.id, "worktree", { dir, branch, base, fork }, "nanopm");
+    await handOverTheSpec(worktree, solution.agent_spec);
+    await startSolution(client, job.project_id, solution.ref, job.id);
+    return { ok: true, build: { solution, clone, dir, worktree, branch, base, fork, network: await network(dir), history } };
+  } catch (err) {
+    if (made) await removeWorktree(clone, dir);
+    return { ok: false, outcome: failed(errorMessage(err)) };
+  }
+}
+async function runBuildJob(input) {
+  const { client, job, adapter, spec: spec2, events, log, verifyCommand: verifyCommand2 } = input;
+  const { solution, clone, dir, worktree, branch, base, fork, history } = input.build;
+  const was = wasOf(job.params);
+  let plan = history.plan;
+  const done = new Set(history.done);
+  let usage;
+  let said = "";
+  const stop2 = async (message, opts = { keep: true }) => {
+    await unstartSolution(client, job.project_id, solution.ref, was).catch(() => void 0);
+    if (opts.keep) await commitAll(worktree, `${solution.ref}: unfinished \u2014 ${solution.title}`).catch(() => null);
+    else await removeWorktree(clone, dir);
+    return { ...failed(opts.keep ? `${message}. What was done is on ${branch}, in ${dir}.` : message), usage };
+  };
+  const park = async (why) => {
+    if ("ask" in why) {
+      await events.write("question", { ...why.ask, ...plan ? {} : { about: "plan" } });
+      await log("build.ask", `${solution.ref} waits on the founder`);
+    } else if (why.resetsAt) {
+      await events.write("paused", { why: "limit", resets_at: new Date(why.resetsAt * 1e3).toISOString() });
+      await log("build.pause", `${solution.ref} paused until the Claude limit resets`);
+    } else {
+      await events.write("question", { question: "Your Claude usage is used up. Get more in Claude, or wait for it to come back, then answer to carry on.", options: ["Carry on"], about: "usage" });
+    }
+    return { status: "waiting", usage };
+  };
+  const session2 = async (prompt, resume3) => {
+    let end = { stop: failed("the agent produced no result") };
+    for await (const event of adapter.run({ ...spec2, prompt, resumeSessionId: resume3 ? spec2.sessionId : void 0 })) {
+      await input.onEvent(event);
+      if (event.type === "tool_use" && event.tool === PLAN_TOOL && !plan) {
+        plan = stepsOf(event.input);
+        if (plan) await events.write("plan", { steps: plan });
+      } else if (event.type === "tool_result" && event.tool === STEP_TOOL && !event.isError) {
+        const { step, summary } = event.input ?? {};
+        const index = Number(step) - 1;
+        if (Number.isInteger(index) && index >= 0 && !done.has(index)) {
+          const says = plan?.[index] ?? `step ${index + 1}`;
+          const commit = await commitAll(worktree, `${solution.ref}: ${says}`, summary);
+          done.add(index);
+          await events.write("step", { step: index + 1, says, commit: commit?.sha ?? null, files: commit?.files ?? 0 });
+        }
+      } else if (event.type === "finished") {
+        usage = sumUsage(usage, event.usage);
+        said = event.result;
+        end = null;
+      } else if (event.type === "deferred" && event.tool === ASK_TOOL) {
+        usage = sumUsage(usage, event.usage);
+        end = { park: { ask: askOf(event.input) } };
+      } else if (event.type === "failed") {
+        end = event.code === "rate_limit" ? { park: { resetsAt: event.resetsAt } } : { stop: { status: "failed", error: { code: event.code, message: event.message } } };
+      }
+    }
+    return end;
+  };
+  const resume2 = history.resume;
+  const check = verifyCommand2 ? `
+
+The project's own check is \`${verifyCommand2}\`. Run it before your last build_step, fix what it reports, and give its result under *How I checked it*.` : "";
+  const finished = () => Boolean(plan && !stepsLeft(plan, done).length);
+  if (!resume2) {
+    await log("build.start", `building ${solution.ref} on ${branch}, in a copy of your code`);
+    await events.write("text", { text: `Working on ${branch}, in a copy of your code. Your own checkout is not touched.` });
+  } else {
+    await events.write("text", { text: AGAIN[resume2.why].said });
+    if (resume2.why === "answer" && spec2.answerFile) await writeFile5(spec2.answerFile, answerForAgent(resume2.answer), { mode: 384 });
+  }
+  let turn = !resume2 ? await session2(spec2.prompt + check, false) : resume2.why === "answer" ? await session2("", true) : finished() ? null : await session2(`${AGAIN[resume2.why].lead} ${carryOn(plan, done)}`, true);
+  for (let resumes = 0; !turn && !finished(); resumes += 1) {
+    if (resumes >= BUILD_RESUMES_MAX) {
+      const left = stepsLeft(plan, done).length;
+      return stop2(plan ? `Nano stopped with ${left} step${left === 1 ? "" : "s"} of its plan left` : "Nano stopped without saying its plan");
+    }
+    turn = await session2(carryOn(plan, done), true);
+  }
+  if (turn && "park" in turn) return park(turn.park);
+  if (turn) return stop2(turn.stop.error?.message ?? "the build stopped");
+  await commitAll(worktree, `${solution.ref}: ${solution.title}`);
+  if (!await commitsSinceFork(worktree, fork)) return stop2("the build finished without changing anything", { keep: false });
+  const rebased = await rebaseOnto(worktree, base);
+  if (!rebased.ok) return stop2(`${base} moved while Nano was building, and the same files changed on both sides: ${rebased.files.join(", ") || "see git status"}`);
+  const [pushed, noPr, page] = await Promise.all([pushBranch(worktree, branch), ghReady(worktree), solutionPage(client, job.project_id, solution.ref)]);
+  if (!pushed.pushed) return stop2(`the push failed: ${pushed.reason}`);
+  const pr = noPr ? null : await openPullRequest(worktree, { branch, base, title: `${solution.ref}: ${solution.title}`, body: prBody(said, page) });
+  if (pr && !pr.ok) return { ...failed(`the branch ${branch} is pushed, but GitHub refused the pull request: ${pr.reason}${pushed.reviewUrl ? `. Open it yourself: ${pushed.reviewUrl}` : ""}`), usage };
+  if (pr) {
+    await events.write("pr", { number: pr.number, url: pr.url });
+    await log("build.pr", `draft pull request #${pr.number} for ${solution.ref}`);
+  }
+  await removeWorktree(clone, dir);
+  return {
+    status: "succeeded",
+    result: [
+      said.trim(),
+      "",
+      pr ? `Draft pull request #${pr.number} \xB7 ${pr.url}` : `Pushed ${branch}. No pull request: ${noPr}.${pushed.reviewUrl ? ` ${pushed.reviewUrl}` : ""}`
+    ].filter(Boolean).join("\n"),
+    data: { branch, session: spec2.sessionId, ...pr ? { pr: { number: pr.number, url: pr.url } } : { review_url: pushed.reviewUrl ?? null } },
+    usage
+  };
+}
+var failed = (message) => ({ status: "failed", error: { code: "harness_error", message } });
+var AGAIN = {
+  answer: { said: "Your answer is in: carrying on.", lead: "" },
+  limit: { said: "Your Claude limit has reset: carrying on.", lead: "Your Claude limit has reset." },
+  lost: { said: "Picked up again where it stopped.", lead: "You were interrupted: the machine stopped." }
+};
+function askOf(input) {
+  const { question, options, why } = input ?? {};
+  return {
+    question: String(question ?? ""),
+    ...Array.isArray(options) ? { options: options.map(String) } : {},
+    ...typeof why === "string" ? { why } : {}
+  };
+}
+async function loadHistory(client, job) {
+  const named = (job.params ?? {}).origin;
+  const origin = typeof named === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(named) ? named : job.id;
+  const { data: runs } = await client.from("jobs").select("id").eq("project_id", job.project_id).eq("skill", BUILD_SKILL).or(`id.eq.${origin},params->>origin.eq.${origin}`);
+  return loadBuildHistory(client, [.../* @__PURE__ */ new Set([origin, job.id, ...(runs ?? []).map((r) => r.id)])], { home: homedir3(), jobId: origin });
+}
+async function loadSolution(client, projectId, id) {
+  const { data, error } = await client.from("solutions").select(BUILD_COLUMNS).eq("id", id).eq("project_id", projectId).is("superseded_by", null).maybeSingle();
+  if (error) throw new Error(`could not read the solution: ${error.message}`);
+  if (!data) throw new Error("that solution is not on this project any more");
+  return data;
+}
+async function machineRefusal(adapter) {
+  const found = await adapter.detect();
+  const version = /\d+\.\d+\.\d+/.exec(found.version ?? "")?.[0];
+  if (version && !newer(CLAUDE_CODE_MIN, version)) return null;
+  return `a build needs Claude Code ${CLAUDE_CODE_MIN} or later on this machine${found.version ? ` (it has ${found.version})` : ""}: run claude update`;
+}
+async function handOverTheSpec(worktree, agentSpec) {
+  await mkdir2(join7(worktree.dir, ".nanopm"), { recursive: true });
+  await writeFile5(join7(worktree.dir, ".nanopm", "SPEC.md"), agentSpec);
+  const exclude = join7(await commonGitDir(worktree), "info", "exclude");
+  const current = await readFile3(exclude, "utf8").catch(() => "");
+  if (!current.split("\n").includes(".nanopm/")) {
+    await mkdir2(join7(exclude, ".."), { recursive: true });
+    await writeFile5(exclude, `${current}${current && !current.endsWith("\n") ? "\n" : ""}.nanopm/
+`);
+  }
+}
+function stepsOf(input) {
+  const steps = input?.steps;
+  return Array.isArray(steps) && steps.length && steps.every((s) => typeof s === "string") ? steps : null;
+}
+function carryOn(plan, done) {
+  if (!plan) return "You stopped before saying your plan. Call build_plan with it now, then build it step by step, calling build_step after each.";
+  const left = stepsLeft(plan, done);
+  return [
+    `Steps ${left.map((i) => i + 1).join(", ")} of your plan are not done yet:`,
+    ...left.map((i) => `${i + 1}. ${plan[i]}`),
+    "",
+    "Check git log and git status to see where you are, then carry on: finish each step, run its checks, and call build_step after it. Do not run anything in the background."
+  ].join("\n");
+}
+async function solutionPage(client, projectId, ref) {
+  const { data } = await client.from("projects").select("slug").eq("id", projectId).maybeSingle();
+  return data?.slug ? `${webUrl()}/p/${data.slug}/roadmap/${ref}` : null;
+}
+function prBody(said, page) {
+  return [
+    said.trim(),
+    page ? `
+The solution and its spec: ${page}` : "",
+    "\n\u2014 Built by NanoPM with Claude Code. A draft: review before merging."
+  ].filter(Boolean).join("\n");
+}
+async function startSolution(client, projectId, ref, jobId) {
+  const { error } = await client.rpc("start_solution", { p_project_id: projectId, p_ref: ref, p_job_id: jobId });
+  if (error) throw new Error(pgMessage(error));
+}
+async function unstartSolution(client, projectId, ref, was) {
+  await client.rpc("unstart_solution", { p_project_id: projectId, p_ref: ref, p_to: was });
+}
+async function requeueLostBuild(client, job) {
+  const params = job.params ?? {};
+  if ((job.attempt ?? 1) < 2) {
+    const { data } = await client.from("jobs").update({ status: "queued", attempt: (job.attempt ?? 1) + 1, assigned_daemon_id: null }).eq("id", job.id).eq("status", "running").select("id");
+    if (data?.length) return true;
+  }
+  const { data: solution } = await client.from("solutions").select("ref").eq("id", params.solution_id ?? "").maybeSingle();
+  if (job.project_id && solution) await unstartSolution(client, job.project_id, solution.ref, wasOf(job.params)).catch(() => void 0);
+  return false;
+}
+async function resumePausedBuilds(client, daemonId, now = Date.now()) {
+  const { data: parked } = await client.from("jobs").select("id").eq("skill", BUILD_SKILL).eq("status", "waiting").eq("assigned_daemon_id", daemonId);
+  const ids = (parked ?? []).map((j) => j.id);
+  if (!ids.length) return [];
+  const { data: stops } = await client.from("job_events").select("job_id, kind, payload").in("job_id", ids).in("kind", ["paused", "question"]).order("id", { ascending: false });
+  const last = /* @__PURE__ */ new Map();
+  for (const e of stops ?? []) if (!last.has(e.job_id)) last.set(e.job_id, e);
+  const due = ids.filter((id) => {
+    const stop2 = last.get(id);
+    return stop2?.kind === "paused" && Date.parse(String(stop2.payload?.resets_at ?? "")) <= now;
+  });
+  if (!due.length) return [];
+  const { data } = await client.from("jobs").update({ status: "queued", assigned_daemon_id: null }).in("id", due).eq("status", "waiting").select("id");
+  return (data ?? []).map((j) => j.id);
+}
+
 // ../daemon/src/review-preflight.ts
 async function reviewWithoutData(client, job) {
   if (job.skill !== "review" || !job.project_id) return null;
@@ -5375,17 +5926,17 @@ async function reviewWithoutData(client, job) {
 }
 
 // ../daemon/src/skills.ts
-import { existsSync as existsSync2, readdirSync } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join5, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname2, join as join8, resolve as resolve2 } from "path";
 function findSkillsDir(env = process.env) {
   if (env.NANOPM_SKILLS_DIR) return env.NANOPM_SKILLS_DIR;
   const candidates = [
-    join5(process.cwd(), "skills"),
+    join8(process.cwd(), "skills"),
     ...process.argv[1] ? [resolve2(dirname2(process.argv[1]), "..", "skills")] : []
   ];
   for (const dir of candidates) {
-    if (existsSync2(join5(dir, "onboard", "skill.json"))) return dir;
+    if (existsSync3(join8(dir, "onboard", "skill.json"))) return dir;
   }
   throw new Error(`Cannot find the skills directory (tried ${candidates.join(", ")}). Set NANOPM_SKILLS_DIR.`);
 }
@@ -5395,9 +5946,9 @@ function skillDirs(skillsDir, env = process.env) {
 }
 async function loadSkill(name, skillsDir = findSkillsDir()) {
   if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new Error(`Invalid skill name "${name}"`);
-  const dir = skillDirs(skillsDir).map((d) => join5(d, name)).find((d) => existsSync2(join5(d, "skill.json")));
+  const dir = skillDirs(skillsDir).map((d) => join8(d, name)).find((d) => existsSync3(join8(d, "skill.json")));
   if (!dir) throw new Error(`Unknown skill "${name}"`);
-  const raw = JSON.parse(await readFile2(join5(dir, "skill.json"), "utf8"));
+  const raw = JSON.parse(await readFile4(join8(dir, "skill.json"), "utf8"));
   let manifest;
   try {
     manifest = parseSkillManifest(raw);
@@ -5406,7 +5957,7 @@ async function loadSkill(name, skillsDir = findSkillsDir()) {
   }
   const tainted = taintedByTheWeb(manifest);
   if (tainted) throw new Error(`the "${name}" skill cannot be loaded: ${tainted}`);
-  const body = await readFile2(join5(dir, "SKILL.md"), "utf8");
+  const body = await readFile4(join8(dir, "SKILL.md"), "utf8");
   return { manifest, body, dir };
 }
 var NOT_WITH_READ_WEB = ["write_memory", "problems", "propose", "review", "write_repo", "run_commands"];
@@ -5441,7 +5992,7 @@ function renderPrompt(template, params) {
 var NEEDS_THE_REQUESTERS_CLONE = ["write_repo", "run_commands"];
 var NEEDS_THE_REQUESTERS_IDENTITY = /* @__PURE__ */ new Set(["want", "start"]);
 async function clonelessSkills(skillsDir = findSkillsDir()) {
-  const names = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync2(join5(skillsDir, d.name, "skill.json"))).map((d) => d.name);
+  const names = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync3(join8(skillsDir, d.name, "skill.json"))).map((d) => d.name);
   const out = [];
   for (const name of names) {
     try {
@@ -5495,30 +6046,6 @@ ${JSON.stringify(mappingOutputSchema(input.role))}`,
 
 // ../daemon/src/problem-mapping.ts
 import { createHash as createHash2 } from "crypto";
-
-// ../daemon/src/usage.ts
-function sumUsage(a, b) {
-  if (!a) return { ...b };
-  return {
-    ...b,
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
-    cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0),
-    costUsd: (a.costUsd ?? 0) + (b.costUsd ?? 0),
-    turns: a.turns + b.turns,
-    durationMs: a.durationMs + b.durationMs,
-    ...a.contextPeakTokens || b.contextPeakTokens ? { contextPeakTokens: Math.max(a.contextPeakTokens ?? 0, b.contextPeakTokens ?? 0) } : {},
-    ...a.reads || b.reads ? { reads: sumReads(a.reads, b.reads) } : {}
-  };
-}
-function sumReads(a, b) {
-  const calls = { ...a?.calls ?? {} };
-  for (const [tool, n] of Object.entries(b?.calls ?? {})) calls[tool] = (calls[tool] ?? 0) + n;
-  return { files: (a?.files ?? 0) + (b?.files ?? 0), calls };
-}
-
-// ../daemon/src/problem-mapping.ts
 var MAPPING_TURN_LIMIT = 40;
 var MAPPING_TIMEOUT_MS = 20 * 6e4;
 async function runProblemMapping(ports) {
@@ -5568,9 +6095,9 @@ async function runProblemMapping(ports) {
       if (cycle === 1 && ports.collect) {
         const maxTurns = Math.min(8, MAPPING_TURN_LIMIT - (usage?.turns ?? 0) - 2);
         await ports.checkpoint("collector.started", { maxTurns: Math.max(0, maxTurns), startedAt: Date.now() });
-        let next2 = null;
+        let next = null;
         try {
-          next2 = await ports.collect(proposal.investigation, signal, maxTurns);
+          next = await ports.collect(proposal.investigation, signal, maxTurns);
         } catch (err) {
           signal.throwIfAborted();
           failure2 = errorMessage(err);
@@ -5578,13 +6105,13 @@ async function runProblemMapping(ports) {
           usage = sumUsage(usage, spent);
           await ports.checkpoint("collector", { usage: spent, failed: failure2 });
         }
-        if (!next2 && !failure2) await ports.checkpoint("collector", { unavailable: true });
+        if (!next && !failure2) await ports.checkpoint("collector", { unavailable: true });
         signal.throwIfAborted();
-        if (next2) {
-          if (next2.usage.turns > 0) usage = sumUsage(usage, next2.usage);
-          await ports.checkpoint("collector", { usage: next2.usage });
+        if (next) {
+          if (next.usage.turns > 0) usage = sumUsage(usage, next.usage);
+          await ports.checkpoint("collector", { usage: next.usage });
           if ((usage?.turns ?? 0) >= MAPPING_TURN_LIMIT) throw new Error("Collection exhausted the shared turn budget.");
-          snapshot3 = copySnapshot(next2.snapshot);
+          snapshot3 = copySnapshot(next.snapshot);
           feedback = { previous_proposal: proposal, instruction: proposal.investigation.collector === "sources" ? "The seen sources you named are now in the snapshot in full. Reconsider the proposal with them, then return the final version." : "Reconsider the proposal with the collected findings, then return the final version." };
           await ports.checkpoint("collection", { snapshot_hash: mappingHash(snapshot3), request: proposal.investigation });
           continue;
@@ -5770,8 +6297,8 @@ async function askAgainIfUnanswered(attempt7, say, role7) {
 var UNANSWERED = /structured[ _]output|returned no result/i;
 
 // ../daemon/src/site.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join9 } from "path";
 var SITE_PATHS = ["/", "/about", "/pricing"];
 var PAGE_CHARS = 6e3;
 var SITE_TIMEOUT_MS = 2e4;
@@ -5894,7 +6421,7 @@ function siteFromSearch(name, hits) {
 }
 async function read(repoRoot, name) {
   try {
-    const text2 = await readFile3(join6(repoRoot, name), "utf8");
+    const text2 = await readFile5(join9(repoRoot, name), "utf8");
     return text2.length > 2e5 ? null : text2;
   } catch {
     return null;
@@ -5948,8 +6475,8 @@ async function fromReadme(repoRoot) {
 }
 
 // ../daemon/src/repo-docs.ts
-import { readFile as readFile4, readdir, stat } from "fs/promises";
-import { join as join7, relative } from "path";
+import { readFile as readFile6, readdir as readdir2, stat } from "fs/promises";
+import { join as join10, relative } from "path";
 var WRITTEN = /(persona|audience|customer|user-research|research\/|icp|segment)/i;
 var ABOUT_PEOPLE = /(persona|audience|customer|user-research|research\/|interview|feedback|survey|verbatim|voice|icp|segment)/i;
 var DOC = /\.(md|mdx|txt)$/i;
@@ -5962,12 +6489,12 @@ async function readDocs(cwd, opts = {}) {
     if (depth > 3 || found.length >= DOCS_MAX * 4) return;
     let entries;
     try {
-      entries = await readdir(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join7(dir, entry.name);
+      const full = join10(dir, entry.name);
       if (SKIP.test(`/${relative(cwd, full)}`)) continue;
       if (entry.isDirectory()) await walk(full, depth + 1);
       else if (DOC.test(entry.name) && (!opts.onlyAboutPeople || ABOUT_PEOPLE.test(relative(cwd, full)))) found.push(full);
@@ -5979,7 +6506,7 @@ async function readDocs(cwd, opts = {}) {
   for (const path of found.slice(0, DOCS_MAX)) {
     try {
       if ((await stat(path)).size > 4e5) continue;
-      out.push({ path: relative(cwd, path), text: (await readFile4(path, "utf8")).slice(0, DOC_CHARS) });
+      out.push({ path: relative(cwd, path), text: (await readFile6(path, "utf8")).slice(0, DOC_CHARS) });
     } catch {
     }
   }
@@ -6451,10 +6978,10 @@ function rank(candidates, readings, verdict, faults) {
   const order = (lands) => DIRECTION_SHAPE_ORDER.indexOf(lands);
   return candidates.filter((c) => readings.some((r) => r.lands === c.lands)).map((candidate) => {
     const v = verdict.verdicts.find((x) => x.lands === candidate.lands);
-    const failed = v?.failed ?? [];
-    const fatal = failed.filter((t) => MUST_PASS_TESTS.includes(t.test));
+    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 ?? [], ...failed.map((t) => t.test)]);
+    const answered = /* @__PURE__ */ new Set([...v?.passed ?? [], ...failed2.map((t) => t.test)]);
     const unanswered = MUST_PASS_TESTS.filter((t) => !answered.has(t));
     const reservations = [
       ...fatal.map((t) => `${t.test} \u2014 ${t.because}`),
@@ -6527,17 +7054,17 @@ async function publish2(client, projectId, job, winner, current, because, confid
   for (const row of DIRECTION_ROWS) {
     const content = winner[row].trim();
     const base = current.find((r) => r.topic === row && r.key === directionKey(row));
-    const next2 = current.find((r) => r.topic === row && r.key === directionKey(row, true));
+    const next = current.find((r) => r.topic === row && r.key === directionKey(row, true));
     const sources2 = [
       ...winner.restsOn.map((ref) => ({ kind: "memory", ref, note: because })),
       ...runnerUp && runnerUp[row]?.trim() && runnerUp[row].trim() !== content ? [{ kind: CONSIDERED, ref: runnerUp.lands, note: runnerUp[row].trim() }] : []
     ];
     if (base?.provenance === "stated") {
       if (base.content.trim() === content) {
-        if (next2) await retire(client, projectId, next2.id, "withdrawn: the crew now agrees with your line");
+        if (next) await retire(client, projectId, next.id, "withdrawn: the crew now agrees with your line");
         continue;
       }
-      await write2(client, projectId, jobId, row, { key: directionKey(row, true), content, confidence, sources: sources2, supersedes: next2?.id ?? null });
+      await write2(client, projectId, jobId, row, { key: directionKey(row, true), content, confidence, sources: sources2, supersedes: next?.id ?? null });
       proposed.push(row);
     } else {
       if (base && base.content.trim() === content) continue;
@@ -6758,17 +7285,17 @@ async function publish3(client, projectId, job, winner, current, because, runner
   for (const line of PITCH_LINE_KEYS) {
     const content = winner[line].trim();
     const base = current.find((r) => r.key === pitchKey(line));
-    const next2 = current.find((r) => r.key === pitchKey(line, true));
+    const next = current.find((r) => r.key === pitchKey(line, true));
     const sources2 = [
       ...winner.restsOn.map((ref) => ({ kind: "memory", ref, note: because })),
       ...runnerUp && !sameLine(runnerUp[line], content) ? [{ kind: CONSIDERED, ref: runnerUp.form, note: runnerUp[line].trim() }] : []
     ];
     if (base?.provenance === "stated") {
       if (sameLine(base.content, content)) {
-        if (next2) await retire2(client, projectId, next2.id, "withdrawn: the crew now agrees with your line");
+        if (next) await retire2(client, projectId, next.id, "withdrawn: the crew now agrees with your line");
         continue;
       }
-      await write3(client, projectId, jobId, { key: pitchKey(line, true), title: PITCH_LINE_TITLE[line], content, confidence: winner.confidence, sources: sources2, supersedes: next2?.id ?? null });
+      await write3(client, projectId, jobId, { key: pitchKey(line, true), title: PITCH_LINE_TITLE[line], content, confidence: winner.confidence, sources: sources2, supersedes: next?.id ?? null });
       proposed.push(line);
     } else {
       if (base && sameLine(base.content, content)) continue;
@@ -7023,10 +7550,10 @@ async function runMarketJob({ client, job, adapter, spec: spec2, onEvent }) {
 }
 async function writeRow(client, projectId, job, rows2, item) {
   const base = rows2.find((r) => r.key === item.key);
-  const next2 = rows2.find((r) => r.key === `${item.key}-next`);
+  const next = rows2.find((r) => r.key === `${item.key}-next`);
   if (base && base.content.trim() === item.content) return { kind: "written" };
   if (base?.provenance === "stated") {
-    await write4(client, projectId, job.id, { ...item, key: `${item.key}-next`, supersedes: next2?.id ?? null });
+    await write4(client, projectId, job.id, { ...item, key: `${item.key}-next`, supersedes: next?.id ?? null });
     return { kind: "written" };
   }
   const held = keepsTheLine(job, base, item.confidence);
@@ -7781,8 +8308,8 @@ ${body}
 
 // ../daemon/src/crew.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join8 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join11 } from "path";
 var READ_ONLY = {
   read_repo: /^(Read|Glob|Grep)$/,
   read_data: /(^|__)(list_connections|describe_source|query)$/
@@ -7797,8 +8324,8 @@ async function attempt6({ adapter, spec: spec2, onEvent, skill: skillName, name,
   if (skill.manifest.capabilities.some((c) => !holds.includes(c))) throw new Error(`The ${name} may not hold tools.`);
   const refused = grant.find((c) => !READ_ONLY[c] || !skill.manifest.capabilities.includes(c));
   if (refused) throw new Error(`The ${name} may not hold ${refused}.`);
-  const runDir = dir ? join8(spec2.runDir, dir) : spec2.runDir;
-  if (dir) await mkdir2(runDir, { recursive: true, mode: 448 });
+  const runDir = dir ? join11(spec2.runDir, dir) : spec2.runDir;
+  if (dir) await mkdir3(runDir, { recursive: true, mode: 448 });
   let result;
   let usage = null;
   await onEvent({ type: "text", text: say });
@@ -8595,7 +9122,7 @@ function critiqueWording(o, v, reworked) {
   return { problem: problem && problem.length <= PROBLEM_MAX ? problem : o.problem, description: v.description?.trim() || o.description };
 }
 function shape(o, input) {
-  const resolve6 = (ids, stance) => ids.map((id) => {
+  const resolve5 = (ids, stance) => ids.map((id) => {
     const source = input.cites.get(id.trim().toUpperCase());
     if (!source) input.unresolved?.add(id.trim());
     return source;
@@ -8607,7 +9134,7 @@ function shape(o, input) {
     if (source) quoted.push({ ...source, note: clip3(stripContactDetails(e.quote), 140), stance: "supports" });
   }
   const quotedRefs = new Set(quoted.map((q) => q.ref));
-  const cited = [...resolve6(o.restsOn, "supports"), ...resolve6(o.against.filter((id) => !supporting.has(id.trim().toUpperCase())), "contradicts")].filter((c) => !(c.stance === "supports" && quotedRefs.has(c.ref)));
+  const cited = [...resolve5(o.restsOn, "supports"), ...resolve5(o.against.filter((id) => !supporting.has(id.trim().toUpperCase())), "contradicts")].filter((c) => !(c.stance === "supports" && quotedRefs.has(c.ref)));
   const all = [...quoted, ...cited];
   let sources2 = all.filter((c, i) => all.findIndex((x) => x.kind === c.kind && x.ref === c.ref && x.stance === c.stance && x.note === c.note) === i);
   if (!sources2.some((s) => s.stance === "supports")) sources2 = [{ kind: "inference", ref: "nanopm", note: null, stance: "supports" }, ...sources2];
@@ -8897,11 +9424,11 @@ async function runSolutionsJob({ client, job, adapter, spec: spec2, onEvent }) {
     await journal("solutions.citations", `${ids.length} citation${ids.length === 1 ? "" : "s"} named nothing the crew was handed, and ${ids.length === 1 ? "was" : "were"} left out: ${ids.slice(0, 12).join(", ")}.`);
   }
   const recorded = results.filter((r) => "kept" in r);
-  const failed = results.filter((r) => "failed" in r);
+  const failed2 = results.filter((r) => "failed" in r);
   const took = `Took ${duration(Date.now() - started)}${timings.length ? `: ${timings.map((t) => `${t.what} ${duration(t.ms)}`).join(", ")}` : ""}.`;
   const summary = [
-    deep ? leaves.length ? recorded.length ? `Deep dive on \u201C${clip3(leaves[0].problem, 120)}\u201D: kept ${recorded[0].kept.map((t) => `\u201C${t}\u201D`).join(", ")}.` : `Deep dive on \u201C${clip3(leaves[0].problem, 120)}\u201D: nothing recorded \u2014 ${failed[0]?.failed ?? "no solution came back"}.` : "Deep dive: nothing to think through." : `Flash: solutions for ${recorded.length} of ${leaves.length} problem${leaves.length === 1 ? "" : "s"} in ${branches.length} branch${branches.length === 1 ? "" : "es"}.`,
-    !deep && failed.length ? `Not recorded: ${failed.map((f) => `${f.leaf.ref} (${f.failed})`).join("; ")}.` : "",
+    deep ? leaves.length ? recorded.length ? `Deep dive on \u201C${clip3(leaves[0].problem, 120)}\u201D: kept ${recorded[0].kept.map((t) => `\u201C${t}\u201D`).join(", ")}.` : `Deep dive on \u201C${clip3(leaves[0].problem, 120)}\u201D: nothing recorded \u2014 ${failed2[0]?.failed ?? "no solution came back"}.` : "Deep dive: nothing to think through." : `Flash: solutions for ${recorded.length} of ${leaves.length} problem${leaves.length === 1 ? "" : "s"} in ${branches.length} branch${branches.length === 1 ? "" : "es"}.`,
+    !deep && failed2.length ? `Not recorded: ${failed2.map((f) => `${f.leaf.ref} (${f.failed})`).join("; ")}.` : "",
     skipped.length ? `Skipped: ${skipped.join("; ")}.` : "",
     took
   ].filter(Boolean).join(" ");
@@ -9071,9 +9598,9 @@ async function flashBranch(ctx, w, n, places) {
     const why = clip3(error instanceof Error ? error.message : String(error), 300);
     for (const leaf of w.leaves) if (!out.some((o) => o.leaf === leaf)) out.push({ leaf, failed: why });
   }
-  const failed = out.filter((o) => "failed" in o);
-  if (failed.length) {
-    await ctx.journal("solutions.failed", `\u201C${name}\u201D could not finish: ${failed.map((f) => `${f.leaf.ref} \u2014 ${f.failed}`).join("; ")}. The other branches were not held.`);
+  const failed2 = out.filter((o) => "failed" in o);
+  if (failed2.length) {
+    await ctx.journal("solutions.failed", `\u201C${name}\u201D could not finish: ${failed2.map((f) => `${f.leaf.ref} \u2014 ${f.failed}`).join("; ")}. The other branches were not held.`);
   }
   return out;
 }
@@ -9438,32 +9965,32 @@ function specOutputSchema(role7) {
 }
 
 // ../daemon/src/git.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var execFileAsync4 = promisify4(execFile4);
-var MAX_BUFFER = 4 * 1024 * 1024;
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execFileAsync5 = promisify5(execFile5);
+var MAX_BUFFER2 = 4 * 1024 * 1024;
 var WIKI_DIR = ".nanopm/wiki/docs";
-async function git2(cwd, args) {
-  const { stdout } = await execFileAsync4("git", ["-C", cwd, ...args], { maxBuffer: MAX_BUFFER, timeout: 2e4 });
+async function git3(cwd, args) {
+  const { stdout } = await execFileAsync5("git", ["-C", cwd, ...args], { maxBuffer: MAX_BUFFER2, timeout: 2e4 });
   return stdout.trim();
 }
 async function listTrackedFiles(cwd) {
-  const lines = (args) => git2(cwd, args).then((out) => out ? out.split("\n") : [], () => []);
+  const lines = (args) => git3(cwd, args).then((out) => out ? out.split("\n") : [], () => []);
   const [files, wiki] = await Promise.all([lines(["ls-files"]), lines(["ls-files", "--others", "--ignored", "--exclude-standard", "--", WIKI_DIR])]);
   return { files, wiki };
 }
 async function headCommit(cwd) {
-  return git2(cwd, ["rev-parse", "--short", "HEAD"]).then((sha) => sha || null, () => null);
+  return git3(cwd, ["rev-parse", "--short", "HEAD"]).then((sha) => sha || null, () => null);
 }
 async function collectGitDigest(cwd, recent = 30) {
   try {
-    await git2(cwd, ["rev-parse", "--git-dir"]);
+    await git3(cwd, ["rev-parse", "--git-dir"]);
   } catch {
     return null;
   }
   const safe = async (args) => {
     try {
-      return await git2(cwd, args);
+      return await git3(cwd, args);
     } catch {
       return "";
     }
@@ -9853,13 +10380,13 @@ var told = (r) => ({
 });
 
 // ../daemon/src/objective-definitions.ts
-import { execFile as execFile5 } from "child_process";
+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 readFile5 } from "fs/promises";
-import { join as join9 } from "path";
-import { promisify as promisify5 } from "util";
-var execFileAsync5 = promisify5(execFile5);
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir4, readFile as readFile7 } from "fs/promises";
+import { join as join12 } from "path";
+import { promisify as promisify6 } from "util";
+var execFileAsync6 = promisify6(execFile6);
 var DEFINITIONS_TIMEOUT_MS = 9e4;
 var DEFINITIONS_THINKING_TOKENS = 2e3;
 var READ_TOOLS3 = /* @__PURE__ */ new Set(["Read", "Glob", "Grep", "StructuredOutput"]);
@@ -9868,7 +10395,7 @@ var COUNTING_LINES_MAX = 80;
 var PER_FILE = 4;
 async function countingLines(cwd) {
   try {
-    const { stdout } = await execFileAsync5("git", ["grep", "-n", "-I", "-i", "-E", COUNTING, "--", ".", ":!*lock*", ":!*.min.*", ":!*.map", ":!*.svg", ":!*.snap"], {
+    const { stdout } = await execFileAsync6("git", ["grep", "-n", "-I", "-i", "-E", COUNTING, "--", ".", ":!*lock*", ":!*.min.*", ":!*.map", ":!*.svg", ":!*.snap"], {
       cwd,
       maxBuffer: 16 * 1024 * 1024,
       timeout: 5e3
@@ -9893,7 +10420,7 @@ function pickLines(raw) {
 }
 async function killRecorded(runDir) {
   try {
-    const pid = Number((await readFile5(join9(runDir, "harness.pid"), "utf8")).trim());
+    const pid = Number((await readFile7(join12(runDir, "harness.pid"), "utf8")).trim());
     if (pid > 1) process.kill(pid, "SIGKILL");
   } catch {
   }
@@ -9913,8 +10440,8 @@ async function readDefinitions({ adapter, spec: spec2, publish: publish5, journa
   if (!hasRepo) return give({}, "No repository to read: the card offers the common definitions.", "ok");
   try {
     const skill = await loadSkill("define-objective");
-    const runDir = join9(spec2.runDir, "definitions");
-    await mkdir3(runDir, { recursive: true, mode: 448 });
+    const runDir = join12(spec2.runDir, "definitions");
+    await mkdir4(runDir, { recursive: true, mode: 448 });
     const schema = definitionsOutputSchema();
     const [lines, listed] = await Promise.all([countingLines(spec2.cwd), listTrackedFiles(spec2.cwd)]);
     const signal = AbortSignal.any([spec2.signal, AbortSignal.timeout(timeoutMs)]);
@@ -9975,7 +10502,7 @@ ${renderTrackedFiles(listed.files, void 0, listed.wiki)}
     if (!result) throw new Error("no answer");
     const parsed = DefinitionsAnswer.safeParse(JSON.parse(result));
     if (!parsed.success) throw new Error("an answer in the wrong shape");
-    const checked = checkProposals(parsed.data, (file) => existsSync3(join9(spec2.cwd, file)));
+    const checked = checkProposals(parsed.data, (file) => existsSync4(join12(spec2.cwd, file)));
     const definitions2 = lever ? checked[lever] ? { [lever]: checked[lever] } : {} : checked;
     const kept = Object.values(definitions2).reduce((n, list) => n + (list?.length ?? 0), 0);
     const read6 = Object.values(definitions2).flat().filter((d) => d?.found).length;
@@ -10248,10 +10775,10 @@ function localDate(timezone, at) {
 
 // ../daemon/src/run-job.ts
 import { randomUUID as randomUUID12 } from "crypto";
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir4, readFile as readFile6, rm as rm3 } from "fs/promises";
-import { homedir as homedir3, tmpdir } from "os";
-import { join as join10, resolve as resolve4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir5, readFile as readFile8, rm as rm4 } from "fs/promises";
+import { homedir as homedir4, tmpdir } from "os";
+import { join as join13, resolve as resolve4 } from "path";
 
 // ../daemon/src/events.ts
 var JobEventWriter = class {
@@ -10331,320 +10858,28 @@ function lighten(value) {
   return value ?? null;
 }
 
-// ../daemon/src/repo.ts
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
-var execFileAsync6 = promisify6(execFile6);
-var MAX_BUFFER2 = 4 * 1024 * 1024;
-var TIMEOUT_MS = 6e4;
-async function git3(cwd, args, timeoutMs = TIMEOUT_MS) {
-  const { stdout } = await execFileAsync6("git", ["-C", cwd, ...args], { maxBuffer: MAX_BUFFER2, timeout: timeoutMs });
-  return stdout.trim();
-}
-var RepoError = class extends Error {
-};
-function branchName(ref) {
-  const slug = ref.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  if (!slug) throw new RepoError(`"${ref}" has no letters or digits to make a branch name from`);
-  return `nanopm/${slug}`;
+// ../daemon/src/run-job.ts
+import { hostname } from "os";
+
+// ../daemon/src/site-ask.ts
+async function askAboutSite(opts) {
+  const host = opts.candidate ? new URL(opts.candidate).hostname : null;
+  await opts.events.write("question", {
+    question: host ? `Is ${host} your site?` : "What is your product's website?",
+    holds: false,
+    // The terminal leaves this one to the browser (`run.ts`), and the page draws its own card.
+    about: "site",
+    ...host ? { site: host } : {}
+  });
 }
-async function readState(cwd) {
-  try {
-    await git3(cwd, ["rev-parse", "--git-dir"]);
-  } catch {
-    throw new RepoError(`${cwd} is not a git repository`);
-  }
-  const [branch, head, status2, remoteUrl] = await Promise.all([
-    git3(cwd, ["branch", "--show-current"]).catch(() => ""),
-    git3(cwd, ["rev-parse", "HEAD"]).catch(() => ""),
-    git3(cwd, ["status", "--porcelain"]).catch(() => ""),
-    git3(cwd, ["remote", "get-url", "origin"]).catch(() => "")
-  ]);
-  const dirty = status2.split("\n").filter(Boolean).map((l) => l.slice(3));
-  return { branch, head, clean: dirty.length === 0, dirty, hasRemote: Boolean(remoteUrl), remoteUrl: remoteUrl || void 0 };
-}
-async function ensureCleanTree(cwd) {
-  const state = await readState(cwd);
-  if (!state.head) {
-    throw new RepoError("this repository has no commits yet; make the first commit, then run nanopm next");
-  }
-  if (!state.clean) {
-    const shown = state.dirty.slice(0, 5).join(", ");
-    const more = state.dirty.length > 5 ? `, and ${state.dirty.length - 5} more` : "";
-    throw new RepoError(
-      `the working tree has uncommitted changes (${shown}${more}). NanoPM commits only its own work, so commit or stash yours first.`
-    );
-  }
-  return state;
-}
-async function createBranch(cwd, name) {
-  const existing = await git3(cwd, ["branch", "--list", name]).catch(() => "");
-  if (existing.trim()) {
-    throw new RepoError(`branch ${name} already exists. Delete it or finish what is on it first.`);
-  }
-  await git3(cwd, ["checkout", "-b", name]);
-}
-async function commitAll(cwd, message) {
-  await git3(cwd, ["add", "-A"]);
-  const staged = await git3(cwd, ["diff", "--cached", "--name-only"]).catch(() => "");
-  if (!staged) return null;
-  await git3(cwd, ["commit", "-m", message, "-m", "Written by NanoPM. Review before merging."]);
-  const sha = await git3(cwd, ["rev-parse", "--short", "HEAD"]);
-  return { sha, ...await diffStat(cwd) };
-}
-async function diffStat(cwd) {
-  const numstat = await git3(cwd, ["show", "--numstat", "--format=", "HEAD"]).catch(() => "");
-  let files = 0;
-  let insertions = 0;
-  let deletions = 0;
-  for (const line of numstat.split("\n").filter(Boolean)) {
-    const [add2 = "", del = ""] = line.split("	");
-    files += 1;
-    insertions += Number(add2) || 0;
-    deletions += Number(del) || 0;
-  }
-  return { files, insertions, deletions };
-}
-async function pushBranch(cwd, name) {
-  const state = await readState(cwd);
-  if (!state.hasRemote) return { pushed: false, reason: "this repository has no origin remote" };
-  try {
-    const { stderr } = await execFileAsync6("git", ["-C", cwd, "push", "--set-upstream", "origin", name], {
-      maxBuffer: MAX_BUFFER2,
-      timeout: 12e4
-    });
-    return { pushed: true, reviewUrl: reviewUrlFrom(stderr) };
-  } catch (err) {
-    const text2 = errorMessage(err);
-    return { pushed: false, reason: text2.split("\n").slice(-3).join(" ").trim() || "git push failed" };
-  }
-}
-function reviewUrlFrom(pushOutput) {
-  const match = /https?:\/\/\S+/.exec(pushOutput);
-  return match?.[0]?.replace(/[).,]+$/, "");
-}
-async function checkout(cwd, ref) {
-  await git3(cwd, ["checkout", ref]);
-}
-async function deleteBranch(cwd, name) {
-  await git3(cwd, ["branch", "-D", name]).catch(() => "");
-}
-async function changedFiles(cwd) {
-  const status2 = await git3(cwd, ["status", "--porcelain"]).catch(() => "");
-  return status2.split("\n").filter(Boolean).map((line) => line.slice(3).trim()).map((path) => path.includes(" -> ") ? path.split(" -> ")[1].trim() : path).map((path) => path.replace(/^"|"$/g, ""));
-}
-
-// ../daemon/src/next-run.ts
-async function loadAcceptedSolution(client, projectId, solutionId) {
-  const { data, error } = await client.from("solutions").select("id, ref, title, reasoning, status, assumption, eval, sources").eq("id", solutionId).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");
-  if (data.status !== "accepted" && data.status !== "building") {
-    throw new Error(`${data.ref} is ${data.status}. Only a solution you accepted can be built.`);
-  }
-  return { ...data, sources: data.sources ?? [] };
-}
-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 && !/only an accepted solution/.test(error.message)) throw new Error(pgMessage(error));
-}
-async function unstartSolution(client, projectId, ref) {
-  await client.rpc("unstart_solution", { p_project_id: projectId, p_ref: ref });
-}
-function renderSolution(solution) {
-  const lines = [`${solution.ref}  ${solution.title}`, "", `Why: ${solution.reasoning}`];
-  if (solution.assumption) lines.push(`Bets on: ${solution.assumption}`);
-  if (solution.eval) lines.push(`We'll know: ${solution.eval}`);
-  if (solution.sources.length) {
-    lines.push(`Rests on: ${solution.sources.map((s) => `${s.kind}:${s.ref}`).join(", ")}`);
-  }
-  return lines.join("\n");
-}
-async function openRepoSession(cwd, ref) {
-  const state = await ensureCleanTree(cwd);
-  if (!state.branch) {
-    throw new RepoError("this repository has a detached HEAD; check out a branch first");
-  }
-  const branch = branchName(ref);
-  await createBranch(cwd, branch);
-  return { branch, baseBranch: state.branch };
-}
-async function closeRepoSession(cwd, session2, item) {
-  return closeBranch(cwd, session2, `${item.ref}: ${item.title}`, { commitErrorThrows: true });
-}
-async function abandonRepoSession(cwd, session2, item) {
-  return closeBranch(cwd, session2, item ? `${item.ref}: ${item.title}` : "WIP: nanopm did not finish", { commitErrorThrows: false });
-}
-async function closeBranch(cwd, session2, message, { commitErrorThrows }) {
-  let commit;
-  try {
-    commit = await commitAll(cwd, message);
-  } catch (err) {
-    await checkout(cwd, session2.baseBranch).catch(() => void 0);
-    if (commitErrorThrows) throw err;
-    commit = null;
-  }
-  if (!commit) {
-    await checkout(cwd, session2.baseBranch).catch(() => void 0);
-    await deleteBranch(cwd, session2.branch);
-    return { branch: session2.branch, pushed: false, note: "nothing was changed, so no branch was kept" };
-  }
-  const push = await pushBranch(cwd, session2.branch);
-  await checkout(cwd, session2.baseBranch).catch(() => void 0);
-  return {
-    branch: session2.branch,
-    commit,
-    pushed: push.pushed,
-    reviewUrl: push.reviewUrl,
-    note: push.pushed ? void 0 : `not pushed: ${push.reason}`
-  };
-}
-async function finishSolution(client, job, solution, result) {
-  const sources2 = [{ kind: "branch", ref: result.branch }];
-  if (result.commit?.sha) sources2.push({ kind: "git", ref: result.commit.sha });
-  if (result.reviewUrl) sources2.push({ kind: "url", ref: result.reviewUrl });
-  sources2.push({ kind: "job", ref: job.id });
-  const { error } = await client.rpc("finish_solution", {
-    p_project_id: job.project_id,
-    p_ref: solution.ref,
-    p_job_id: job.id,
-    p_sources: sources2
-  });
-  if (error) throw new Error(`the work is committed on ${result.branch}, but recording it failed: ${error.message}`);
-}
-function renderRepoResult(result) {
-  if (!result.commit) return result.note ?? "nothing changed";
-  const { files, insertions, deletions } = result.commit;
-  const stat2 = `${files} file${files === 1 ? "" : "s"} changed, ${insertions} insertion${insertions === 1 ? "" : "s"}, ${deletions} deletion${deletions === 1 ? "" : "s"}`;
-  const lines = [`${result.branch} \xB7 ${result.commit.sha} \xB7 ${stat2}`];
-  if (result.reviewUrl) lines.push(result.reviewUrl);
-  else if (result.note) lines.push(result.note);
-  return lines.join("\n");
-}
-
-// ../daemon/src/run-job.ts
-import { hostname } from "os";
-
-// ../daemon/src/site-ask.ts
-async function askAboutSite(opts) {
-  const host = opts.candidate ? new URL(opts.candidate).hostname : null;
-  await opts.events.write("question", {
-    question: host ? `Is ${host} your site?` : "What is your product's website?",
-    holds: false,
-    // The terminal leaves this one to the browser (`run.ts`), and the page draws its own card.
-    about: "site",
-    ...host ? { site: host } : {}
-  });
-}
-
-// ../daemon/src/verify.ts
-import { spawn as spawn3 } from "child_process";
-var VERIFY_TIMEOUT_MS = 10 * 6e4;
-var OUTPUT_TAIL = 4e3;
-var DEFINES_THE_COMMAND = [
-  /(^|\/)package\.json$/,
-  /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/,
-  /(^|\/)(Makefile|justfile|Justfile|Taskfile\.ya?ml)$/,
-  /(^|\/)\.husky\//,
-  /(^|\/)\.github\//,
-  /(^|\/)(pyproject\.toml|uv\.lock|Cargo\.toml|Cargo\.lock|Gemfile|Gemfile\.lock)$/
-];
-function pathsNamedIn(command) {
-  return command.split(/[\s;&|()<>]+/).filter((t) => /[/.]/.test(t) && !/^-/.test(t) && t.length > 2).map((t) => t.replace(/^\.\//, "").replace(/^["']|["']$/g, ""));
-}
-function guardVerify(changed, command) {
-  for (const file of changed) {
-    const pattern = DEFINES_THE_COMMAND.find((p) => p.test(file));
-    if (pattern) {
-      return `the change touched ${file}, which decides what the verify command does, so the command was not run`;
-    }
-  }
-  const named = pathsNamedIn(command);
-  for (const file of changed) {
-    if (named.some((n) => file === n || file.endsWith(`/${n}`) || n.endsWith(file))) {
-      return `the change touched ${file}, which the verify command runs, so the command was not run`;
-    }
-  }
-  return null;
-}
-async function verify(opts) {
-  const skipped = guardVerify(opts.changed, opts.command);
-  if (skipped) return { ran: false, passed: false, skipped, output: "", durationMs: 0, timedOut: false };
-  return runCommand(opts);
-}
-async function runCommand(opts) {
-  const timeoutMs = opts.timeoutMs ?? VERIFY_TIMEOUT_MS;
-  const startedAt = Date.now();
-  const child = spawn3("sh", ["-c", opts.command], {
-    cwd: opts.cwd,
-    env: opts.env,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  let output = "";
-  const collect6 = (chunk) => {
-    output += chunk.toString();
-    if (output.length > OUTPUT_TAIL * 4) output = output.slice(-OUTPUT_TAIL * 2);
-  };
-  child.stdout.on("data", collect6);
-  child.stderr.on("data", collect6);
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    child.kill("SIGTERM");
-    setTimeout(() => child.kill("SIGKILL"), 5e3).unref();
-  }, timeoutMs);
-  const onAbort = () => child.kill("SIGTERM");
-  opts.signal?.addEventListener("abort", onAbort, { once: true });
-  const exitCode = await new Promise((resolve6) => {
-    child.on("close", (code) => resolve6(code));
-    child.on("error", () => resolve6(127));
-  });
-  clearTimeout(timer);
-  opts.signal?.removeEventListener("abort", onAbort);
-  return {
-    ran: true,
-    passed: exitCode === 0 && !timedOut,
-    output: tail(output, OUTPUT_TAIL),
-    exitCode: exitCode ?? void 0,
-    durationMs: Date.now() - startedAt,
-    timedOut
-  };
-}
-function tail(text2, max) {
-  const trimmed = text2.trimEnd();
-  if (trimmed.length <= max) return trimmed;
-  return `\u2026 ${trimmed.slice(-max)}`;
-}
-function renderVerifyResult(result, command) {
-  if (!result.ran) return result.skipped ?? "no verify command is set for this project";
-  const secs = (result.durationMs / 1e3).toFixed(0);
-  if (result.timedOut) return `the check NanoPM could not run itself, \`${command}\`, did not finish within ${secs}s and was stopped`;
-  return result.passed ? `the check NanoPM could not run itself, \`${command}\`, passed in ${secs}s` : `the check NanoPM could not run itself, \`${command}\`, failed (exit ${result.exitCode}) after ${secs}s`;
-}
-function retryPrompt(result, command) {
-  return [
-    `Your change does not pass this project's own check.`,
-    ``,
-    `The daemon ran \`${command}\` in the repository root and it failed with exit ${result.exitCode}.`,
-    `You did not run this and cannot run it; this output is the only evidence you get.`,
-    ``,
-    "```",
-    result.output || "(the command produced no output)",
-    "```",
-    ``,
-    `Fix what this reports, in the files you already changed where possible. Do not disable`,
-    `the check, do not edit what the command runs, and do not change unrelated code to make`,
-    `it pass. If the failure is not caused by your change, say so plainly and stop.`
-  ].join("\n");
-}
-
-// ../daemon/src/run-job.ts
-var QUICK_RUNS = { reword: runRewordJob, talk: runTalkJob };
-async function runJob(job, ctx) {
-  const startedAt = Date.now();
-  let events;
-  events = new JobEventWriter(job.id, supabaseEventInsert(ctx.client, (seq) => events.bump(seq)));
-  let outcome;
+
+// ../daemon/src/run-job.ts
+var QUICK_RUNS = { reword: runRewordJob, talk: runTalkJob };
+async function runJob(job, ctx) {
+  const startedAt = Date.now();
+  let events;
+  events = new JobEventWriter(job.id, supabaseEventInsert(ctx.client, (seq) => events.bump(seq)));
+  let outcome;
   try {
     await events.status("running", { daemon_id: ctx.daemonId, hostname: hostname() });
     const skill = await loadSkill(job.skill);
@@ -10657,11 +10892,13 @@ async function runJob(job, ctx) {
     };
   }
   const durationMs = Date.now() - startedAt;
+  const over = outcome.status !== "waiting";
   await events.status(outcome.status, outcome.error ? { error: outcome.error } : crewRun(job) && outcome.result ? { text: outcome.result } : {});
   await withRetry(
     () => ctx.client.from("jobs").update({
       status: outcome.status,
-      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      // A parked job is not over: it waits, with no heartbeat, for the founder or the limit.
+      finished_at: over ? (/* @__PURE__ */ new Date()).toISOString() : null,
       // A mapping run's root row belongs to SQL: checkpoints, receipt and text land there
       // with the publication. A resumed job's own row is free to carry the text.
       ...job.skill === "problems" && !job.resume_of ? {} : { result: outcome.result !== void 0 ? { text: outcome.result, ...outcome.data } : null },
@@ -10674,7 +10911,7 @@ async function runJob(job, ctx) {
     ctx,
     job,
     "job.end",
-    outcome.status === "succeeded" ? `finished ${job.skill}` : outcome.status === "cancelled" ? `${job.skill} cancelled by the user` : `${job.skill} failed: ${outcome.error?.message}`,
+    outcome.status === "succeeded" ? `finished ${job.skill}` : outcome.status === "waiting" ? `${job.skill} waits, with nothing running` : outcome.status === "cancelled" ? `${job.skill} cancelled by the user` : `${job.skill} failed: ${outcome.error?.message}`,
     {
       usage: {
         tokens: usageTokens(outcome.usage),
@@ -10683,15 +10920,15 @@ async function runJob(job, ctx) {
         ...outcome.usage?.contextPeakTokens ? { context_peak: outcome.usage.contextPeakTokens } : {},
         ...outcome.usage?.reads ? { files_read: outcome.usage.reads.files, calls: outcome.usage.reads.calls } : {}
       },
-      outcome: outcome.status === "succeeded" ? "ok" : "error"
+      outcome: outcome.status === "succeeded" || !over ? "ok" : "error"
     }
   );
   return outcome;
 }
 async function execute(job, skill, ctx, events) {
-  const runDir = join10(nanopmHome(), "run", job.id);
-  await mkdir4(runDir, { recursive: true, mode: 448 });
-  const resumeSessionId = job.resume_of ? await sessionOf(ctx.client, job.resume_of) : void 0;
+  const runDir = join13(nanopmHome(), "run", job.id);
+  await mkdir5(runDir, { recursive: true, mode: 448 });
+  const resumeSessionId = job.resume_of ? await sessionOf(ctx.client, job.resume_of) : 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();
@@ -10734,14 +10971,14 @@ async function execute(job, skill, ctx, events) {
       clearTimeout(timer);
       clearInterval(heartbeat2);
       clearInterval(cancelPoll);
-      await rm3(runDir, { recursive: true, force: true });
+      await rm4(runDir, { recursive: true, force: true });
     }
   }
   const quickRun2 = QUICK_RUNS[job.skill];
   if (quickRun2) {
     const cwd2 = scratchDir(job.id);
     try {
-      await mkdir4(cwd2, { recursive: true, mode: 448 });
+      await mkdir5(cwd2, { recursive: true, mode: 448 });
       const caps = skill.manifest.capabilities;
       return await quickRun2({
         client: ctx.client,
@@ -10761,13 +10998,22 @@ async function execute(job, skill, ctx, events) {
       clearTimeout(timer);
       clearInterval(heartbeat2);
       clearInterval(cancelPoll);
-      await rm3(runDir, { recursive: true, force: true });
-      await rm3(cwd2, { recursive: true, force: true });
+      await rm4(runDir, { recursive: true, force: true });
+      await rm4(cwd2, { recursive: true, force: true });
     }
   }
-  const capabilities = capCapabilities(skill.manifest.capabilities, autonomy2);
+  const capabilities = capCapabilities(skill.manifest.capabilities, autonomy2, { asked: skill.manifest.asked && job.requested_by === ctx.userId });
   const harnessWeb = await claudeSearches(searchProvider);
-  const cwd = await resolveCwd(ctx, job, params, scratchDir(job.id), capabilities.includes("write_repo"));
+  let cwd = await resolveCwd(ctx, job, params, scratchDir(job.id), capabilities.includes("write_repo"));
+  const prepared = job.skill === BUILD_SKILL ? await prepareBuild(ctx.client, job, cwd, adapter) : null;
+  if (prepared && !prepared.ok) {
+    clearTimeout(timer);
+    clearInterval(heartbeat2);
+    clearInterval(cancelPoll);
+    return prepared.outcome;
+  }
+  const build2 = prepared?.build;
+  if (build2) cwd = build2.dir;
   const definitionsRead = job.skill === "onboard" && !job.resume_of ? readDefinitions({
     adapter,
     spec: { cwd, runDir, systemPrompt: "", prompt: "", capabilities: [], mcp: [], maxTurns: 1, sessionId, env: harnessEnv(timeoutMs), signal: abort.signal },
@@ -10791,29 +11037,6 @@ async function execute(job, skill, ctx, events) {
     const read6 = site.pages.length ? `read ${site.pages.map((p) => new URL(p.url).pathname).join(", ")} on ${site.host}` : `could not read ${site.host}`;
     await logActivity(ctx, job, "scan.site", site.missed.length ? `${read6} (${site.missed.length} not read)` : read6);
   }
-  let item;
-  let session2;
-  if (capabilities.includes("write_repo")) {
-    const solutionId = params.solution_id;
-    if (typeof solutionId !== "string" || !solutionId) {
-      clearTimeout(timer);
-      clearInterval(heartbeat2);
-      clearInterval(cancelPoll);
-      return { status: "failed", error: { code: "harness_error", message: "this job names no solution to build" } };
-    }
-    try {
-      item = await loadAcceptedSolution(ctx.client, job.project_id, solutionId);
-      session2 = await openRepoSession(cwd, item.ref);
-      await startSolution(ctx.client, job.project_id, item.ref, job.id);
-      params.item = renderSolution(item);
-      await logActivity(ctx, job, "repo.branch", `working on ${session2.branch}`);
-    } catch (err) {
-      clearTimeout(timer);
-      clearInterval(heartbeat2);
-      clearInterval(cancelPoll);
-      return { status: "failed", error: { code: "harness_error", message: errorMessage(err) } };
-    }
-  }
   const spec2 = {
     cwd,
     runDir,
@@ -10833,20 +11056,22 @@ async function execute(job, skill, ctx, events) {
     ].filter(Boolean).join("\n\n"),
     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 `remove_files` refuse everywhere else.
+    // what lets the build's tools refuse everywhere else.
     mcp: ctx.mcpServers?.(job, timeoutMs, capabilities.includes("write_repo") ? cwd : void 0) ?? [],
     model: skill.manifest.model,
     maxTurns: skill.manifest.maxTurns,
     sessionId,
     resumeSessionId,
-    env: harnessEnv(timeoutMs),
+    // Print mode kills a background task when the turn ends; a build waits on its commands (§9).
+    env: build2 ? { ...harnessEnv(timeoutMs), CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1" } : harnessEnv(timeoutMs),
     signal: abort.signal
   };
   const verifyCommand2 = project?.preferences?.verify_command?.trim() || null;
   let outcome;
-  let verified;
   let webCalls = 0;
   const onHarnessEvent = async (event) => {
     await events.harness(event);
@@ -10864,6 +11089,24 @@ async function execute(job, skill, ctx, events) {
     return result;
   };
   try {
+    if (build2) {
+      try {
+        return await runBuildJob({
+          client: ctx.client,
+          job,
+          adapter,
+          build: build2,
+          spec: spec2,
+          verifyCommand: verifyCommand2,
+          events,
+          onEvent: onHarnessEvent,
+          log: (step, summary, result) => logActivity(ctx, job, step, summary, result ? { outcome: result } : {})
+        });
+      } catch (error) {
+        if (cancelled) return { status: "cancelled" };
+        return { status: "failed", error: { code: timedOut ? "timeout" : "harness_error", message: errorMessage(error) } };
+      }
+    }
     if (job.skill === "personas") {
       try {
         return await runPersonaJob({ client: ctx.client, job, adapter, spec: spec2, onEvent: onHarnessEvent });
@@ -10944,83 +11187,23 @@ async function execute(job, skill, ctx, events) {
         return { status: "failed", error: { code: timedOut ? "timeout" : "harness_error", message: errorMessage(error) } };
       }
     }
-    for (let attempt7 = 1; attempt7 <= 2; attempt7 += 1) {
-      const attemptSpec = attempt7 === 1 ? spec2 : { ...spec2, prompt: retryPrompt(verified, verifyCommand2), resumeSessionId: sessionId };
-      let attemptOutcome;
-      webCalls = 0;
-      for await (const event of adapter.run(attemptSpec)) {
-        await onHarnessEvent(event);
-        if (event.type === "finished") {
-          attemptOutcome = { status: "succeeded", result: event.result, usage: event.usage };
-        } else if (event.type === "failed") {
-          attemptOutcome = { status: "failed", error: { code: event.code, message: event.message } };
-        }
+    for await (const event of adapter.run(spec2)) {
+      await onHarnessEvent(event);
+      if (event.type === "finished") {
+        outcome = { status: "succeeded", result: event.result, usage: event.usage };
+      } else if (event.type === "failed") {
+        outcome = { status: "failed", error: { code: event.code, message: event.message } };
       }
-      if (attemptOutcome) await noteIfItNeverSearched(attemptOutcome, capabilities.includes("read_web"));
-      outcome = mergeAttempts(outcome, attemptOutcome);
-      if (attemptOutcome?.status !== "succeeded" || !session2 || !verifyCommand2) break;
-      verified = await verify({
-        cwd,
-        command: verifyCommand2,
-        env: harnessEnv(timeoutMs),
-        changed: await changedFiles(cwd),
-        signal: abort.signal
-      });
-      await logActivity(ctx, job, "repo.verify", renderVerifyResult(verified, verifyCommand2), {
-        outcome: verified.passed ? "ok" : "error",
-        usage: { duration_ms: verified.durationMs }
-      });
-      await events.write("text", { text: renderVerifyResult(verified, verifyCommand2) });
-      if (verified.passed || !verified.ran || attempt7 === 2) break;
     }
+    if (outcome) await noteIfItNeverSearched(outcome, capabilities.includes("read_web"));
   } finally {
     clearTimeout(timer);
     clearInterval(heartbeat2);
     clearInterval(cancelPoll);
     await definitionsRead;
-    await rm3(runDir, { recursive: true, force: true });
-  }
-  if (outcome?.status === "succeeded" && verified && verified.ran && !verified.passed) {
-    outcome = {
-      ...outcome,
-      status: "failed",
-      error: {
-        code: "harness_error",
-        message: `${renderVerifyResult(verified, verifyCommand2)}. The work is on the branch; the solution stays accepted.`
-      }
-    };
-  }
-  if (outcome?.status === "succeeded") {
-    if (!session2 || !item) return outcome;
-    try {
-      const repo = await closeRepoSession(cwd, session2, item);
-      await logActivity(ctx, job, "repo.commit", renderRepoResult(repo).split("\n")[0]);
-      if (!repo.commit) {
-        await unstartSolution(ctx.client, job.project_id, item.ref).catch(() => void 0);
-        return {
-          ...outcome,
-          status: "failed",
-          error: { code: "harness_error", message: "the skill finished without changing anything" }
-        };
-      }
-      await finishSolution(ctx.client, job, item, repo);
-      return { ...outcome, result: [outcome.result, "", renderRepoResult(repo)].filter((l) => l !== void 0).join("\n") };
-    } catch (err) {
-      return {
-        ...outcome,
-        status: "failed",
-        error: { code: "harness_error", message: errorMessage(err) }
-      };
-    }
-  }
-  if (session2) {
-    const kept = await abandonRepoSession(cwd, session2, verified?.ran && !verified.passed ? item : void 0).catch(() => void 0);
-    if (item) await unstartSolution(ctx.client, job.project_id, item.ref).catch(() => void 0);
-    if (kept?.commit) {
-      await logActivity(ctx, job, "repo.commit", renderRepoResult(kept).split("\n")[0], { outcome: "error" });
-      if (outcome) outcome = { ...outcome, result: [outcome.result, "", renderRepoResult(kept)].filter(Boolean).join("\n") };
-    }
+    await rm4(runDir, { recursive: true, force: true });
   }
+  if (outcome?.status === "succeeded") return outcome;
   if (cancelled) return { status: "cancelled" };
   if (timedOut) {
     return { status: "failed", error: { code: "timeout", message: `exceeded the ${skill.manifest.timeout} cap` } };
@@ -11031,10 +11214,6 @@ async function sessionOf(client, jobId) {
   const { data } = await client.from("jobs").select("harness_session_id").eq("id", jobId).maybeSingle();
   return data?.harness_session_id ?? void 0;
 }
-function mergeAttempts(first, second) {
-  if (!first?.usage || !second?.usage) return second ?? first;
-  return { ...second, usage: sumUsage(first.usage, second.usage) };
-}
 async function askForTheSite(ctx, job, project, events) {
   const started = Date.now();
   const search = await searchForSite(project.name);
@@ -11060,7 +11239,7 @@ function harnessWebFor(searchProvider, machineCanSearch) {
 }
 async function machineWebSearch() {
   try {
-    const parsed = JSON.parse(await readFile6(join10(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile8(join13(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.webSearch === true;
   } catch {
     return false;
@@ -11102,7 +11281,7 @@ function buildHeader(job, project, cwd, harnessWeb = false, memory = false) {
   return lines.join("\n");
 }
 function scratchDir(jobId) {
-  return join10(tmpdir(), `nanopm-run-${jobId}`);
+  return join13(tmpdir(), `nanopm-run-${jobId}`);
 }
 async function resolveCwd(ctx, job, params, fallback, mustBeTheClone = false) {
   const refuse2 = (why) => {
@@ -11111,12 +11290,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 mkdir4(fallback, { recursive: true, mode: 448 });
+    await mkdir5(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
   if (!job.project_id) {
     if (mustBeTheClone) refuse2("the job belongs to no project");
-    await mkdir4(fallback, { recursive: true, mode: 448 });
+    await mkdir5(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();
@@ -11124,12 +11303,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 mkdir4(fallback, { recursive: true, mode: 448 });
+    await mkdir5(fallback, { recursive: true, mode: 448 });
     return fallback;
   }
-  if (existsSync4(allowed)) return resolve4(allowed);
+  if (existsSync5(allowed)) return resolve4(allowed);
   if (mustBeTheClone) refuse2(`${allowed} is not on this machine any more`);
-  await mkdir4(fallback, { recursive: true, mode: 448 });
+  await mkdir5(fallback, { recursive: true, mode: 448 });
   return fallback;
 }
 function asData8(label, body) {
@@ -11138,10 +11317,10 @@ ${body}
 </${label}>`;
 }
 function harnessEnv(timeoutMs, source = process.env) {
-  const home = source.HOME ?? homedir3();
+  const home = source.HOME ?? homedir4();
   const env = {
     HOME: home,
-    PATH: [source.PATH ?? "/usr/local/bin:/usr/bin:/bin", join10(home, ".local", "bin")].join(":"),
+    PATH: [source.PATH ?? "/usr/local/bin:/usr/bin:/bin", join13(home, ".local", "bin")].join(":"),
     MCP_TOOL_TIMEOUT: String(timeoutMs)
   };
   for (const key of ["USER", "LANG", "TMPDIR", "SHELL", "ANTHROPIC_API_KEY", "CLAUDE_CONFIG_DIR"]) {
@@ -11221,6 +11400,8 @@ async function runDaemon(options = {}) {
   const startedAt = Date.now();
   let lastDeployCheck = 0;
   const DEPLOY_CHECK_MS = 30 * 6e4;
+  const PAUSE_CHECK_MS = 6e4;
+  let lastPauseCheck = 0;
   const UPDATE_CHECK_MS = 60 * 6e4;
   const updatable = !options.once && installKind() === "installer";
   let lastUpdateCheck = Date.now() - UPDATE_CHECK_MS + 5 * 6e4;
@@ -11278,6 +11459,10 @@ async function runDaemon(options = {}) {
         continue;
       }
       if (options.once && Date.now() - startedAt > onceTimeoutMs) break;
+      if (!options.once && Date.now() - lastPauseCheck > PAUSE_CHECK_MS) {
+        lastPauseCheck = Date.now();
+        for (const id of await resumePausedBuilds(auth.client, daemonId).catch(() => [])) log(`build ${id}: the Claude limit reset, carrying on`);
+      }
       if (!options.once && Date.now() - lastDeployCheck > DEPLOY_CHECK_MS) {
         lastDeployCheck = Date.now();
         for (const check of await reviewDeploys(auth.client, daemonId).catch(() => [])) {
@@ -11318,12 +11503,12 @@ async function chainAfter(auth, job, outcome, log) {
   const parent = job.parent_job_id ? await parentOf(auth, job.parent_job_id) : null;
   const own = job.params ?? {};
   const deep = own.depth === "deep" && job.trigger === "hook";
-  const next2 = daemonQueues(job.skill, 0, parent?.skill ?? null, deep);
-  if (!next2.length) return;
+  const next = daemonQueues(job.skill, 0, parent?.skill ?? null, deep);
+  if (!next.length) return;
   if (await chainDepth(auth, job) >= CHAIN_DEPTH_MAX) return;
   const from = deep ? own.repo_path : parent?.params?.repo_path;
   const repo = typeof from === "string" ? { repo_path: from } : null;
-  for (const skill of next2) {
+  for (const skill of next) {
     const params = { ...repo ?? {}, ...deep ? { depth: "deep", background: true } : {} };
     const { data, error } = await auth.client.from("jobs").insert({
       project_id: job.project_id,
@@ -11406,7 +11591,7 @@ var heldInThisProcess = false;
 function acquireLock() {
   if (heldInThisProcess) throw new Error("a nanopm daemon is already running in this process");
   mkdirSync(nanopmHome(), { recursive: true, mode: 448 });
-  const path = join11(nanopmHome(), "daemon.pid");
+  const path = join14(nanopmHome(), "daemon.pid");
   for (; ; ) {
     try {
       const fd = openSync(path, "wx");
@@ -11478,10 +11663,11 @@ async function claimNext(client, daemonId, skills) {
   return rows2[0] ?? null;
 }
 async function reclaimOwnJobs(client, daemonId) {
-  const { data: stale } = await client.from("jobs").select("id, project_id, skill").eq("assigned_daemon_id", daemonId).in("status", ["running", "waiting"]);
+  const { data: stale } = await client.from("jobs").select("id, project_id, skill, status, attempt, params").eq("assigned_daemon_id", daemonId).in("status", ["running", "waiting"]);
   const ids = [];
   for (const job of stale ?? []) {
     await killOrphanedHarness(job.id);
+    if (job.skill === BUILD_SKILL && (job.status === "waiting" || await requeueLostBuild(client, job))) continue;
     const error = { code: "interrupted", message: "the daemon stopped while this job was running" };
     await client.from("jobs").update({ status: "failed", finished_at: (/* @__PURE__ */ new Date()).toISOString(), error }).eq("id", job.id).in("status", ["running", "waiting"]);
     await client.from("job_events").insert({ job_id: job.id, seq: 0, kind: "status", payload: { status: "failed", error }, author_kind: "nanopm" });
@@ -11493,13 +11679,13 @@ async function reclaimOwnJobs(client, daemonId) {
 async function harnessPids(runDir) {
   const dirs = [runDir];
   try {
-    for (const d of await readdir2(runDir, { withFileTypes: true })) if (d.isDirectory()) dirs.push(join11(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 readFile7(join11(dir, "harness.pid"), "utf8")).trim());
+      const pid = Number((await readFile9(join14(dir, "harness.pid"), "utf8")).trim());
       if (pid > 1) pids.push(pid);
     } catch {
     }
@@ -11507,20 +11693,20 @@ async function harnessPids(runDir) {
   return pids;
 }
 async function killOrphanedHarness(jobId) {
-  const runDir = join11(nanopmHome(), "run", jobId);
+  const runDir = join14(nanopmHome(), "run", jobId);
   for (const pid of await harnessPids(runDir)) {
     try {
       process.kill(pid, "SIGTERM");
     } catch {
     }
   }
-  await rm4(runDir, { recursive: true, force: true });
+  await rm5(runDir, { recursive: true, force: true });
 }
 async function registerDaemon(auth, version, opts = {}) {
-  const path = join11(nanopmHome(), "daemon.json");
+  const path = join14(nanopmHome(), "daemon.json");
   let identity = null;
   try {
-    identity = JSON.parse(await readFile7(path, "utf8"));
+    identity = JSON.parse(await readFile9(path, "utf8"));
   } catch {
     identity = null;
   }
@@ -11558,8 +11744,8 @@ async function registerDaemon(auth, version, opts = {}) {
   return data.id;
 }
 async function rememberDaemon(id, shared = false) {
-  await mkdir5(nanopmHome(), { recursive: true, mode: 448 });
-  await writeFile4(join11(nanopmHome(), "daemon.json"), JSON.stringify({ id, shared }, null, 2) + "\n", { mode: 384 });
+  await mkdir6(nanopmHome(), { recursive: true, mode: 448 });
+  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);
@@ -11613,13 +11799,15 @@ function contextFromEnv(env = process.env) {
     userId: env.NANOPM_USER_ID,
     actor: env.NANOPM_ACTOR,
     askTimeoutMs: Number(env.NANOPM_ASK_TIMEOUT_MS ?? 3 * 60 * 60 * 1e3),
-    workspace: env.NANOPM_WORKSPACE || void 0
+    workspace: env.NANOPM_WORKSPACE || void 0,
+    answerFile: env.NANOPM_ANSWER_FILE || void 0
   };
 }
 
 // ../memory-mcp/src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { randomUUID as randomUUID13 } from "crypto";
+import { readFile as readFile10, unlink } from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
 import { z as z21 } from "zod";
 
@@ -11910,48 +12098,6 @@ function refuseFetch(url, allowlist, open = false) {
   return `${host} is not on this project's allowlist, so it was not read. The founder can allow it: if it is a competitor, \`nanopm market confirm <ref>\` on the entry that names them, or \`nanopm market add <name> ${host}\`. Until then, search results and the sites already allowed are what there is.`;
 }
 
-// ../memory-mcp/src/repo-rules.ts
-import { lstat, unlink } from "fs/promises";
-import { relative as relative3, resolve as resolve5, sep as sep2 } from "path";
-var REMOVE_MAX = 50;
-function refuseRemove(workspace, requested) {
-  const root2 = resolve5(workspace);
-  const target = resolve5(root2, requested);
-  const rel = relative3(root2, target);
-  if (!rel || rel.startsWith("..") || rel.startsWith(`..${sep2}`)) return "outside the workspace";
-  if (rel === ".git" || rel.startsWith(`.git${sep2}`)) return "inside .git";
-  if (looksLikeASecret(rel)) return "looks like a secret, which the agent may neither read nor remove";
-  return null;
-}
-async function removeFiles(workspace, paths) {
-  const out = [];
-  for (const requested of paths.slice(0, REMOVE_MAX)) {
-    const refusal = refuseRemove(workspace, requested);
-    if (refusal) {
-      out.push({ path: requested, removed: false, reason: refusal });
-      continue;
-    }
-    const target = resolve5(workspace, requested);
-    try {
-      const stat2 = await lstat(target);
-      if (stat2.isSymbolicLink()) {
-        out.push({ path: requested, removed: false, reason: "a symlink; what it points at is not touched" });
-        continue;
-      }
-      if (stat2.isDirectory()) {
-        out.push({ path: requested, removed: false, reason: "a directory; name the files in it" });
-        continue;
-      }
-      await unlink(target);
-      out.push({ path: requested, removed: true });
-    } catch (err) {
-      const code = err.code;
-      out.push({ path: requested, removed: false, reason: code === "ENOENT" ? "not there" : err instanceof Error ? err.message : String(err) });
-    }
-  }
-  return out;
-}
-
 // ../memory-mcp/src/problem-rules.ts
 import { z as z20 } from "zod";
 var STATEMENT_MAX = 300;
@@ -12187,6 +12333,8 @@ ${renderMap()}`,
       }
     },
     async ({ question, options, why }, extra) => {
+      const handed = ctx.answerFile ? await takeAnswer(ctx.answerFile) : null;
+      if (handed !== null) return json({ answer: handed, skipped: false });
       const answer = await askUser(ctx, { question, options, why }, extra.signal);
       if (answer === null) return failure("No answer arrived in time, or the job was cancelled. Do not ask again; continue with what you have.");
       return json({ answer, skipped: /^\s*(skip|passe?r?)\s*$/i.test(answer) || answer.trim() === "" });
@@ -12326,7 +12474,7 @@ ${renderMap()}`,
       }
     },
     async ({ ref, outcome, note }) => {
-      return json(await finishSolution2(ctx, ref, outcome, note));
+      return json(await finishSolution(ctx, ref, outcome, note));
     }
   );
   server.registerTool(
@@ -12426,20 +12574,20 @@ ${renderMap()}`,
     }
   );
   server.registerTool(
-    "remove_files",
+    "build_plan",
     {
-      description: "Delete files in the repository you are working in. Paths relative to the repository root, at most 50. Refused: anything outside the repository, inside .git, a symlink, a directory, or a file that looks like a secret. A file you mean to delete should be deleted with this, not emptied or replaced with a note \u2014 a stub is not a deletion.",
-      inputSchema: { paths: z21.array(z21.string().min(1).max(500)).min(1).max(REMOVE_MAX) }
+      description: `Say the plan before you change anything: ${BUILD_STEPS_MIN} to ${BUILD_STEPS_MAX} steps, in order, each one change the founder can recognise, in their words (at most ${BUILD_STEP_MAX} characters). The last step is your own check of the whole change. Call it once; the founder sees it as a checklist.`,
+      inputSchema: { steps: z21.array(z21.string().min(3).max(BUILD_STEP_MAX)).min(BUILD_STEPS_MIN).max(BUILD_STEPS_MAX) }
     },
-    async ({ paths }) => {
-      if (!ctx.workspace) return failure("this job has no repository to remove files from");
-      const outcomes = await removeFiles(ctx.workspace, paths);
-      const removed = outcomes.filter((o) => o.removed).map((o) => o.path);
-      await logActivity2(ctx, "repo.remove", `removed ${removed.length} of ${paths.length} files${removed.length ? `: ${trim2(removed.join(", "), 200)}` : ""}`, {
-        outcome: removed.length === paths.length ? "ok" : "error"
-      });
-      return json({ outcomes, note: removed.length ? "Removed. The commit at the end of this job will record the deletions." : "Nothing was removed." });
-    }
+    async ({ steps }) => ctx.workspace ? json({ recorded: steps.length, note: "Recorded. Build step 1 now; call build_step when it is done." }) : failure("this job builds nothing")
+  );
+  server.registerTool(
+    "build_step",
+    {
+      description: "A step of your plan is done and its checks pass: NanoPM commits the worktree now, with the step as the message, and ticks it for the founder. Call it once per step, in order, after the step works. Do not run git commit yourself.",
+      inputSchema: { step: z21.number().int().min(1).max(BUILD_STEPS_MAX), summary: z21.string().min(3).max(300) }
+    },
+    async ({ step }) => ctx.workspace ? json({ step, note: "Committed by NanoPM. Go on with the next step, or stop when the plan is done." }) : failure("this job builds nothing")
   );
   server.registerTool(
     "web_search",
@@ -12751,6 +12899,12 @@ async function writeContext(ctx, items, refused = []) {
   await logActivity2(ctx, "memory.write", `wrote ${written.length} items under ${topics}: ${written.map((w) => w.key).join(", ")}${refusedNote}`);
   return { written };
 }
+async function takeAnswer(answerFile) {
+  const taken = `${answerFile}.taken`;
+  const answer = await readFile10(taken, "utf8").catch(() => null);
+  if (answer !== null) await unlink(taken).catch(() => void 0);
+  return answer;
+}
 async function askUser(ctx, q, signal) {
   const seq = await nextSeq(ctx);
   const { error } = await ctx.client.from("job_events").insert({ job_id: ctx.jobId, seq, kind: "question", payload: { question: q.question, options: q.options ?? null, why: q.why ?? null }, author_kind: "nanopm" });
@@ -13226,7 +13380,7 @@ async function markFast(ctx, problemRef) {
   await logActivity2(ctx, "problems.fast", `${problem.ref} is one small change`);
   return { problem: problem.ref, fast: true };
 }
-async function finishSolution2(ctx, ref, outcome, note) {
+async function finishSolution(ctx, ref, outcome, note) {
   if (ctx.actor === "mapping-review") throw new Error("A targeted collection cannot decide solution outcomes.");
   const upper = ref.toUpperCase();
   const { data: current } = await ctx.client.from("solutions").select("status").eq("project_id", ctx.projectId).eq("ref", upper).is("superseded_by", null).maybeSingle();
@@ -13524,7 +13678,8 @@ var MEMORY_TOOL_NAMES = [
   "play_store_search",
   "list_market",
   "write_market",
-  "remove_files",
+  "build_plan",
+  "build_step",
   // Talk to Nano (docs/✅nanopm-68-talk-to-nano.md): the map read, and changed as the founder asked.
   ...TALK_TOOLS
 ];
@@ -13535,19 +13690,19 @@ async function startMemoryServer(env = process.env) {
 }
 
 // src/commands/add.ts
-import { readFile as readFile9 } 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 readFile8 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join15 } from "path";
 async function localDaemonId() {
   try {
-    const parsed = JSON.parse(await readFile8(join12(nanopmHome(), "daemon.json"), "utf8"));
+    const parsed = JSON.parse(await readFile11(join15(nanopmHome(), "daemon.json"), "utf8"));
     return parsed.id ?? null;
   } catch {
     return null;
@@ -13572,7 +13727,7 @@ async function detectRepo(cwd) {
   } catch {
     remote = null;
   }
-  const name = remote ? remote.split("/").pop() : basename(root2);
+  const name = remote ? remote.split("/").pop() : basename2(root2);
   return { root: root2, remote, name, empty: await repoIsEmpty(root2) };
 }
 async function repoIsEmpty(root2) {
@@ -13583,7 +13738,7 @@ async function repoIsEmpty(root2) {
   }
   const files = (await execFileAsync7("git", ["-C", root2, "ls-files"])).stdout.split("\n").filter(Boolean);
   return files.every((f) => {
-    const base = basename(f);
+    const base = basename2(f);
     return base.startsWith(".") || /^(readme|licen[cs]e)(\.|$)/i.test(base);
   });
 }
@@ -13682,7 +13837,7 @@ async function add(file, opts) {
     text2 = await readStdin();
   } else {
     try {
-      text2 = await readFile9(file, "utf8");
+      text2 = await readFile12(file, "utf8");
     } catch {
       throw new Error(`could not read ${file}`);
     }
@@ -13697,7 +13852,7 @@ async function add(file, opts) {
 }
 
 // src/commands/run.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
 import { setTimeout as sleep3 } from "timers/promises";
 
@@ -13864,7 +14019,7 @@ function phaseOf(tool) {
   if (name === "query") return "data";
   if (name === "web_search" || name === "web_fetch") return "web";
   if (REVIEW_WRITES.has(name)) return "review";
-  if (name === "remove_files") return "build";
+  if (name === "build_plan" || name === "build_step") return "build";
   return null;
 }
 function touched(tool, input) {
@@ -14029,7 +14184,7 @@ function questionBlock(p) {
 
 // src/commands/run.ts
 async function answersFromFile(path) {
-  const raw = JSON.parse(await readFile10(path, "utf8"));
+  const raw = JSON.parse(await readFile13(path, "utf8"));
   const entries = raw.map((a) => typeof a === "string" ? { answer: a } : a);
   return scriptedAnswerer(entries);
 }
@@ -14113,6 +14268,7 @@ async function streamJob(client, jobId, opts) {
   const shownAnswers = /* @__PURE__ */ new Set();
   for (; ; ) {
     const { data: events } = await client.from("job_events").select("id, seq, kind, payload, author_kind").eq("job_id", jobId).gt("id", lastId).order("id", { ascending: true });
+    for (const ev of events ?? []) if (ev.kind === "answer") answered.add(ev.seq);
     for (const ev of events ?? []) {
       lastId = Math.max(lastId, Number(ev.id));
       const payload = ev.payload ?? {};
@@ -14251,16 +14407,16 @@ async function askOne(auth, projectId, question, daemonId, opts, out) {
 
 // src/commands/daemon-service.ts
 import { execFile as execFile8 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir6, readFile as readFile11, rm as rm5, writeFile as writeFile5 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join13 } from "path";
+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 join16 } from "path";
 import { promisify as promisify8 } from "util";
 
 // package.json
 var package_default = {
   name: "@nanopm/cli",
-  version: "0.1.10",
+  version: "0.1.12",
   description: "An autonomous product manager for builders who run several small products. Runs on your machine, drives your own coding harness.",
   type: "module",
   license: "MIT",
@@ -14312,10 +14468,10 @@ var VERSION = package_default.version;
 var execFileAsync8 = promisify8(execFile8);
 var LAUNCHD_LABEL = "pm.nano.daemon";
 function plistPath() {
-  return join13(homedir4(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return join16(homedir5(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function daemonLogPath() {
-  return join13(nanopmHome(), "daemon.log");
+  return join16(nanopmHome(), "daemon.log");
 }
 function renderPlist(opts) {
   const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -14374,13 +14530,13 @@ async function installDaemon(out = (l) => console.log(l), opts = {}) {
   out(web.ok ? "Claude's own search answers; searches go through your subscription." : `Claude's search is not available on this machine (${web.message}); searches use DuckDuckGo.`);
   const bin = process.argv[1];
   if (!bin) throw new Error("cannot locate the nanopm binary");
-  const home = homedir4();
-  const path = [process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", join13(home, ".local", "bin")].join(":");
-  await mkdir6(join13(home, "Library", "LaunchAgents"), { recursive: true });
-  await mkdir6(nanopmHome(), { recursive: true, mode: 448 });
+  const home = homedir5();
+  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 });
-  await writeFile5(plistPath(), renderPlist({ node: process.execPath, bin, home, path, logPath: daemonLogPath(), nanopmHome: nanopmHome() }), { mode: 420 });
+  await writeFile7(plistPath(), renderPlist({ node: process.execPath, bin, home, path, logPath: daemonLogPath(), nanopmHome: nanopmHome() }), { mode: 420 });
   const target = guiTarget();
   await execFileAsync8("launchctl", ["bootout", target, plistPath()]).catch(() => void 0);
   await execFileAsync8("launchctl", ["bootstrap", target, plistPath()]);
@@ -14393,7 +14549,7 @@ function guiTarget() {
   return `gui/${process.getuid?.() ?? 501}`;
 }
 async function restartDaemon() {
-  if (!existsSync5(plistPath())) return false;
+  if (!existsSync6(plistPath())) return false;
   await execFileAsync8("launchctl", ["kickstart", "-k", `${guiTarget()}/${LAUNCHD_LABEL}`]);
   return true;
 }
@@ -14401,12 +14557,12 @@ async function uninstallDaemon(out = (l) => console.log(l)) {
   requireMac();
   const target = guiTarget();
   await execFileAsync8("launchctl", ["bootout", target, plistPath()]).catch(() => void 0);
-  await rm5(plistPath(), { force: true });
+  await rm6(plistPath(), { force: true });
   out(`Removed ${LAUNCHD_LABEL}.`);
 }
 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");
@@ -14428,7 +14584,7 @@ async function daemonStatus(out = (l) => console.log(l)) {
 }
 async function daemonLogs(lines = 50) {
   try {
-    const text2 = await readFile11(daemonLogPath(), "utf8");
+    const text2 = await readFile14(daemonLogPath(), "utf8");
     return text2.trimEnd().split("\n").slice(-lines).join("\n");
   } catch {
     return `no log at ${daemonLogPath()} yet`;
@@ -14436,41 +14592,41 @@ async function daemonLogs(lines = 50) {
 }
 async function localWebSearch() {
   try {
-    const parsed = JSON.parse(await readFile11(join13(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 = join13(nanopmHome(), "daemon.json");
+  const path = join16(nanopmHome(), "daemon.json");
   let parsed = {};
   try {
-    parsed = JSON.parse(await readFile11(path, "utf8"));
+    parsed = JSON.parse(await readFile14(path, "utf8"));
   } catch {
     parsed = {};
   }
-  await mkdir6(nanopmHome(), { recursive: true, mode: 448 });
-  await writeFile5(path, JSON.stringify({ ...parsed, webSearch: webSearch2 }, null, 2) + "\n", { mode: 384 });
+  await mkdir7(nanopmHome(), { recursive: true, mode: 448 });
+  await writeFile7(path, JSON.stringify({ ...parsed, webSearch: webSearch2 }, null, 2) + "\n", { mode: 384 });
 }
 async function localShared() {
   try {
-    const parsed = JSON.parse(await readFile11(join13(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 = join13(nanopmHome(), "daemon.json");
+  const path = join16(nanopmHome(), "daemon.json");
   let parsed = {};
   try {
-    parsed = JSON.parse(await readFile11(path, "utf8"));
+    parsed = JSON.parse(await readFile14(path, "utf8"));
   } catch {
     parsed = {};
   }
-  await mkdir6(nanopmHome(), { recursive: true, mode: 448 });
-  await writeFile5(path, JSON.stringify({ ...parsed, shared }, null, 2) + "\n", { mode: 384 });
+  await mkdir7(nanopmHome(), { recursive: true, mode: 448 });
+  await writeFile7(path, JSON.stringify({ ...parsed, shared }, null, 2) + "\n", { mode: 384 });
 }
 
 // src/format/log.ts
@@ -14713,702 +14869,772 @@ The install line does the same: curl -fsSL https://nanopm.app/install | sh`);
   out(await restartDaemon() ? `Updated ${VERSION} \u2192 ${latest}; the daemon restarted on it.` : `Updated ${VERSION} \u2192 ${latest}.`);
 }
 
-// src/format/roadmap.ts
-var SHAPE = {
-  proposed: { mark: "\u25CB", colour: ANSI.amber, label: "proposed" },
-  accepted: { mark: "\u25D0", colour: ANSI.green, label: "accepted" },
-  building: { mark: "\u25D4", colour: ANSI.blue, label: "building" },
-  rejected: { mark: "\u2298", colour: ANSI.red, label: "rejected" },
-  done: { mark: "\u25CF", colour: ANSI.green, label: "done" },
-  dropped: { mark: "\u2298", colour: ANSI.dim, label: "dropped" }
+// src/commands/autonomy.ts
+async function readAutonomy(client, projectId) {
+  const { data } = await client.from("project_preferences").select("autonomy").eq("project_id", projectId).maybeSingle();
+  return data?.autonomy ?? "propose";
+}
+var EXPLAINED = {
+  propose: "NanoPM reads and proposes. It never changes a file.",
+  execute_after_validation: "NanoPM changes files, on its own branch, after showing you what it will do and waiting for a yes.",
+  execute_then_report: "NanoPM acts first and tells you after. Not available yet."
 };
-var WORK_KINDS = /* @__PURE__ */ new Set(["branch", "git", "url", "job"]);
-function renderRoadmapItem(item, opts, problem, builtBy) {
-  const paint = painter(opts.color);
-  const shape2 = SHAPE[item.status] ?? { mark: "\xB7", colour: "", label: item.status };
-  const out = [`${paint(shape2.colour, shape2.mark)} ${paint(ANSI.bold, item.ref)}  ${item.title}`];
-  if (problem) out.push(paint(ANSI.dim, `  answers ${problem.ref}  ${clip(problem.statement, Math.max(30, columns() - 20))}`));
-  out.push("");
-  for (const line of wrap(item.reasoning, Math.max(40, columns() - 4))) out.push(`  ${line}`);
-  out.push("");
-  const facts = [
-    ["status", shape2.label + (item.outcome ? ` \xB7 ${item.outcome}${item.outcome_note ? `: ${item.outcome_note}` : ""}` : "")],
-    ["rank", String(item.rank)],
-    ["who", item.actor === "founder" ? "you" : "NanoPM"],
-    ["bets on", item.assumption ?? "\u2014"],
-    ["we'll know", item.eval ?? "\u2014"]
-  ];
-  for (const [k, v] of facts) out.push(paint(ANSI.dim, `  ${k.padEnd(9)} ${v}`));
-  const sources2 = item.sources ?? [];
-  const restsOn = sources2.filter((s) => !WORK_KINDS.has(s.kind));
-  if (restsOn.length) {
-    out.push(paint(ANSI.dim, `  ${"rests on".padEnd(9)} ${restsOn.map((s) => `${s.kind}:${s.ref}`).join(", ")}`));
+async function autonomy(level, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const current = await readAutonomy(auth.client, project.id);
+  if (!level) {
+    const lines = [`${project.name} is on "${current}".`, ""];
+    for (const l of AUTONOMY_LEVELS) {
+      lines.push(`  ${l === current ? "\u25CF" : "\u25CB"} ${l.padEnd(26)} ${EXPLAINED[l]}`);
+    }
+    lines.push("", "  nanopm autonomy <level>");
+    return lines.join("\n");
   }
-  const where = renderWhere(sources2);
-  if (where) out.push(paint(ANSI.dim, `  ${"where".padEnd(9)} ${where}${builtBy ? ` \xB7 built by ${builtBy}` : ""}`));
-  return out.join("\n");
-}
-function renderWhere(sources2) {
-  const branch = sources2.find((s) => s.kind === "branch")?.ref;
-  const commit = sources2.find((s) => s.kind === "git")?.ref;
-  const url = sources2.find((s) => s.kind === "url")?.ref;
-  return [branch, commit, url].filter(Boolean).join(" \xB7 ");
+  const wanted = level.trim();
+  if (!AUTONOMY_LEVELS.includes(wanted)) {
+    throw new Error(`"${level}" is not a level. Pick one of: ${AUTONOMY_LEVELS.join(", ")}.`);
+  }
+  if (wanted === "execute_then_report") {
+    throw new Error(
+      "execute_then_report is not available yet. NanoPM asks before it changes anything until the review loop has been used in anger."
+    );
+  }
+  if (wanted === current) return `${project.name} is already on "${current}".`;
+  const { error } = await auth.client.from("project_preferences").update({ autonomy: wanted }).eq("project_id", project.id);
+  if (error) {
+    throw new Error(`could not change the dial: ${error.message}`);
+  }
+  return [`${project.name} is now on "${wanted}".`, EXPLAINED[wanted]].join("\n");
 }
-var VERB = {
-  want: { text: "wanted", colour: ANSI.amber },
-  confirm: { text: "confirmed", colour: ANSI.green },
-  drop: { text: "dropped", colour: ANSI.red },
-  merge: { text: "merged into", colour: ANSI.blue },
-  separate: { text: "kept apart", colour: ANSI.blue },
-  weight: { text: "weighed", colour: ANSI.blue },
-  area: { text: "filed", colour: ANSI.blue },
-  accept: { text: "accepted", colour: ANSI.green },
-  reject: { text: "rejected", colour: ANSI.red },
-  first: { text: "put first", colour: ANSI.blue },
-  done: { text: "did", colour: ANSI.green },
-  dismiss: { text: "dismissed", colour: ANSI.red }
-};
-function renderDecisions(rows2, opts) {
-  const paint = painter(opts.color);
-  if (!rows2.length) return "No decisions yet.";
-  const out = [];
-  for (const row of rows2) {
-    const when = row.created_at.slice(0, 10);
-    const verb = VERB[row.kind] ?? { text: row.kind, colour: ANSI.blue };
-    const about = row.solutions ? `${paint(ANSI.dim, row.solutions.ref)} ${row.solutions.title}` : row.problems ? paint(ANSI.dim, row.problems.ref) : row.market_entries ? `${paint(ANSI.dim, row.market_entries.ref)} ${row.market_entries.competitor ?? ""}`.trimEnd() : "";
-    const by = row.by ? paint(ANSI.dim, ` \xB7 by ${row.by}`) : "";
-    out.push(`${paint(ANSI.dim, when)}  ${paint(verb.colour, verb.text)} ${about}${by}`.trimEnd());
-    if (row.body) {
-      for (const line of wrap(row.body, 72)) out.push(paint(ANSI.dim, `              ${line}`));
+async function verifyCommand(command, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const { data } = await auth.client.from("project_preferences").select("verify_command").eq("project_id", project.id).maybeSingle();
+  const current = data?.verify_command ?? null;
+  if (!command && !opts.clear) {
+    if (!current) {
+      return [
+        `${project.name} has no check, so nothing verifies what NanoPM writes.`,
+        "",
+        '  nanopm verify "npm run lint && npm test"',
+        "",
+        "A build runs it in its sandboxed copy of the repository before its last step,",
+        "fixes what it reports, and says the result in the pull request."
+      ].join("\n");
     }
+    return [`${project.name} verifies with:`, "", `  ${current}`, "", '  nanopm verify "<command>" \xB7 nanopm verify --clear'].join("\n");
   }
-  return out.join("\n");
-}
-var HUE = ["\x1B[34m", "\x1B[35m", "\x1B[36m", "\x1B[32m", "\x1B[95m"];
-function themesOf(tree) {
-  return new Map(tree.map((b) => [b.id, { name: themeName(b), colour: HUE[themeHue(tree, b) - 1] }]));
-}
-function sizeWord(size, paint) {
-  return size === "big" ? `${paint(ANSI.bold, "\u25AA")} ${SIZE_WORD.big}` : size === "small" ? paint(ANSI.dim, SIZE_WORD.small) : "";
+  const next = opts.clear ? null : command.trim();
+  if (next !== null && !next) throw new Error('a check needs a command: nanopm verify "npm test"');
+  const { error } = await auth.client.from("project_preferences").update({ verify_command: next }).eq("project_id", project.id);
+  if (error) throw new Error(`could not save the check: ${error.message}`);
+  if (next === null) return `${project.name} no longer runs a check. Nothing will verify what NanoPM writes.`;
+  return [`${project.name} will verify with:`, "", `  ${next}`, "", "A build runs it in its sandboxed copy of the repository before its last step."].join("\n");
 }
-function renderSolutionsBoard(board, opts) {
+
+// 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);
   const width = Math.max(40, columns());
-  const themes = themesOf(board.tree);
-  const out = [`${paint(ANSI.bold, "Roadmap")}${board.objective ? `  ${paint(ANSI.dim, `${board.objective.lever} \u2014 ${board.objective.sentence}`)}` : ""}`];
-  const chips = board.tree.flatMap((b) => {
-    const n = board.cards.filter((c) => c.branch.id === b.id).length;
-    const t = themes.get(b.id);
-    return n ? [`${paint(t.colour, "\u25CF")} ${t.name} ${paint(ANSI.dim, String(n))}`] : [];
-  });
-  const legend = chips.reduce((lines, chip) => {
-    const last = lines.at(-1);
-    if (last !== void 0 && visibleLength(last) + 3 + visibleLength(chip) <= width) lines[lines.length - 1] = `${last}   ${chip}`;
-    else lines.push(chip);
-    return lines;
-  }, []);
-  out.push("", ...legend);
-  if (!board.cards.some((c) => c.pick.placed_by === "founder")) out.push(paint(ANSI.dim, "Nano placed these in the order of your opportunity map. Move them where you want them."));
-  const refWidth = Math.max(5, ...board.cards.map((c) => c.pick.ref.length));
-  const gutter = " ".repeat(refWidth + 4);
-  const titleWidth = Math.min(Math.max(...board.cards.map((c) => c.pick.title.length)), width - gutter.length - 8);
-  for (const h of HORIZONS) {
-    const column = board.cards.filter((c) => c.horizon === h);
-    out.push("", `${paint(ANSI.bold, HORIZON_WORD[h])}  ${paint(ANSI.dim, String(column.length))}`);
-    if (!column.length) out.push(paint(ANSI.dim, `  Move a card here: nanopm roadmap move <ref> ${h}`));
-    for (const c of column) {
-      const t = themes.get(c.branch.id);
-      out.push(`  ${paint(ANSI.dim, c.pick.ref.padEnd(refWidth))}  ${paint(t.colour, "\u25CF")} ${paint(ANSI.dim, t.name)}`);
-      out.push(`${gutter}${clip(c.pick.title, titleWidth).padEnd(titleWidth)}  ${sizeWord(c.pick.size, paint)}`.trimEnd());
-      const depth = board.working.get(c.leaf.id);
-      if (depth) out.push(`${gutter}${paint(ANSI.blue, "\u25CF")} ${paint(ANSI.dim, WORK_WORD[depth])}`);
-    }
+  const out = [];
+  if (!lens) return "No objective yet: the map is drawn for it. Say what matters most right now on Your business, then `nanopm opportunities run`.";
+  out.push(`${paint(ANSI.bold, "Opportunities")}  ${paint(ANSI.dim, `${lens.lever} \u2014 ${lens.sentence}`)}`);
+  out.push(paint(ANSI.dim, lens.definition ? `Counts: ${lens.definition}` : "What it counts is not defined yet: drawn against the lever and your sentence."));
+  if (opts.previous) out.push(paint(ANSI.amber, "Drawn for your previous objective. `nanopm opportunities run` draws it for this one."));
+  if (!rows2.length) {
+    out.push("", "No map yet. `nanopm opportunities run` draws it from what NanoPM knows; add --deep to check it against your users, code and data.");
+    return out.join("\n");
   }
-  if (board.earlier) out.push("", paint(ANSI.bold, "On the problem list"), "", board.earlier);
-  out.push(
-    "",
-    paint(ANSI.dim, 'nanopm roadmap <ref> \xB7 nanopm roadmap move <ref> now|next|later [position] \xB7 nanopm reject <ref> ["why"]'),
-    paint(ANSI.dim, "nanopm opportunities brainstorm <ref> [--deep]: solutions to another problem, or deeper ones")
-  );
+  const tree = liveTree(rows2);
+  const live = rows2.filter(isLive);
+  const evidenced = live.filter((r) => r.evidence_status === "evidence_backed").length;
+  out.push(paint(ANSI.dim, `${live.length} on the map: ${evidenced} evidence-backed, ${live.length - evidenced} hypotheses \u2014 what users or their behaviour have not shown yet.`));
+  const who = (r) => r.personas.map((p) => opts.names?.get(p) ?? p).join(", ");
+  const one = (r, place) => {
+    const indent = "  ".repeat(r.depth - 1);
+    const yours = r.status === "confirmed" ? paint(ANSI.green, " yours") : "";
+    out.push("", `${indent}${paint(ANSI.bold, place.padStart(2))}  ${r.depth === 1 ? paint(ANSI.bold, r.problem) : r.problem}${yours}  ${paint(ANSI.dim, r.ref)}`);
+    const pad = `${indent}    `;
+    const facts = [PRIORITY_WORD[r.priority], EVIDENCE_STATUS_WORD[r.evidence_status], NEXT_ACTION_WORD[r.next_action], who(r)].filter(Boolean).join(" \xB7 ");
+    out.push(`${pad}${paint(ANSI.dim, facts)}`);
+    const gist = r.description ? paragraphs(r.description)[0] : null;
+    if (gist) for (const l of wrap(gist, width - pad.length)) out.push(`${pad}${l}`);
+    if (r.learn) for (const l of wrap(`To learn more: ${r.learn}`, width - pad.length)) out.push(`${pad}${paint(ANSI.dim, l)}`);
+    if (r.founder_rank !== null && r.now_rank) out.push(`${pad}${paint(ANSI.dim, `Its place is yours; NanoPM would now put it at #${r.now_rank}.`)}`);
+    if (r.reconsider) for (const l of wrap(`Worth reconsidering: ${r.reconsider}`, width - pad.length)) out.push(`${pad}${paint(ANSI.amber, l)}`);
+    for (const c of r.children) one(c, `${place}.${c.rank}`);
+  };
+  for (const r of tree) one(r, String(r.rank));
+  const aside = rows2.filter((r) => r.status === "set_aside");
+  if (aside.length) {
+    out.push("", paint(ANSI.bold, `Set aside (${aside.length})`));
+    for (const r of aside) out.push(`  ${paint(ANSI.dim, r.ref.padEnd(8))} ${r.problem}${r.set_aside_reason ? paint(ANSI.dim, ` \u2014 ${r.set_aside_reason}`) : ""}`);
+  }
+  out.push("", paint(ANSI.dim, '`nanopm opportunities confirm <ref>`, `set-aside <ref> "why"`, `move <ref> <place>`, `reword <ref> "\u2026"`, `brainstorm <ref> [--deep]`, `run [--deep] [--note "\u2026"] [--use signals,data,repo,market] [--skip \u2026]`.'));
   return out.join("\n");
 }
-function renderSolutionSheet(s, at, opts) {
+
+// src/format/needs.ts
+var MARK = { observed: "\u25CF", stated: "\u2013", inferred: "\u25CB" };
+function renderNeeds(persona, tree, opts) {
   const paint = painter(opts.color);
   const width = Math.max(40, columns());
-  const theme = at.branch ? themesOf(at.tree).get(at.branch.id) : void 0;
   const out = [];
-  if (theme) out.push(`${paint(theme.colour, "\u25CF")} ${paint(ANSI.dim, theme.name)}`);
-  const size = sizeWord(s.size, paint);
-  out.push(`${paint(ANSI.dim, s.ref)}  ${paint(ANSI.bold, s.title)}${size ? `  ${size}` : ""}`);
-  const pad = " ".repeat(12);
-  const heading = (text2) => out.push("", `  ${paint(ANSI.bold, text2)}`);
-  heading("Problem we are solving");
-  if (at.leaf) {
-    const solves = wrap(at.leaf.problem, width - 6 - at.leaf.ref.length - 2);
-    solves[solves.length - 1] += `  ${paint(ANSI.dim, at.leaf.ref)}`;
-    for (const line of solves) out.push(`    ${line}`);
-    if (at.branch && at.branch.id !== at.leaf.id) {
-      for (const line of wrap(`Part of: ${at.branch.problem} ${at.branch.ref}`, width - 6)) out.push(`    ${paint(ANSI.dim, line)}`);
-    }
-  } else {
-    out.push(paint(ANSI.dim, "    The problem it answered is no longer on the map."));
-  }
-  const described = paragraphs(s.description);
-  if (described.length) {
-    heading("Proposed solution");
-    described.forEach((p, i) => {
-      if (i) out.push("");
-      for (const line of wrap(p, width - 6)) out.push(`    ${line}`);
-    });
-  }
-  const changelog = parseChangelog(s.changelog);
-  if (changelog) {
-    heading("Future changelog");
-    for (const line of wrap(changelog.headline, width - 6)) out.push(`    ${paint(ANSI.bold, line)}`);
-    for (const point of changelog.points) wrap(point, width - 8).forEach((line, i) => out.push(`    ${i ? " " : "\u2022"} ${line}`));
-  }
-  if (s.steps.length) {
-    heading("Plan");
-    s.steps.forEach((step, i) => {
-      const who = STEP_WHO_WORD[step.who] ?? step.who;
-      wrap(step.do, width - pad.length - 8).forEach((line, j) => out.push(`${j ? pad : `    \u2610 ${who.padEnd(6)}`}${line}`));
-      if (step.checks) out.push(pad + paint(ANSI.amber, i === 0 ? "checks the problem first" : "checks the problem"));
-    });
+  const counts = needCounts(tree);
+  out.push(`${paint(ANSI.bold, `${persona.name}\u2019s needs`)}  ${paint(ANSI.dim, `${counts.needs} needs \xB7 ${counts.difficulties + counts.precise} difficulties`)}`);
+  if (!tree.length) {
+    out.push("", `Nothing mapped yet. \`nanopm needs --refresh ${persona.slug}\` maps it in depth; add --short for a quick pass.`);
+    return out.join("\n");
   }
-  const card = at.leaf ? at.cards.find((c) => c.leaf.id === at.leaf.id) : void 0;
-  const others = card ? card.others.filter((o) => o.id !== s.id) : [];
-  out.push("");
-  if (s.status === "rejected") out.push(paint(ANSI.dim, "  Thrown out."));
-  else if (card?.pick.id === s.id) {
-    const column = at.cards.filter((c) => c.horizon === card.horizon);
-    const yours = s.placed_by === "founder" ? ", where you put it" : "";
-    out.push(paint(ANSI.dim, `  On the board: ${HORIZON_WORD[card.horizon]}, ${column.indexOf(card) + 1} of ${column.length}${yours}.`));
-  } else out.push(paint(ANSI.dim, card ? `  Not on the board: ${card.pick.ref} is this problem's card.` : "  Not on the board."));
-  if (others.length) out.push(paint(ANSI.dim, `  Other solutions to this problem: ${others.map((o) => o.ref).join(", ")}.`));
-  if (s.status === "proposed") {
-    const move = card?.pick.id === s.id ? `nanopm roadmap move ${s.ref} now|next|later [position] \xB7 ` : "";
-    out.push(paint(ANSI.dim, `  ${move}nanopm reject ${s.ref} ["why"]`));
+  const line = (n, depth) => {
+    const indent = "  ".repeat(depth);
+    const lead = n.level === 1 ? `${n.emoji ?? " "} ` : `${MARK[n.provenance]} `;
+    const where = n.provenance === "inferred" ? paint(ANSI.dim, ` guess ${n.confidence ?? 0}%`) : n.sources.length ? paint(ANSI.dim, ` ${n.sources.length} source${n.sources.length === 1 ? "" : "s"}`) : "";
+    const state = n.status === "dropped" ? paint(ANSI.dim, " dropped") : n.status === "confirmed" || n.author_kind === "user" ? "" : paint(ANSI.amber, " to review");
+    const label = n.status === "dropped" ? paint(ANSI.dim, n.label) : n.level === 1 ? paint(ANSI.bold, n.label) : n.label;
+    const body = wrap(`${label}${where}${state}${n.proposal ? paint(ANSI.amber, " \xB7 NanoPM suggests a new wording") : ""}`, width - indent.length - 12);
+    out.push(`${indent}${lead}${paint(ANSI.dim, n.ref.padEnd(8))} ${body[0] ?? ""}`);
+    for (const more of body.slice(1)) out.push(`${indent}           ${more}`);
+    for (const c of n.children) line(c, depth + 1);
+  };
+  for (const need of tree) {
+    out.push("");
+    line(need, 0);
   }
+  out.push("", paint(ANSI.dim, `\u25CF observed  \u2013 stated by you  \u25CB NanoPM\u2019s guess. \`nanopm needs confirm <ref>\`, \`nanopm needs drop <ref> "why"\`, \`nanopm needs dig <ref>\`.`));
+  if (opts.others?.length) out.push(paint(ANSI.dim, `Other personas: ${opts.others.join(", ")}.`));
   return out.join("\n");
 }
 
-// src/format/problems.ts
-var SHAPE2 = {
-  candidate: { mark: "\u25CB", colour: ANSI.dim, label: "candidate" },
-  confirmed: { mark: "\u25C9", colour: ANSI.amber, label: "confirmed" },
-  addressed: { mark: "\u25CF", colour: ANSI.green, label: "addressed" },
-  dropped: { mark: "\u2298", colour: ANSI.dim, label: "dropped" }
-};
-function renderImportance(problem, opts) {
-  const paint = painter(opts.color);
-  if (problem.importance_basis === "evidence") {
-    return paint(ANSI.bold, String(Math.round(problem.importance)).padStart(3));
-  }
-  const value = problem.importance;
-  const word = value >= 67 ? "high" : value >= 34 ? "med" : value > 0 ? "low" : "\u2014";
-  return paint(ANSI.dim, `~${word}`.padStart(5));
+// src/commands/needs.ts
+async function people(client, projectId) {
+  const { data, error } = await client.from("memory").select("key, title, content").eq("project_id", projectId).eq("topic", PERSONA_TOPIC).is("superseded_by", null);
+  if (error) throw new Error(`could not read the personas: ${error.message}`);
+  return (data ?? []).filter((r) => PERSONA_KEY.test(r.key)).map((r) => {
+    const p = parsePersona(r.key, r.content);
+    return { slug: p.slug, name: personaName(r.title, p.slug), primary: p.primary };
+  }).sort((a, b) => Number(b.primary) - Number(a.primary));
 }
-function renderProblems(problems2, duplicates, opts) {
-  const paint = painter(opts.color);
-  if (!problems2.length) {
-    return [
-      "No problems on the list yet.",
-      "",
-      paint(ANSI.dim, "  nanopm review     reads your data, then works out what they say about your users"),
-      paint(ANSI.dim, "  nanopm opportunities         what to work on, for your objective")
-    ].join("\n");
-  }
-  const refWidth = Math.max(...problems2.map((p) => p.ref.length));
-  const out = [];
-  const map = groupProblemMap(problems2.map((p) => ({ ...p, parentRef: p.parent_ref })));
-  const ordered = [...map.branches.flatMap((b) => [b.parent, ...b.children]), ...map.unplaced];
-  for (const problem of ordered) {
-    const shape2 = SHAPE2[problem.status] ?? { mark: "\xB7", colour: ANSI.dim, label: problem.status };
-    const score = renderImportance(problem, opts);
-    const head = `${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, problem.ref.padEnd(refWidth))} ${score}  ${problem.parent_ref ? paint(ANSI.dim, "\u21B3 ") : ""}${clip(firstSentence(problem.statement), Math.max(40, columns() - refWidth - 14))}`;
-    out.push(head);
-    if (problem.mapping) out.push(paint(ANSI.dim, `  ${problem.mapping.level === 1 ? "Need" : "Difficulty"} \xB7 ${problem.mapping.knowledge} \xB7 ${problem.mapping.origin === "expert_inference" ? "expert inference" : "source analysis"}`));
-    const indent = `  ${" ".repeat(refWidth)}      `;
-    const tail2 = problem.proofs > 0 ? `${problem.proofs} proof${problem.proofs === 1 ? "" : "s"}${problem.proof_kinds?.length ? ` \xB7 ${problem.proof_kinds.join(", ")}` : ""}` : problem.importance_note ? `no proof yet \xB7 ${problem.importance_note}` : "no proof yet";
-    out.push(paint(ANSI.dim, indent + clip(tail2, Math.max(40, columns() - indent.length))));
-  }
-  const unproven = problems2.filter((p) => p.proofs === 0).length;
-  if (unproven) {
-    out.push("");
-    out.push(
-      paint(
-        ANSI.dim,
-        `${unproven} of ${problems2.length} rest on judgement, not proof. A tilde marks those.`
-      )
-    );
-  }
-  if (duplicates.length) {
-    out.push("");
-    for (const pair of duplicates.slice(0, 3)) {
-      const why = pair.flagged ? `NanoPM is not sure ${pair.a} and ${pair.b} are different problems` : `${pair.a} and ${pair.b} read alike`;
-      out.push(paint(ANSI.amber, `? ${why}`));
-    }
-    out.push(paint(ANSI.dim, `  nanopm decisions        why \xB7 nanopm problems merge ${duplicates[0].b} ${duplicates[0].a}`));
-  }
-  if (opts.manualMerges !== void 0) {
-    out.push("");
-    out.push(
-      paint(
-        ANSI.dim,
-        `${opts.manualMerges} merge${opts.manualMerges === 1 ? "" : "s"} you have had to make by hand.`
-      )
-    );
-  }
-  out.push("");
-  out.push(paint(ANSI.dim, "  nanopm problems <ref> \xB7 nanopm problems merge <from> <into> \xB7 nanopm problems weight <ref> <0-100>"));
-  return out.join("\n");
+function pick2(list, named) {
+  if (!list.length) throw new Error("there is no persona on the business card yet. `nanopm personas --refresh` works out who this is for.");
+  if (!named) return list[0];
+  const one = list.find((p) => p.slug === named.toLowerCase() || p.name.toLowerCase() === named.toLowerCase());
+  if (!one) throw new Error(`no persona "${named}". The personas are: ${list.map((p) => p.slug).join(", ")}.`);
+  return one;
 }
-function renderProblem(problem, evidence2, addressedBy, opts) {
-  const paint = painter(opts.color);
-  const shape2 = SHAPE2[problem.status] ?? { mark: "\xB7", colour: ANSI.dim, label: problem.status };
-  const width = columns();
-  const out = [];
-  out.push(`${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, problem.ref)}  ${paint(ANSI.bold, shape2.label)}`);
-  out.push("");
-  for (const line of wrap(problem.statement, width)) out.push(line);
-  out.push("");
-  const facts = [];
-  const m = problem.mapping ?? null;
-  if (m) {
-    const story = problemStory(m, { proofs: problem.proofs, kinds: problem.proof_kinds ?? [], provenance: problem.provenance ?? "inferred", authorKind: problem.author_kind ?? "nanopm", createdAt: problem.created_at ?? "" });
-    out.push(...wrap(story.story, width));
-    out.push("");
-    out.push(...wrap(story.doubt, width).map((l) => paint(ANSI.dim, l)));
-    out.push(...wrap(story.assumes ? `${story.test} ${story.assumes}` : story.test, width).map((l) => paint(ANSI.dim, l)));
-    out.push("");
-    out.push(paint(ANSI.dim, "how I got here"));
-    facts.push(["kind", `${m.level === 1 ? "a need" : "a difficulty"} \xB7 ${m.knowledge} \xB7 ${m.origin === "expert_inference" ? "expert inference" : "source analysis"}`]);
-    if (m.parent_reason) facts.push(["grouping", m.parent_reason]);
-  }
-  if (problem.segment) facts.push(["who", problem.segment]);
-  facts.push([
-    "weight",
-    problem.importance_basis === "evidence" ? `${Math.round(problem.importance)} from ${problem.proofs} piece${problem.proofs === 1 ? "" : "s"} of proof` : `${Math.round(problem.importance)}, a judgement${problem.importance_note ? ` \u2014 ${problem.importance_note}` : ""}`
+async function rows(client, projectId, persona) {
+  let q = client.from("need_nodes").select(NEED_NODE_COLUMNS).eq("project_id", projectId);
+  if (persona) q = q.eq("persona", persona);
+  const { data, error } = await q.order("created_at");
+  if (error) throw new Error(`could not read the needs map: ${error.message}`);
+  return data ?? [];
+}
+async function needs(persona, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const list = await people(auth.client, project.id);
+  const who = pick2(list, persona);
+  const tree = needTree(await rows(auth.client, project.id, who.slug));
+  return renderNeeds(who, tree, { color: opts.color ?? useColor(), others: list.filter((p) => p.slug !== who.slug).map((p) => p.slug) });
+}
+async function mapNeeds(target, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const list = await people(auth.client, project.id);
+  let persona;
+  let scope = "map";
+  if (target.ref) {
+    const ref = target.ref.toUpperCase();
+    const node = (await rows(auth.client, project.id)).find((r) => r.ref === ref);
+    if (!node) throw new Error(`no node ${target.ref} on any needs map. \`nanopm needs\` shows the refs.`);
+    persona = pick2(list, node.persona);
+    scope = ref;
+  } else persona = pick2(list, target.persona);
+  const [{ data: active }, tree] = await Promise.all([
+    auth.client.from("jobs").select("params").eq("project_id", project.id).eq("skill", "needs").in("status", [...ACTIVE_STATUSES]),
+    rows(auth.client, project.id, persona.slug).then(needTree)
   ]);
-  if (problem.parent_ref) facts.push(["part of", problem.parent_ref]);
-  for (const [label, value] of facts) {
-    out.push(`${paint(ANSI.dim, label.padEnd(9))}${clip(value, width - 9)}`);
-  }
-  if (evidence2.length) {
-    out.push("");
-    out.push(paint(ANSI.dim, "sources"));
-    for (const item of evidence2) {
-      const when = (item.occurred_at ?? item.created_at).slice(0, 10);
-      const where = item.metric_key ?? item.source_ref ?? item.kind;
-      for (const line of wrap(item.body, width - 2)) out.push(`  ${line}`);
-      out.push(paint(ANSI.dim, `  \u2014 ${item.relation ?? "supports"} \xB7 ${item.kind} \xB7 ${where} \xB7 ${when}`));
-    }
-  } else {
-    out.push("");
-    out.push(paint(ANSI.dim, "No proof yet. This ranking is a judgement, and the next review may settle it."));
-  }
-  if (addressedBy.length) {
-    out.push("");
-    out.push(paint(ANSI.dim, "addressed by"));
-    for (const item of addressedBy) {
-      out.push(`  ${paint(ANSI.dim, item.ref)}  ${clip(item.title, width - 12)} ${paint(ANSI.dim, `(${item.status})`)}`);
-    }
+  const lineage = (ref) => {
+    const walk = (l) => {
+      for (const n of l) {
+        if (n.ref === ref.toUpperCase()) return n.path.map((p) => p.ref);
+        const deeper = walk(n.children);
+        if (deeper) return deeper;
+      }
+      return null;
+    };
+    return walk(tree) ?? [ref];
+  };
+  const clash = needsRunConflict((active ?? []).map((j) => runScopeOf(j.params)), { persona: persona.slug, scope }, { primary: list.find((p) => p.primary)?.slug ?? list[0]?.slug ?? null, lineage, name: (s) => list.find((p) => p.slug === s)?.name ?? s });
+  if (clash) throw new Error(clash);
+  const repo = await detectRepo(opts.cwd);
+  if (repo) await rememberClone(auth.client, project.id, repo.root);
+  const params = {
+    persona: persona.slug,
+    ...scope === "map" ? {} : { scope },
+    depth: opts.short ? "short" : "deep",
+    ...opts.note?.trim() ? { note: opts.note.trim().slice(0, 600) } : {},
+    ...repo ? { repo_path: repo.root } : {}
+  };
+  return runSkill("needs", { project: project.id, params, cancelSignal: opts.cancelSignal });
+}
+async function confirmNeed(ref, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const { data, error } = await auth.client.from("need_nodes").update({ status: "confirmed" }).eq("project_id", project.id).eq("ref", ref.toUpperCase()).eq("status", "proposed").select("ref, label");
+  if (error) throw new Error(pgMessage(error));
+  if (!data?.length) throw new Error(`${ref} is not a node waiting on your word. \`nanopm needs\` shows which are.`);
+  return `Confirmed ${data[0].ref}: ${data[0].label}. A run proposes beside it from now on, never over it.`;
+}
+async function dropNeed(ref, why, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const { data, error } = await auth.client.from("need_nodes").update({ status: "dropped", drop_reason: why?.trim().slice(0, 400) || "not true of them" }).eq("project_id", project.id).eq("ref", ref.toUpperCase()).in("status", ["proposed", "confirmed"]).select("ref, label");
+  if (error) throw new Error(pgMessage(error));
+  if (!data?.length) throw new Error(`${ref} is not on the map any more.`);
+  return `Dropped ${data[0].ref}: ${data[0].label}. It stays on the record, and NanoPM will not propose it again in the same place.`;
+}
+
+// src/commands/opportunities.ts
+async function lensOf2(client, projectId) {
+  const { data } = await client.from("memory").select("id, key, content").eq("project_id", projectId).eq("topic", GOALS_TOPIC).in("key", [OBJECTIVE_KEY, DEFINITION_KEY]).is("superseded_by", null);
+  const rows2 = data ?? [];
+  const aim = rows2.find((r) => r.key === OBJECTIVE_KEY);
+  const m = aim ? /^Lever:\s*([a-z]+)\.\s*(.*)$/s.exec(aim.content.trim()) : null;
+  const lever = m?.[1];
+  if (!aim || !lever || !OUTCOME_LEVERS.includes(lever)) return null;
+  const def = rows2.find((r) => r.key === DEFINITION_KEY);
+  const parsed = def ? parseDefinition(def.content) : null;
+  const sentence2 = m[2].trim();
+  const definition = parsed && parsed.lever === lever ? parsed.sentence : null;
+  return { id: aim.id, lever, sentence: sentence2, definition, key: lensKey(lever, sentence2, definition) };
+}
+async function loadOpportunities(client, projectId) {
+  const [standing, replaced] = await Promise.all([
+    client.from("opportunities").select(OPPORTUNITY_COLUMNS).eq("project_id", projectId).neq("status", "replaced"),
+    client.from("opportunities").select(REPLACED_COLUMNS).eq("project_id", projectId).eq("status", "replaced")
+  ]);
+  const error = standing.error ?? replaced.error;
+  if (error) throw new Error(`could not read the opportunities: ${error.message}`);
+  return [...standing.data ?? [], ...replaced.data ?? []];
+}
+async function workingOn(client, projectId) {
+  const { data } = await client.from("jobs").select("params").eq("project_id", projectId).eq("skill", SOLUTIONS_SKILL).in("status", [...ACTIVE_STATUSES]);
+  return leavesAtWork((data ?? []).map((j) => j.params));
+}
+async function opportunities(opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const [lens, all, personas2] = await Promise.all([lensOf2(auth.client, project.id), loadOpportunities(auth.client, project.id), people(auth.client, project.id)]);
+  const { shown, drawnFor } = shownMap(all, lens?.key ?? null);
+  const names = new Map(personas2.map((p) => [p.slug, p.name]));
+  return renderOpportunities(shown, lens, { color: opts.color ?? useColor(), previous: drawnFor === "previous", names });
+}
+async function rankOpportunities(opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const list = (s) => s ? s.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+  const sources2 = opts.use || opts.skip ? { ...opts.use ? { use: list(opts.use) } : {}, ...opts.skip ? { skip: list(opts.skip) } : {} } : void 0;
+  const params = {
+    depth: opts.deep ? "deep" : "short",
+    ...opts.note?.trim() ? { note: opts.note.trim().slice(0, OPPORTUNITIES_NOTE_MAX) } : {},
+    ...sources2 ? { sources: sources2 } : {}
+  };
+  const checked = opportunitiesAsk(params);
+  if (!checked.ok) throw new Error(checked.why);
+  const { data: active } = await auth.client.from("jobs").select("id").eq("project_id", project.id).eq("skill", "opportunities").in("status", [...ACTIVE_STATUSES]);
+  const clash = opportunitiesRunConflict(active ?? []);
+  if (clash) throw new Error(clash);
+  const repo = await detectRepo(opts.cwd);
+  if (repo) await rememberClone(auth.client, project.id, repo.root);
+  return runSkill("opportunities", { project: project.id, params: { ...params, ...repo ? { repo_path: repo.root } : {} }, cancelSignal: opts.cancelSignal });
+}
+async function rpc2(name, args, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const { error } = await auth.client.rpc(name, { p_project_id: project.id, ...args });
+  if (error) throw new Error(pgMessage(error));
+}
+async function confirmOpportunity(ref, opts) {
+  await rpc2("confirm_opportunity", { p_ref: ref }, opts);
+  return `${ref.toUpperCase()} is yours. A later run ranks around it and never replaces it.`;
+}
+async function setAsideOpportunity(ref, why, opts) {
+  await rpc2("set_aside_opportunity", { p_ref: ref, p_reason: why ?? "not now" }, opts);
+  return `${ref.toUpperCase()} is set aside for this objective, with the narrower problems under it. It comes back if the objective changes.`;
+}
+async function moveOpportunity(ref, place, opts) {
+  const rank2 = Number(place);
+  if (!Number.isInteger(rank2) || rank2 < 1) throw new Error("say where: nanopm opportunities move <ref> <place>, a place from 1");
+  await rpc2("move_opportunity", { p_ref: ref, p_rank: rank2 }, opts);
+  return `${ref.toUpperCase()} is at #${rank2} among its siblings, and the place is yours. Moved above a higher priority, it takes that priority.`;
+}
+async function rewordOpportunity(ref, problem, opts) {
+  const text2 = problem?.trim().replace(/\s+/g, " ") ?? "";
+  if (!text2) throw new Error('say it: nanopm opportunities reword <ref> "the problem, in your words"');
+  if (text2.length > PROBLEM_MAX) throw new Error(`one line, under ${PROBLEM_MAX} characters`);
+  await rpc2("restate_opportunity", { p_ref: ref, p_problem: text2 }, opts);
+  return `Kept in your words: ${text2}`;
+}
+var AWAKE_MS = 12e4;
+async function awakeDaemon(client, userId) {
+  const since = new Date(Date.now() - AWAKE_MS).toISOString();
+  const [{ data }, local] = await Promise.all([
+    client.from("daemons").select("id, hostname").eq("user_id", userId).in("status", ["online", "running"]).gte("last_seen_at", since).order("last_seen_at", { ascending: false }),
+    localDaemonId()
+  ]);
+  return data?.find((d) => d.id === local) ?? data?.[0] ?? null;
+}
+async function brainstorm(ref, opts) {
+  const auth = await authenticate();
+  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
+  const [lens, all, busy] = await Promise.all([lensOf2(auth.client, project.id), loadOpportunities(auth.client, project.id), workingOn(auth.client, project.id)]);
+  const deep = Boolean(opts.deep);
+  const plan = brainstormPlan(shownMap(all, lens?.key ?? null).shown, ref, deep, new Set(busy.keys()));
+  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 brainstorm again.");
+  const repo = deep ? await detectRepo(opts.cwd) : null;
+  if (repo) await rememberClone(auth.client, project.id, repo.root);
+  for (const params of plan.jobs) {
+    const { error } = await auth.client.from("jobs").insert({ project_id: project.id, skill: SOLUTIONS_SKILL, params: { ...params, ...repo ? { repo_path: repo.root } : {} }, requested_by: auth.userId, trigger: "user", target_daemon_id: daemon.id });
+    if (error) throw new Error(`could not queue the brainstorm: ${error.message}`);
   }
-  out.push("");
-  out.push(paint(ANSI.dim, "  nanopm problems \xB7 nanopm roadmap"));
+  const n = plan.leaves.length;
+  const minutes = deep ? DEEP_MINUTES * n : FLASH_MINUTES;
+  const what = plan.problem.children.length ? `the ${n} narrower problem${n === 1 ? "" : "s"} under ${plan.problem.ref}` : `${plan.problem.ref} \u201C${clip(plan.problem.problem, 60)}\u201D`;
+  const how = deep ? `${DEPTH_WORD.deep}${n > 1 ? ", one after the other" : ""}` : `${DEPTH_WORD.quick}, a first pass`;
+  const out = [`${deep ? "Going deeper on" : "Brainstorming"} ${what}: ${how}, about ${minutes} minutes on ${daemon.hostname}.`];
+  if (plan.problem.children.length) for (const l of plan.leaves) out.push(`  ${l.ref.padEnd(8)} ${clip(l.problem, Math.max(30, columns() - 11))}`);
+  if (plan.busy) out.push(`${plan.busy} left out: Nano is already finding solutions to ${plan.busy === 1 ? "it" : "them"}.`);
+  out.push("The solutions land on `nanopm roadmap`.");
   return out.join("\n");
 }
 
-// src/format/tree.ts
-var SOLUTION_SHAPE = {
+// src/format/roadmap.ts
+var SHAPE = {
   proposed: { mark: "\u25CB", colour: ANSI.amber, label: "proposed" },
   accepted: { mark: "\u25D0", colour: ANSI.green, label: "accepted" },
   building: { mark: "\u25D4", colour: ANSI.blue, label: "building" },
-  done: { mark: "\u25CF", colour: ANSI.green, label: "done" },
   rejected: { mark: "\u2298", colour: ANSI.red, label: "rejected" },
+  done: { mark: "\u25CF", colour: ANSI.green, label: "done" },
   dropped: { mark: "\u2298", colour: ANSI.dim, label: "dropped" }
 };
-var PROBLEM_SHAPE = {
-  candidate: { mark: "\u25CB", colour: ANSI.dim },
-  confirmed: { mark: "\u25C9", colour: ANSI.amber },
-  addressed: { mark: "\u25CF", colour: ANSI.green },
-  dropped: { mark: "\u2298", colour: ANSI.dim }
+var WORK_KINDS = /* @__PURE__ */ new Set(["branch", "git", "url", "job"]);
+function renderRoadmapItem(item, opts, problem, builtBy) {
+  const paint = painter(opts.color);
+  const shape2 = SHAPE[item.status] ?? { mark: "\xB7", colour: "", label: item.status };
+  const out = [`${paint(shape2.colour, shape2.mark)} ${paint(ANSI.bold, item.ref)}  ${item.title}`];
+  if (problem) out.push(paint(ANSI.dim, `  answers ${problem.ref}  ${clip(problem.statement, Math.max(30, columns() - 20))}`));
+  out.push("");
+  for (const line of wrap(item.reasoning, Math.max(40, columns() - 4))) out.push(`  ${line}`);
+  out.push("");
+  const facts = [
+    ["status", shape2.label + (item.outcome ? ` \xB7 ${item.outcome}${item.outcome_note ? `: ${item.outcome_note}` : ""}` : "")],
+    ["rank", String(item.rank)],
+    ["who", item.actor === "founder" ? "you" : "NanoPM"],
+    ["bets on", item.assumption ?? "\u2014"],
+    ["we'll know", item.eval ?? "\u2014"]
+  ];
+  for (const [k, v] of facts) out.push(paint(ANSI.dim, `  ${k.padEnd(9)} ${v}`));
+  const sources2 = item.sources ?? [];
+  const restsOn = sources2.filter((s) => !WORK_KINDS.has(s.kind));
+  if (restsOn.length) {
+    out.push(paint(ANSI.dim, `  ${"rests on".padEnd(9)} ${restsOn.map((s) => `${s.kind}:${s.ref}`).join(", ")}`));
+  }
+  const where = renderWhere(sources2);
+  if (where) out.push(paint(ANSI.dim, `  ${"where".padEnd(9)} ${where}${builtBy ? ` \xB7 built by ${builtBy}` : ""}`));
+  return out.join("\n");
+}
+function renderWhere(sources2) {
+  const branch = sources2.find((s) => s.kind === "branch")?.ref;
+  const commit = sources2.find((s) => s.kind === "git")?.ref;
+  const url = sources2.find((s) => s.kind === "url")?.ref;
+  return [branch, commit, url].filter(Boolean).join(" \xB7 ");
+}
+var VERB = {
+  want: { text: "wanted", colour: ANSI.amber },
+  confirm: { text: "confirmed", colour: ANSI.green },
+  drop: { text: "dropped", colour: ANSI.red },
+  merge: { text: "merged into", colour: ANSI.blue },
+  separate: { text: "kept apart", colour: ANSI.blue },
+  weight: { text: "weighed", colour: ANSI.blue },
+  area: { text: "filed", colour: ANSI.blue },
+  accept: { text: "accepted", colour: ANSI.green },
+  reject: { text: "rejected", colour: ANSI.red },
+  first: { text: "put first", colour: ANSI.blue },
+  done: { text: "did", colour: ANSI.green },
+  dismiss: { text: "dismissed", colour: ANSI.red }
 };
-var NO_AREA = "no area yet";
-var SHOWN = /* @__PURE__ */ new Set(["proposed", "accepted", "building", "done"]);
-function renderTree(problems2, solutions, strategy, opts) {
+function renderDecisions(rows2, opts) {
   const paint = painter(opts.color);
+  if (!rows2.length) return "No decisions yet.";
   const out = [];
-  const width = Math.max(40, columns());
-  if (strategy) {
-    out.push(paint(ANSI.bold, "Strategy"));
-    for (const line of wrap(strategy, width - 4)) out.push(`  ${line}`);
-    out.push("");
-  }
-  const shown = solutions.filter((s) => SHOWN.has(s.status));
-  const open = problems2.filter((p) => p.status !== "dropped" && (!opts.alongside || shown.some((s) => s.problem_id === p.id)));
-  if (opts.alongside && !open.length) return "";
-  if (!open.length && !shown.length) {
-    out.push("No problems yet. `nanopm opportunities` shows what to work on.");
-    return out.join("\n");
-  }
-  const byProblem = /* @__PURE__ */ new Map();
-  for (const s of shown) byProblem.set(s.problem_id, [...byProblem.get(s.problem_id) ?? [], s]);
-  const refWidth = Math.max(...[...open.map((p) => p.ref), ...shown.map((s) => s.ref)].map((r) => r.length), 5);
-  for (const [area, rows2] of groupByArea(open)) {
-    out.push(paint(ANSI.bold, area));
-    for (const p of rows2) {
-      const shape2 = PROBLEM_SHAPE[p.status] ?? { mark: "\xB7", colour: "" };
-      const kind = p.kind === "founder" ? paint(ANSI.dim, " (founder)") : "";
-      const proof = p.proofs ? `${p.proofs} proof${p.proofs === 1 ? "" : "s"}` : "no proof";
-      const tail2 = `${renderImportance(p, opts)}  ${paint(ANSI.dim, proof)}`;
-      const head = `  ${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, p.ref.padEnd(refWidth))}  `;
-      out.push(head + clip(p.statement, Math.max(30, width - visibleLength(head) - visibleLength(tail2) - 2)) + kind + "  " + tail2);
-      const under = byProblem.get(p.id) ?? [];
-      if (!under.length) {
-        out.push(paint(ANSI.dim, `    ${" ".repeat(refWidth + 2)}  no solution yet`));
-        continue;
-      }
-      for (const s of under) out.push(...solutionLines(s, refWidth, width, paint));
+  for (const row of rows2) {
+    const when = row.created_at.slice(0, 10);
+    const verb = VERB[row.kind] ?? { text: row.kind, colour: ANSI.blue };
+    const about = row.solutions ? `${paint(ANSI.dim, row.solutions.ref)} ${row.solutions.title}` : row.problems ? paint(ANSI.dim, row.problems.ref) : row.market_entries ? `${paint(ANSI.dim, row.market_entries.ref)} ${row.market_entries.competitor ?? ""}`.trimEnd() : "";
+    const by = row.by ? paint(ANSI.dim, ` \xB7 by ${row.by}`) : "";
+    out.push(`${paint(ANSI.dim, when)}  ${paint(verb.colour, verb.text)} ${about}${by}`.trimEnd());
+    if (row.body) {
+      for (const line of wrap(row.body, 72)) out.push(paint(ANSI.dim, `              ${line}`));
     }
-    out.push("");
-  }
-  const waiting = shown.filter((s) => s.status === "proposed").length;
-  if (waiting) {
-    out.push(`${waiting} waiting on you.`);
-    out.push(paint(ANSI.dim, '  nanopm accept <ref> \xB7 nanopm reject <ref> "why" \xB7 nanopm roadmap <ref> \xB7 nanopm roadmap --board'));
-  } else if (!opts.alongside) {
-    out.push(paint(ANSI.dim, "Nothing waiting on you."));
   }
-  return out.join("\n").trimEnd();
+  return out.join("\n");
 }
-function solutionLines(s, refWidth, width, paint, indent = 6) {
-  const shape2 = SOLUTION_SHAPE[s.status] ?? { mark: "\xB7", colour: "", label: s.status };
-  const pad = " ".repeat(indent);
-  const STATE = { accepted: "chosen", building: "building", done: "done" };
-  const tail2 = s.actor === "founder" ? "yours to do" : s.outcome ? s.outcome : s.status === "proposed" ? s.assumption ? clip(s.assumption, 40) : null : STATE[s.status] ?? null;
-  const badge = tail2 ? paint(ANSI.dim, `  ${tail2}`) : "";
-  const head = `${pad}${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, s.ref.padEnd(refWidth))}  `;
-  const lines = [head + clip(s.title, Math.max(30, width - visibleLength(head) - visibleLength(badge))) + badge];
-  const reason2 = `${pad}  ${" ".repeat(refWidth)}  `;
-  lines.push(paint(ANSI.dim, reason2 + clip(firstSentence(s.reasoning), Math.max(30, width - reason2.length))));
-  return lines;
+var HUE = ["\x1B[34m", "\x1B[35m", "\x1B[36m", "\x1B[32m", "\x1B[95m"];
+function themesOf(tree) {
+  return new Map(tree.map((b) => [b.id, { name: themeName(b), colour: HUE[themeHue(tree, b) - 1] }]));
 }
-function groupByArea(problems2) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const p of problems2) {
-    const area = p.area ?? NO_AREA;
-    groups.set(area, [...groups.get(area) ?? [], p]);
-  }
-  const named = [...groups.entries()].filter(([a]) => a !== NO_AREA);
-  const rest = groups.get(NO_AREA);
-  return rest ? [...named, [NO_AREA, rest]] : named;
+function sizeWord(size, paint) {
+  return size === "big" ? `${paint(ANSI.bold, "\u25AA")} ${SIZE_WORD.big}` : size === "small" ? paint(ANSI.dim, SIZE_WORD.small) : "";
 }
-var BOARD_COLUMNS = [
-  { status: "proposed", label: "Proposed" },
-  { status: "accepted", label: "Chosen" },
-  { status: "building", label: "Building" },
-  { status: "done", label: "Done" }
-];
-function renderBoard(problems2, solutions, opts) {
+function renderSolutionsBoard(board, opts) {
   const paint = painter(opts.color);
-  const out = [];
-  const byId = new Map(problems2.map((p) => [p.id, p]));
   const width = Math.max(40, columns());
-  const refWidth = Math.max(...solutions.map((s) => s.ref.length), 5);
-  for (const col of BOARD_COLUMNS) {
-    const rows2 = solutions.filter((s) => s.status === col.status);
-    out.push(`${paint(ANSI.bold, col.label)} ${paint(ANSI.dim, String(rows2.length))}`);
-    if (!rows2.length) out.push(paint(ANSI.dim, "  \u2014"));
-    for (const s of rows2) {
-      const shape2 = SOLUTION_SHAPE[s.status];
-      const problem = byId.get(s.problem_id);
-      const head = `  ${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, s.ref.padEnd(refWidth))}  `;
-      out.push(head + clip(s.title, Math.max(30, width - visibleLength(head))));
-      const under = [problem ? `${problem.ref} ${clip(problem.statement, 50)}` : "its problem was dropped", s.assumption ? clip(s.assumption, 40) : null].filter(Boolean).join(" \xB7 ");
-      out.push(paint(ANSI.dim, `  ${" ".repeat(refWidth + 2)}  ${under}`));
+  const themes = themesOf(board.tree);
+  const out = [`${paint(ANSI.bold, "Roadmap")}${board.objective ? `  ${paint(ANSI.dim, `${board.objective.lever} \u2014 ${board.objective.sentence}`)}` : ""}`];
+  const chips = board.tree.flatMap((b) => {
+    const n = board.cards.filter((c) => c.branch.id === b.id).length;
+    const t = themes.get(b.id);
+    return n ? [`${paint(t.colour, "\u25CF")} ${t.name} ${paint(ANSI.dim, String(n))}`] : [];
+  });
+  const legend = chips.reduce((lines, chip) => {
+    const last = lines.at(-1);
+    if (last !== void 0 && visibleLength(last) + 3 + visibleLength(chip) <= width) lines[lines.length - 1] = `${last}   ${chip}`;
+    else lines.push(chip);
+    return lines;
+  }, []);
+  out.push("", ...legend);
+  if (!board.cards.some((c) => c.pick.placed_by === "founder")) out.push(paint(ANSI.dim, "Nano placed these in the order of your opportunity map. Move them where you want them."));
+  const refWidth = Math.max(5, ...board.cards.map((c) => c.pick.ref.length));
+  const gutter = " ".repeat(refWidth + 4);
+  const titleWidth = Math.min(Math.max(...board.cards.map((c) => c.pick.title.length)), width - gutter.length - 8);
+  for (const h of HORIZONS) {
+    const column = board.cards.filter((c) => c.horizon === h);
+    out.push("", `${paint(ANSI.bold, HORIZON_WORD[h])}  ${paint(ANSI.dim, String(column.length))}`);
+    if (!column.length) out.push(paint(ANSI.dim, `  Move a card here: nanopm roadmap move <ref> ${h}`));
+    for (const c of column) {
+      const t = themes.get(c.branch.id);
+      out.push(`  ${paint(ANSI.dim, c.pick.ref.padEnd(refWidth))}  ${paint(t.colour, "\u25CF")} ${paint(ANSI.dim, t.name)}`);
+      out.push(`${gutter}${clip(c.pick.title, titleWidth).padEnd(titleWidth)}  ${sizeWord(c.pick.size, paint)}`.trimEnd());
+      const depth = board.working.get(c.leaf.id);
+      if (depth) out.push(`${gutter}${paint(ANSI.blue, "\u25CF")} ${paint(ANSI.dim, WORK_WORD[depth])}`);
     }
-    out.push("");
   }
-  return out.join("\n").trimEnd();
+  if (board.earlier) out.push("", paint(ANSI.bold, "On the problem list"), "", board.earlier);
+  out.push(
+    "",
+    paint(ANSI.dim, 'nanopm roadmap <ref> \xB7 nanopm roadmap move <ref> now|next|later [position] \xB7 nanopm reject <ref> ["why"]'),
+    paint(ANSI.dim, "nanopm opportunities brainstorm <ref> [--deep]: solutions to another problem, or deeper ones")
+  );
+  return out.join("\n");
 }
-
-// src/format/opportunities.ts
-function renderOpportunities(rows2, lens, opts) {
+function renderSolutionSheet(s, at, opts) {
   const paint = painter(opts.color);
   const width = Math.max(40, columns());
+  const theme = at.branch ? themesOf(at.tree).get(at.branch.id) : void 0;
   const out = [];
-  if (!lens) return "No objective yet: the map is drawn for it. Say what matters most right now on Your business, then `nanopm opportunities run`.";
-  out.push(`${paint(ANSI.bold, "Opportunities")}  ${paint(ANSI.dim, `${lens.lever} \u2014 ${lens.sentence}`)}`);
-  out.push(paint(ANSI.dim, lens.definition ? `Counts: ${lens.definition}` : "What it counts is not defined yet: drawn against the lever and your sentence."));
-  if (opts.previous) out.push(paint(ANSI.amber, "Drawn for your previous objective. `nanopm opportunities run` draws it for this one."));
-  if (!rows2.length) {
-    out.push("", "No map yet. `nanopm opportunities run` draws it from what NanoPM knows; add --deep to check it against your users, code and data.");
-    return out.join("\n");
+  if (theme) out.push(`${paint(theme.colour, "\u25CF")} ${paint(ANSI.dim, theme.name)}`);
+  const size = sizeWord(s.size, paint);
+  out.push(`${paint(ANSI.dim, s.ref)}  ${paint(ANSI.bold, s.title)}${size ? `  ${size}` : ""}`);
+  const pad = " ".repeat(12);
+  const heading = (text2) => out.push("", `  ${paint(ANSI.bold, text2)}`);
+  heading("Problem we are solving");
+  if (at.leaf) {
+    const solves = wrap(at.leaf.problem, width - 6 - at.leaf.ref.length - 2);
+    solves[solves.length - 1] += `  ${paint(ANSI.dim, at.leaf.ref)}`;
+    for (const line of solves) out.push(`    ${line}`);
+    if (at.branch && at.branch.id !== at.leaf.id) {
+      for (const line of wrap(`Part of: ${at.branch.problem} ${at.branch.ref}`, width - 6)) out.push(`    ${paint(ANSI.dim, line)}`);
+    }
+  } else {
+    out.push(paint(ANSI.dim, "    The problem it answered is no longer on the map."));
   }
-  const tree = liveTree(rows2);
-  const live = rows2.filter(isLive);
-  const evidenced = live.filter((r) => r.evidence_status === "evidence_backed").length;
-  out.push(paint(ANSI.dim, `${live.length} on the map: ${evidenced} evidence-backed, ${live.length - evidenced} hypotheses \u2014 what users or their behaviour have not shown yet.`));
-  const who = (r) => r.personas.map((p) => opts.names?.get(p) ?? p).join(", ");
-  const one = (r, place) => {
-    const indent = "  ".repeat(r.depth - 1);
-    const yours = r.status === "confirmed" ? paint(ANSI.green, " yours") : "";
-    out.push("", `${indent}${paint(ANSI.bold, place.padStart(2))}  ${r.depth === 1 ? paint(ANSI.bold, r.problem) : r.problem}${yours}  ${paint(ANSI.dim, r.ref)}`);
-    const pad = `${indent}    `;
-    const facts = [PRIORITY_WORD[r.priority], EVIDENCE_STATUS_WORD[r.evidence_status], NEXT_ACTION_WORD[r.next_action], who(r)].filter(Boolean).join(" \xB7 ");
-    out.push(`${pad}${paint(ANSI.dim, facts)}`);
-    const gist = r.description ? paragraphs(r.description)[0] : null;
-    if (gist) for (const l of wrap(gist, width - pad.length)) out.push(`${pad}${l}`);
-    if (r.learn) for (const l of wrap(`To learn more: ${r.learn}`, width - pad.length)) out.push(`${pad}${paint(ANSI.dim, l)}`);
-    if (r.founder_rank !== null && r.now_rank) out.push(`${pad}${paint(ANSI.dim, `Its place is yours; NanoPM would now put it at #${r.now_rank}.`)}`);
-    if (r.reconsider) for (const l of wrap(`Worth reconsidering: ${r.reconsider}`, width - pad.length)) out.push(`${pad}${paint(ANSI.amber, l)}`);
-    for (const c of r.children) one(c, `${place}.${c.rank}`);
-  };
-  for (const r of tree) one(r, String(r.rank));
-  const aside = rows2.filter((r) => r.status === "set_aside");
-  if (aside.length) {
-    out.push("", paint(ANSI.bold, `Set aside (${aside.length})`));
-    for (const r of aside) out.push(`  ${paint(ANSI.dim, r.ref.padEnd(8))} ${r.problem}${r.set_aside_reason ? paint(ANSI.dim, ` \u2014 ${r.set_aside_reason}`) : ""}`);
+  const described = paragraphs(s.description);
+  if (described.length) {
+    heading("Proposed solution");
+    described.forEach((p, i) => {
+      if (i) out.push("");
+      for (const line of wrap(p, width - 6)) out.push(`    ${line}`);
+    });
+  }
+  const changelog = parseChangelog(s.changelog);
+  if (changelog) {
+    heading("Future changelog");
+    for (const line of wrap(changelog.headline, width - 6)) out.push(`    ${paint(ANSI.bold, line)}`);
+    for (const point of changelog.points) wrap(point, width - 8).forEach((line, i) => out.push(`    ${i ? " " : "\u2022"} ${line}`));
+  }
+  if (s.steps.length) {
+    heading("Plan");
+    s.steps.forEach((step, i) => {
+      const who = STEP_WHO_WORD[step.who] ?? step.who;
+      wrap(step.do, width - pad.length - 8).forEach((line, j) => out.push(`${j ? pad : `    \u2610 ${who.padEnd(6)}`}${line}`));
+      if (step.checks) out.push(pad + paint(ANSI.amber, i === 0 ? "checks the problem first" : "checks the problem"));
+    });
+  }
+  const card = at.leaf ? at.cards.find((c) => c.leaf.id === at.leaf.id) : void 0;
+  const others = card ? card.others.filter((o) => o.id !== s.id) : [];
+  out.push("");
+  if (s.status === "rejected") out.push(paint(ANSI.dim, "  Thrown out."));
+  else if (card?.pick.id === s.id) {
+    const column = at.cards.filter((c) => c.horizon === card.horizon);
+    const yours = s.placed_by === "founder" ? ", where you put it" : "";
+    out.push(paint(ANSI.dim, `  On the board: ${HORIZON_WORD[card.horizon]}, ${column.indexOf(card) + 1} of ${column.length}${yours}.`));
+  } else out.push(paint(ANSI.dim, card ? `  Not on the board: ${card.pick.ref} is this problem's card.` : "  Not on the board."));
+  if (others.length) out.push(paint(ANSI.dim, `  Other solutions to this problem: ${others.map((o) => o.ref).join(", ")}.`));
+  if (s.status === "proposed") {
+    const move = card?.pick.id === s.id ? `nanopm roadmap move ${s.ref} now|next|later [position] \xB7 ` : "";
+    out.push(paint(ANSI.dim, `  ${move}nanopm reject ${s.ref} ["why"]`));
   }
-  out.push("", paint(ANSI.dim, '`nanopm opportunities confirm <ref>`, `set-aside <ref> "why"`, `move <ref> <place>`, `reword <ref> "\u2026"`, `brainstorm <ref> [--deep]`, `run [--deep] [--note "\u2026"] [--use signals,data,repo,market] [--skip \u2026]`.'));
   return out.join("\n");
 }
-
-// src/format/needs.ts
-var MARK = { observed: "\u25CF", stated: "\u2013", inferred: "\u25CB" };
-function renderNeeds(persona, tree, opts) {
+
+// src/format/problems.ts
+var SHAPE2 = {
+  candidate: { mark: "\u25CB", colour: ANSI.dim, label: "candidate" },
+  confirmed: { mark: "\u25C9", colour: ANSI.amber, label: "confirmed" },
+  addressed: { mark: "\u25CF", colour: ANSI.green, label: "addressed" },
+  dropped: { mark: "\u2298", colour: ANSI.dim, label: "dropped" }
+};
+function renderImportance(problem, opts) {
+  const paint = painter(opts.color);
+  if (problem.importance_basis === "evidence") {
+    return paint(ANSI.bold, String(Math.round(problem.importance)).padStart(3));
+  }
+  const value = problem.importance;
+  const word = value >= 67 ? "high" : value >= 34 ? "med" : value > 0 ? "low" : "\u2014";
+  return paint(ANSI.dim, `~${word}`.padStart(5));
+}
+function renderProblems(problems2, duplicates, opts) {
   const paint = painter(opts.color);
-  const width = Math.max(40, columns());
+  if (!problems2.length) {
+    return [
+      "No problems on the list yet.",
+      "",
+      paint(ANSI.dim, "  nanopm review     reads your data, then works out what they say about your users"),
+      paint(ANSI.dim, "  nanopm opportunities         what to work on, for your objective")
+    ].join("\n");
+  }
+  const refWidth = Math.max(...problems2.map((p) => p.ref.length));
   const out = [];
-  const counts = needCounts(tree);
-  out.push(`${paint(ANSI.bold, `${persona.name}\u2019s needs`)}  ${paint(ANSI.dim, `${counts.needs} needs \xB7 ${counts.difficulties + counts.precise} difficulties`)}`);
-  if (!tree.length) {
-    out.push("", `Nothing mapped yet. \`nanopm needs --refresh ${persona.slug}\` maps it in depth; add --short for a quick pass.`);
-    return out.join("\n");
+  const map = groupProblemMap(problems2.map((p) => ({ ...p, parentRef: p.parent_ref })));
+  const ordered = [...map.branches.flatMap((b) => [b.parent, ...b.children]), ...map.unplaced];
+  for (const problem of ordered) {
+    const shape2 = SHAPE2[problem.status] ?? { mark: "\xB7", colour: ANSI.dim, label: problem.status };
+    const score = renderImportance(problem, opts);
+    const head = `${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, problem.ref.padEnd(refWidth))} ${score}  ${problem.parent_ref ? paint(ANSI.dim, "\u21B3 ") : ""}${clip(firstSentence(problem.statement), Math.max(40, columns() - refWidth - 14))}`;
+    out.push(head);
+    if (problem.mapping) out.push(paint(ANSI.dim, `  ${problem.mapping.level === 1 ? "Need" : "Difficulty"} \xB7 ${problem.mapping.knowledge} \xB7 ${problem.mapping.origin === "expert_inference" ? "expert inference" : "source analysis"}`));
+    const indent = `  ${" ".repeat(refWidth)}      `;
+    const tail = problem.proofs > 0 ? `${problem.proofs} proof${problem.proofs === 1 ? "" : "s"}${problem.proof_kinds?.length ? ` \xB7 ${problem.proof_kinds.join(", ")}` : ""}` : problem.importance_note ? `no proof yet \xB7 ${problem.importance_note}` : "no proof yet";
+    out.push(paint(ANSI.dim, indent + clip(tail, Math.max(40, columns() - indent.length))));
   }
-  const line = (n, depth) => {
-    const indent = "  ".repeat(depth);
-    const lead = n.level === 1 ? `${n.emoji ?? " "} ` : `${MARK[n.provenance]} `;
-    const where = n.provenance === "inferred" ? paint(ANSI.dim, ` guess ${n.confidence ?? 0}%`) : n.sources.length ? paint(ANSI.dim, ` ${n.sources.length} source${n.sources.length === 1 ? "" : "s"}`) : "";
-    const state = n.status === "dropped" ? paint(ANSI.dim, " dropped") : n.status === "confirmed" || n.author_kind === "user" ? "" : paint(ANSI.amber, " to review");
-    const label = n.status === "dropped" ? paint(ANSI.dim, n.label) : n.level === 1 ? paint(ANSI.bold, n.label) : n.label;
-    const body = wrap(`${label}${where}${state}${n.proposal ? paint(ANSI.amber, " \xB7 NanoPM suggests a new wording") : ""}`, width - indent.length - 12);
-    out.push(`${indent}${lead}${paint(ANSI.dim, n.ref.padEnd(8))} ${body[0] ?? ""}`);
-    for (const more of body.slice(1)) out.push(`${indent}           ${more}`);
-    for (const c of n.children) line(c, depth + 1);
-  };
-  for (const need of tree) {
+  const unproven = problems2.filter((p) => p.proofs === 0).length;
+  if (unproven) {
     out.push("");
-    line(need, 0);
+    out.push(
+      paint(
+        ANSI.dim,
+        `${unproven} of ${problems2.length} rest on judgement, not proof. A tilde marks those.`
+      )
+    );
   }
-  out.push("", paint(ANSI.dim, `\u25CF observed  \u2013 stated by you  \u25CB NanoPM\u2019s guess. \`nanopm needs confirm <ref>\`, \`nanopm needs drop <ref> "why"\`, \`nanopm needs dig <ref>\`.`));
-  if (opts.others?.length) out.push(paint(ANSI.dim, `Other personas: ${opts.others.join(", ")}.`));
+  if (duplicates.length) {
+    out.push("");
+    for (const pair of duplicates.slice(0, 3)) {
+      const why = pair.flagged ? `NanoPM is not sure ${pair.a} and ${pair.b} are different problems` : `${pair.a} and ${pair.b} read alike`;
+      out.push(paint(ANSI.amber, `? ${why}`));
+    }
+    out.push(paint(ANSI.dim, `  nanopm decisions        why \xB7 nanopm problems merge ${duplicates[0].b} ${duplicates[0].a}`));
+  }
+  if (opts.manualMerges !== void 0) {
+    out.push("");
+    out.push(
+      paint(
+        ANSI.dim,
+        `${opts.manualMerges} merge${opts.manualMerges === 1 ? "" : "s"} you have had to make by hand.`
+      )
+    );
+  }
+  out.push("");
+  out.push(paint(ANSI.dim, "  nanopm problems <ref> \xB7 nanopm problems merge <from> <into> \xB7 nanopm problems weight <ref> <0-100>"));
   return out.join("\n");
 }
-
-// src/commands/needs.ts
-async function people(client, projectId) {
-  const { data, error } = await client.from("memory").select("key, title, content").eq("project_id", projectId).eq("topic", PERSONA_TOPIC).is("superseded_by", null);
-  if (error) throw new Error(`could not read the personas: ${error.message}`);
-  return (data ?? []).filter((r) => PERSONA_KEY.test(r.key)).map((r) => {
-    const p = parsePersona(r.key, r.content);
-    return { slug: p.slug, name: personaName(r.title, p.slug), primary: p.primary };
-  }).sort((a, b) => Number(b.primary) - Number(a.primary));
-}
-function pick2(list, named) {
-  if (!list.length) throw new Error("there is no persona on the business card yet. `nanopm personas --refresh` works out who this is for.");
-  if (!named) return list[0];
-  const one = list.find((p) => p.slug === named.toLowerCase() || p.name.toLowerCase() === named.toLowerCase());
-  if (!one) throw new Error(`no persona "${named}". The personas are: ${list.map((p) => p.slug).join(", ")}.`);
-  return one;
-}
-async function rows(client, projectId, persona) {
-  let q = client.from("need_nodes").select(NEED_NODE_COLUMNS).eq("project_id", projectId);
-  if (persona) q = q.eq("persona", persona);
-  const { data, error } = await q.order("created_at");
-  if (error) throw new Error(`could not read the needs map: ${error.message}`);
-  return data ?? [];
-}
-async function needs(persona, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const list = await people(auth.client, project.id);
-  const who = pick2(list, persona);
-  const tree = needTree(await rows(auth.client, project.id, who.slug));
-  return renderNeeds(who, tree, { color: opts.color ?? useColor(), others: list.filter((p) => p.slug !== who.slug).map((p) => p.slug) });
-}
-async function mapNeeds(target, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const list = await people(auth.client, project.id);
-  let persona;
-  let scope = "map";
-  if (target.ref) {
-    const ref = target.ref.toUpperCase();
-    const node = (await rows(auth.client, project.id)).find((r) => r.ref === ref);
-    if (!node) throw new Error(`no node ${target.ref} on any needs map. \`nanopm needs\` shows the refs.`);
-    persona = pick2(list, node.persona);
-    scope = ref;
-  } else persona = pick2(list, target.persona);
-  const [{ data: active }, tree] = await Promise.all([
-    auth.client.from("jobs").select("params").eq("project_id", project.id).eq("skill", "needs").in("status", [...ACTIVE_STATUSES]),
-    rows(auth.client, project.id, persona.slug).then(needTree)
-  ]);
-  const lineage = (ref) => {
-    const walk = (l) => {
-      for (const n of l) {
-        if (n.ref === ref.toUpperCase()) return n.path.map((p) => p.ref);
-        const deeper = walk(n.children);
-        if (deeper) return deeper;
-      }
-      return null;
-    };
-    return walk(tree) ?? [ref];
-  };
-  const clash = needsRunConflict((active ?? []).map((j) => runScopeOf(j.params)), { persona: persona.slug, scope }, { primary: list.find((p) => p.primary)?.slug ?? list[0]?.slug ?? null, lineage, name: (s) => list.find((p) => p.slug === s)?.name ?? s });
-  if (clash) throw new Error(clash);
-  const repo = await detectRepo(opts.cwd);
-  if (repo) await rememberClone(auth.client, project.id, repo.root);
-  const params = {
-    persona: persona.slug,
-    ...scope === "map" ? {} : { scope },
-    depth: opts.short ? "short" : "deep",
-    ...opts.note?.trim() ? { note: opts.note.trim().slice(0, 600) } : {},
-    ...repo ? { repo_path: repo.root } : {}
-  };
-  return runSkill("needs", { project: project.id, params, cancelSignal: opts.cancelSignal });
-}
-async function confirmNeed(ref, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const { data, error } = await auth.client.from("need_nodes").update({ status: "confirmed" }).eq("project_id", project.id).eq("ref", ref.toUpperCase()).eq("status", "proposed").select("ref, label");
-  if (error) throw new Error(pgMessage(error));
-  if (!data?.length) throw new Error(`${ref} is not a node waiting on your word. \`nanopm needs\` shows which are.`);
-  return `Confirmed ${data[0].ref}: ${data[0].label}. A run proposes beside it from now on, never over it.`;
-}
-async function dropNeed(ref, why, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const { data, error } = await auth.client.from("need_nodes").update({ status: "dropped", drop_reason: why?.trim().slice(0, 400) || "not true of them" }).eq("project_id", project.id).eq("ref", ref.toUpperCase()).in("status", ["proposed", "confirmed"]).select("ref, label");
-  if (error) throw new Error(pgMessage(error));
-  if (!data?.length) throw new Error(`${ref} is not on the map any more.`);
-  return `Dropped ${data[0].ref}: ${data[0].label}. It stays on the record, and NanoPM will not propose it again in the same place.`;
-}
-
-// src/commands/opportunities.ts
-async function lensOf2(client, projectId) {
-  const { data } = await client.from("memory").select("id, key, content").eq("project_id", projectId).eq("topic", GOALS_TOPIC).in("key", [OBJECTIVE_KEY, DEFINITION_KEY]).is("superseded_by", null);
-  const rows2 = data ?? [];
-  const aim = rows2.find((r) => r.key === OBJECTIVE_KEY);
-  const m = aim ? /^Lever:\s*([a-z]+)\.\s*(.*)$/s.exec(aim.content.trim()) : null;
-  const lever = m?.[1];
-  if (!aim || !lever || !OUTCOME_LEVERS.includes(lever)) return null;
-  const def = rows2.find((r) => r.key === DEFINITION_KEY);
-  const parsed = def ? parseDefinition(def.content) : null;
-  const sentence2 = m[2].trim();
-  const definition = parsed && parsed.lever === lever ? parsed.sentence : null;
-  return { id: aim.id, lever, sentence: sentence2, definition, key: lensKey(lever, sentence2, definition) };
-}
-async function loadOpportunities(client, projectId) {
-  const [standing, replaced] = await Promise.all([
-    client.from("opportunities").select(OPPORTUNITY_COLUMNS).eq("project_id", projectId).neq("status", "replaced"),
-    client.from("opportunities").select(REPLACED_COLUMNS).eq("project_id", projectId).eq("status", "replaced")
-  ]);
-  const error = standing.error ?? replaced.error;
-  if (error) throw new Error(`could not read the opportunities: ${error.message}`);
-  return [...standing.data ?? [], ...replaced.data ?? []];
-}
-async function workingOn(client, projectId) {
-  const { data } = await client.from("jobs").select("params").eq("project_id", projectId).eq("skill", SOLUTIONS_SKILL).in("status", [...ACTIVE_STATUSES]);
-  return leavesAtWork((data ?? []).map((j) => j.params));
-}
-async function opportunities(opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const [lens, all, personas2] = await Promise.all([lensOf2(auth.client, project.id), loadOpportunities(auth.client, project.id), people(auth.client, project.id)]);
-  const { shown, drawnFor } = shownMap(all, lens?.key ?? null);
-  const names = new Map(personas2.map((p) => [p.slug, p.name]));
-  return renderOpportunities(shown, lens, { color: opts.color ?? useColor(), previous: drawnFor === "previous", names });
-}
-async function rankOpportunities(opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const list = (s) => s ? s.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
-  const sources2 = opts.use || opts.skip ? { ...opts.use ? { use: list(opts.use) } : {}, ...opts.skip ? { skip: list(opts.skip) } : {} } : void 0;
-  const params = {
-    depth: opts.deep ? "deep" : "short",
-    ...opts.note?.trim() ? { note: opts.note.trim().slice(0, OPPORTUNITIES_NOTE_MAX) } : {},
-    ...sources2 ? { sources: sources2 } : {}
-  };
-  const checked = opportunitiesAsk(params);
-  if (!checked.ok) throw new Error(checked.why);
-  const { data: active } = await auth.client.from("jobs").select("id").eq("project_id", project.id).eq("skill", "opportunities").in("status", [...ACTIVE_STATUSES]);
-  const clash = opportunitiesRunConflict(active ?? []);
-  if (clash) throw new Error(clash);
-  const repo = await detectRepo(opts.cwd);
-  if (repo) await rememberClone(auth.client, project.id, repo.root);
-  return runSkill("opportunities", { project: project.id, params: { ...params, ...repo ? { repo_path: repo.root } : {} }, cancelSignal: opts.cancelSignal });
-}
-async function rpc2(name, args, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const { error } = await auth.client.rpc(name, { p_project_id: project.id, ...args });
-  if (error) throw new Error(pgMessage(error));
-}
-async function confirmOpportunity(ref, opts) {
-  await rpc2("confirm_opportunity", { p_ref: ref }, opts);
-  return `${ref.toUpperCase()} is yours. A later run ranks around it and never replaces it.`;
-}
-async function setAsideOpportunity(ref, why, opts) {
-  await rpc2("set_aside_opportunity", { p_ref: ref, p_reason: why ?? "not now" }, opts);
-  return `${ref.toUpperCase()} is set aside for this objective, with the narrower problems under it. It comes back if the objective changes.`;
+function renderProblem(problem, evidence2, addressedBy, opts) {
+  const paint = painter(opts.color);
+  const shape2 = SHAPE2[problem.status] ?? { mark: "\xB7", colour: ANSI.dim, label: problem.status };
+  const width = columns();
+  const out = [];
+  out.push(`${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, problem.ref)}  ${paint(ANSI.bold, shape2.label)}`);
+  out.push("");
+  for (const line of wrap(problem.statement, width)) out.push(line);
+  out.push("");
+  const facts = [];
+  const m = problem.mapping ?? null;
+  if (m) {
+    const story = problemStory(m, { proofs: problem.proofs, kinds: problem.proof_kinds ?? [], provenance: problem.provenance ?? "inferred", authorKind: problem.author_kind ?? "nanopm", createdAt: problem.created_at ?? "" });
+    out.push(...wrap(story.story, width));
+    out.push("");
+    out.push(...wrap(story.doubt, width).map((l) => paint(ANSI.dim, l)));
+    out.push(...wrap(story.assumes ? `${story.test} ${story.assumes}` : story.test, width).map((l) => paint(ANSI.dim, l)));
+    out.push("");
+    out.push(paint(ANSI.dim, "how I got here"));
+    facts.push(["kind", `${m.level === 1 ? "a need" : "a difficulty"} \xB7 ${m.knowledge} \xB7 ${m.origin === "expert_inference" ? "expert inference" : "source analysis"}`]);
+    if (m.parent_reason) facts.push(["grouping", m.parent_reason]);
+  }
+  if (problem.segment) facts.push(["who", problem.segment]);
+  facts.push([
+    "weight",
+    problem.importance_basis === "evidence" ? `${Math.round(problem.importance)} from ${problem.proofs} piece${problem.proofs === 1 ? "" : "s"} of proof` : `${Math.round(problem.importance)}, a judgement${problem.importance_note ? ` \u2014 ${problem.importance_note}` : ""}`
+  ]);
+  if (problem.parent_ref) facts.push(["part of", problem.parent_ref]);
+  for (const [label, value] of facts) {
+    out.push(`${paint(ANSI.dim, label.padEnd(9))}${clip(value, width - 9)}`);
+  }
+  if (evidence2.length) {
+    out.push("");
+    out.push(paint(ANSI.dim, "sources"));
+    for (const item of evidence2) {
+      const when = (item.occurred_at ?? item.created_at).slice(0, 10);
+      const where = item.metric_key ?? item.source_ref ?? item.kind;
+      for (const line of wrap(item.body, width - 2)) out.push(`  ${line}`);
+      out.push(paint(ANSI.dim, `  \u2014 ${item.relation ?? "supports"} \xB7 ${item.kind} \xB7 ${where} \xB7 ${when}`));
+    }
+  } else {
+    out.push("");
+    out.push(paint(ANSI.dim, "No proof yet. This ranking is a judgement, and the next review may settle it."));
+  }
+  if (addressedBy.length) {
+    out.push("");
+    out.push(paint(ANSI.dim, "addressed by"));
+    for (const item of addressedBy) {
+      out.push(`  ${paint(ANSI.dim, item.ref)}  ${clip(item.title, width - 12)} ${paint(ANSI.dim, `(${item.status})`)}`);
+    }
+  }
+  out.push("");
+  out.push(paint(ANSI.dim, "  nanopm problems \xB7 nanopm roadmap"));
+  return out.join("\n");
 }
-async function moveOpportunity(ref, place, opts) {
-  const rank2 = Number(place);
-  if (!Number.isInteger(rank2) || rank2 < 1) throw new Error("say where: nanopm opportunities move <ref> <place>, a place from 1");
-  await rpc2("move_opportunity", { p_ref: ref, p_rank: rank2 }, opts);
-  return `${ref.toUpperCase()} is at #${rank2} among its siblings, and the place is yours. Moved above a higher priority, it takes that priority.`;
+
+// src/format/tree.ts
+var SOLUTION_SHAPE = {
+  proposed: { mark: "\u25CB", colour: ANSI.amber, label: "proposed" },
+  accepted: { mark: "\u25D0", colour: ANSI.green, label: "accepted" },
+  building: { mark: "\u25D4", colour: ANSI.blue, label: "building" },
+  done: { mark: "\u25CF", colour: ANSI.green, label: "done" },
+  rejected: { mark: "\u2298", colour: ANSI.red, label: "rejected" },
+  dropped: { mark: "\u2298", colour: ANSI.dim, label: "dropped" }
+};
+var PROBLEM_SHAPE = {
+  candidate: { mark: "\u25CB", colour: ANSI.dim },
+  confirmed: { mark: "\u25C9", colour: ANSI.amber },
+  addressed: { mark: "\u25CF", colour: ANSI.green },
+  dropped: { mark: "\u2298", colour: ANSI.dim }
+};
+var NO_AREA = "no area yet";
+var SHOWN = /* @__PURE__ */ new Set(["proposed", "accepted", "building", "done"]);
+function renderTree(problems2, solutions, strategy, opts) {
+  const paint = painter(opts.color);
+  const out = [];
+  const width = Math.max(40, columns());
+  if (strategy) {
+    out.push(paint(ANSI.bold, "Strategy"));
+    for (const line of wrap(strategy, width - 4)) out.push(`  ${line}`);
+    out.push("");
+  }
+  const shown = solutions.filter((s) => SHOWN.has(s.status));
+  const open = problems2.filter((p) => p.status !== "dropped" && (!opts.alongside || shown.some((s) => s.problem_id === p.id)));
+  if (opts.alongside && !open.length) return "";
+  if (!open.length && !shown.length) {
+    out.push("No problems yet. `nanopm opportunities` shows what to work on.");
+    return out.join("\n");
+  }
+  const byProblem = /* @__PURE__ */ new Map();
+  for (const s of shown) byProblem.set(s.problem_id, [...byProblem.get(s.problem_id) ?? [], s]);
+  const refWidth = Math.max(...[...open.map((p) => p.ref), ...shown.map((s) => s.ref)].map((r) => r.length), 5);
+  for (const [area, rows2] of groupByArea(open)) {
+    out.push(paint(ANSI.bold, area));
+    for (const p of rows2) {
+      const shape2 = PROBLEM_SHAPE[p.status] ?? { mark: "\xB7", colour: "" };
+      const kind = p.kind === "founder" ? paint(ANSI.dim, " (founder)") : "";
+      const proof = p.proofs ? `${p.proofs} proof${p.proofs === 1 ? "" : "s"}` : "no proof";
+      const tail = `${renderImportance(p, opts)}  ${paint(ANSI.dim, proof)}`;
+      const head = `  ${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, p.ref.padEnd(refWidth))}  `;
+      out.push(head + clip(p.statement, Math.max(30, width - visibleLength(head) - visibleLength(tail) - 2)) + kind + "  " + tail);
+      const under = byProblem.get(p.id) ?? [];
+      if (!under.length) {
+        out.push(paint(ANSI.dim, `    ${" ".repeat(refWidth + 2)}  no solution yet`));
+        continue;
+      }
+      for (const s of under) out.push(...solutionLines(s, refWidth, width, paint));
+    }
+    out.push("");
+  }
+  const waiting = shown.filter((s) => s.status === "proposed").length;
+  if (waiting) {
+    out.push(`${waiting} waiting on you.`);
+    out.push(paint(ANSI.dim, '  nanopm accept <ref> \xB7 nanopm reject <ref> "why" \xB7 nanopm roadmap <ref> \xB7 nanopm roadmap --board'));
+  } else if (!opts.alongside) {
+    out.push(paint(ANSI.dim, "Nothing waiting on you."));
+  }
+  return out.join("\n").trimEnd();
 }
-async function rewordOpportunity(ref, problem, opts) {
-  const text2 = problem?.trim().replace(/\s+/g, " ") ?? "";
-  if (!text2) throw new Error('say it: nanopm opportunities reword <ref> "the problem, in your words"');
-  if (text2.length > PROBLEM_MAX) throw new Error(`one line, under ${PROBLEM_MAX} characters`);
-  await rpc2("restate_opportunity", { p_ref: ref, p_problem: text2 }, opts);
-  return `Kept in your words: ${text2}`;
+function solutionLines(s, refWidth, width, paint, indent = 6) {
+  const shape2 = SOLUTION_SHAPE[s.status] ?? { mark: "\xB7", colour: "", label: s.status };
+  const pad = " ".repeat(indent);
+  const STATE = { accepted: "chosen", building: "building", done: "done" };
+  const tail = s.actor === "founder" ? "yours to do" : s.outcome ? s.outcome : s.status === "proposed" ? s.assumption ? clip(s.assumption, 40) : null : STATE[s.status] ?? null;
+  const badge = tail ? paint(ANSI.dim, `  ${tail}`) : "";
+  const head = `${pad}${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, s.ref.padEnd(refWidth))}  `;
+  const lines = [head + clip(s.title, Math.max(30, width - visibleLength(head) - visibleLength(badge))) + badge];
+  const reason2 = `${pad}  ${" ".repeat(refWidth)}  `;
+  lines.push(paint(ANSI.dim, reason2 + clip(firstSentence(s.reasoning), Math.max(30, width - reason2.length))));
+  return lines;
 }
-var AWAKE_MS = 12e4;
-async function awakeDaemon(client, userId) {
-  const since = new Date(Date.now() - AWAKE_MS).toISOString();
-  const [{ data }, local] = await Promise.all([
-    client.from("daemons").select("id, hostname").eq("user_id", userId).in("status", ["online", "running"]).gte("last_seen_at", since).order("last_seen_at", { ascending: false }),
-    localDaemonId()
-  ]);
-  return data?.find((d) => d.id === local) ?? data?.[0] ?? null;
+function groupByArea(problems2) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const p of problems2) {
+    const area = p.area ?? NO_AREA;
+    groups.set(area, [...groups.get(area) ?? [], p]);
+  }
+  const named = [...groups.entries()].filter(([a]) => a !== NO_AREA);
+  const rest = groups.get(NO_AREA);
+  return rest ? [...named, [NO_AREA, rest]] : named;
 }
-async function brainstorm(ref, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const [lens, all, busy] = await Promise.all([lensOf2(auth.client, project.id), loadOpportunities(auth.client, project.id), workingOn(auth.client, project.id)]);
-  const deep = Boolean(opts.deep);
-  const plan = brainstormPlan(shownMap(all, lens?.key ?? null).shown, ref, deep, new Set(busy.keys()));
-  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 brainstorm again.");
-  const repo = deep ? await detectRepo(opts.cwd) : null;
-  if (repo) await rememberClone(auth.client, project.id, repo.root);
-  for (const params of plan.jobs) {
-    const { error } = await auth.client.from("jobs").insert({ project_id: project.id, skill: SOLUTIONS_SKILL, params: { ...params, ...repo ? { repo_path: repo.root } : {} }, requested_by: auth.userId, trigger: "user", target_daemon_id: daemon.id });
-    if (error) throw new Error(`could not queue the brainstorm: ${error.message}`);
+var BOARD_COLUMNS = [
+  { status: "proposed", label: "Proposed" },
+  { status: "accepted", label: "Chosen" },
+  { status: "building", label: "Building" },
+  { status: "done", label: "Done" }
+];
+function renderBoard(problems2, solutions, opts) {
+  const paint = painter(opts.color);
+  const out = [];
+  const byId = new Map(problems2.map((p) => [p.id, p]));
+  const width = Math.max(40, columns());
+  const refWidth = Math.max(...solutions.map((s) => s.ref.length), 5);
+  for (const col of BOARD_COLUMNS) {
+    const rows2 = solutions.filter((s) => s.status === col.status);
+    out.push(`${paint(ANSI.bold, col.label)} ${paint(ANSI.dim, String(rows2.length))}`);
+    if (!rows2.length) out.push(paint(ANSI.dim, "  \u2014"));
+    for (const s of rows2) {
+      const shape2 = SOLUTION_SHAPE[s.status];
+      const problem = byId.get(s.problem_id);
+      const head = `  ${paint(shape2.colour, shape2.mark)} ${paint(ANSI.dim, s.ref.padEnd(refWidth))}  `;
+      out.push(head + clip(s.title, Math.max(30, width - visibleLength(head))));
+      const under = [problem ? `${problem.ref} ${clip(problem.statement, 50)}` : "its problem was dropped", s.assumption ? clip(s.assumption, 40) : null].filter(Boolean).join(" \xB7 ");
+      out.push(paint(ANSI.dim, `  ${" ".repeat(refWidth + 2)}  ${under}`));
+    }
+    out.push("");
   }
-  const n = plan.leaves.length;
-  const minutes = deep ? DEEP_MINUTES * n : FLASH_MINUTES;
-  const what = plan.problem.children.length ? `the ${n} narrower problem${n === 1 ? "" : "s"} under ${plan.problem.ref}` : `${plan.problem.ref} \u201C${clip(plan.problem.problem, 60)}\u201D`;
-  const how = deep ? `${DEPTH_WORD.deep}${n > 1 ? ", one after the other" : ""}` : `${DEPTH_WORD.quick}, a first pass`;
-  const out = [`${deep ? "Going deeper on" : "Brainstorming"} ${what}: ${how}, about ${minutes} minutes on ${daemon.hostname}.`];
-  if (plan.problem.children.length) for (const l of plan.leaves) out.push(`  ${l.ref.padEnd(8)} ${clip(l.problem, Math.max(30, columns() - 11))}`);
-  if (plan.busy) out.push(`${plan.busy} left out: Nano is already finding solutions to ${plan.busy === 1 ? "it" : "them"}.`);
-  out.push("The solutions land on `nanopm roadmap`.");
-  return out.join("\n");
+  return out.join("\n").trimEnd();
 }
 
 // src/commands/roadmap.ts
@@ -15568,8 +15794,8 @@ async function decide(kind, ref, body, opts) {
   const row = Array.isArray(data) ? data[0] : void 0;
   if (!row) throw new Error(`nothing changed for ${ref}`);
   if (onMap) {
-    const next2 = card?.others[0];
-    const after = !card ? "" : next2 ? ` ${next2.ref} \u201C${next2.title}\u201D takes its card in ${HORIZON_WORD[card.horizon]}.` : ` Its card leaves the board: nothing else answers ${card.leaf.ref} yet. \`nanopm opportunities brainstorm ${card.leaf.ref}\` finds more.`;
+    const next = card?.others[0];
+    const after = !card ? "" : next ? ` ${next.ref} \u201C${next.title}\u201D takes its card in ${HORIZON_WORD[card.horizon]}.` : ` Its card leaves the board: nothing else answers ${card.leaf.ref} yet. \`nanopm opportunities brainstorm ${card.leaf.ref}\` finds more.`;
     return `Thrown out: ${row.ref}${body?.trim() ? ` \u2014 ${body.trim()}` : ""}.${after}`;
   }
   const verb = kind === "accept" ? "Accepted" : "Rejected";
@@ -15586,123 +15812,65 @@ function normalizeRef(input, items) {
   return given;
 }
 
-// src/commands/next.ts
-async function next(opts) {
+// 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 autonomy2 = await readAutonomy(auth.client, project.id);
-  if (autonomy2 === "propose") {
-    throw new Error(
-      `${project.name} is on "propose", so NanoPM may look but not touch.
-  nanopm autonomy execute_after_validation   to let it change files, asking you first`
-    );
-  }
-  const { data: items, error } = await auth.client.from("solutions").select("id, ref, title, rank, status").eq("project_id", project.id).is("superseded_by", null).eq("status", "accepted").eq("actor", "nanopm").order("rank");
-  if (error) throw new Error(`could not read the solutions: ${error.message}`);
-  const accepted = items ?? [];
-  if (!accepted.length) {
-    throw new Error("nothing is accepted yet. Run `nanopm roadmap`, then `nanopm accept <ref>`.");
-  }
-  let item = accepted[0];
-  if (opts.ref) {
-    const wanted = normalizeRef(opts.ref, accepted);
-    const found = accepted.find((i) => i.ref === wanted);
-    if (!found) {
-      throw new Error(`${opts.ref} is not an accepted solution NanoPM can build. Accepted: ${accepted.map((i) => i.ref).join(", ")}.`);
-    }
-    item = found;
-  }
   const repo = await detectRepo(opts.cwd);
-  if (!repo) throw new Error("run this inside the repository, so NanoPM changes the clone you are looking at");
+  if (!repo) throw new Error("run this inside the repository, so NanoPM builds from the clone you are looking at");
+  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 daemonId = await localDaemonId();
-  const { data: job, error: queueError } = await auth.client.from("jobs").insert({
-    project_id: project.id,
-    skill: "next",
-    params: { solution_id: item.id, repo_path: repo.root },
-    requested_by: auth.userId,
-    target_daemon_id: daemonId
-  }).select("id").single();
-  if (queueError || !job) throw new Error(`could not queue the work: ${queueError?.message}`);
-  out(`${item.ref}  ${item.title}`);
-  const answerer = opts.answersFile ? await answersFromFile(opts.answersFile) : answersFromTerminal(out);
-  return streamJob(auth.client, job.id, { pollMs: 700, out, renderer, cancelSignal: opts.cancelSignal, answerer, verbose: verboseWanted() });
-}
-async function readAutonomy(client, projectId) {
-  const { data } = await client.from("project_preferences").select("autonomy").eq("project_id", projectId).maybeSingle();
-  return data?.autonomy ?? "propose";
-}
-var EXPLAINED = {
-  propose: "NanoPM reads and proposes. It never changes a file.",
-  execute_after_validation: "NanoPM changes files, on its own branch, after showing you what it will do and waiting for a yes.",
-  execute_then_report: "NanoPM acts first and tells you after. Not available yet."
-};
-async function autonomy(level, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const current = await readAutonomy(auth.client, project.id);
-  if (!level) {
-    const lines = [`${project.name} is on "${current}".`, ""];
-    for (const l of AUTONOMY_LEVELS) {
-      lines.push(`  ${l === current ? "\u25CF" : "\u25CB"} ${l.padEnd(26)} ${EXPLAINED[l]}`);
-    }
-    lines.push("", "  nanopm autonomy <level>");
-    return lines.join("\n");
-  }
-  const wanted = level.trim();
-  if (!AUTONOMY_LEVELS.includes(wanted)) {
-    throw new Error(`"${level}" is not a level. Pick one of: ${AUTONOMY_LEVELS.join(", ")}.`);
-  }
-  if (wanted === "execute_then_report") {
-    throw new Error(
-      "execute_then_report is not available yet. NanoPM asks before it changes anything until the review loop has been used in anger."
-    );
-  }
-  if (wanted === current) return `${project.name} is already on "${current}".`;
-  const { error } = await auth.client.from("project_preferences").update({ autonomy: wanted }).eq("project_id", project.id);
-  if (error) {
-    throw new Error(`could not change the dial: ${error.message}`);
-  }
-  return [`${project.name} is now on "${wanted}".`, EXPLAINED[wanted]].join("\n");
-}
-async function verifyCommand(command, opts) {
-  const auth = await authenticate();
-  const project = await resolveProject(auth.client, { projectId: opts.projectId, cwd: opts.cwd });
-  const { data } = await auth.client.from("project_preferences").select("verify_command").eq("project_id", project.id).maybeSingle();
-  const current = data?.verify_command ?? null;
-  if (!command && !opts.clear) {
-    if (!current) {
-      return [
-        `${project.name} has no check, so nothing verifies what NanoPM writes.`,
-        "",
-        '  nanopm verify "npm run lint && npm test"',
-        "",
-        "The daemon runs it in the repository root after a change and before the solution is",
-        "marked done. A failure goes back to NanoPM once, to fix."
-      ].join("\n");
-    }
-    return [`${project.name} verifies with:`, "", `  ${current}`, "", '  nanopm verify "<command>" \xB7 nanopm verify --clear'].join("\n");
-  }
-  const next2 = opts.clear ? null : command.trim();
-  if (next2 !== null && !next2) throw new Error('a check needs a command: nanopm verify "npm test"');
-  const { error } = await auth.client.from("project_preferences").update({ verify_command: next2 }).eq("project_id", project.id);
-  if (error) throw new Error(`could not save the check: ${error.message}`);
-  if (next2 === null) return `${project.name} no longer runs a check. Nothing will verify what NanoPM writes.`;
-  return [
-    `${project.name} will verify with:`,
-    "",
-    `  ${next2}`,
-    "",
-    "It runs in the repository root. If your change touches what the command itself runs \u2014",
-    "package.json, a lockfile, the script it calls \u2014 the check is skipped and you are told,",
-    "because an agent that can rewrite its own examiner is not being examined."
-  ].join("\n");
+  const { jobId } = await queueBuild(auth.client, {
+    projectId: project.id,
+    userId: auth.userId,
+    daemonId: local,
+    ref: solution.ref,
+    repoPath: repo.root,
+    anyway: opts.anyway,
+    ...stopped ? { resumeOf: { id: stopped.id, was: stopped.was, origin: stopped.origin } } : {}
+  });
+  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 readFile12 } from "fs/promises";
-import { join as join14 } 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",
@@ -15752,7 +15920,7 @@ async function envFiles(repoRoot) {
   const out = [];
   for (const file of ENV_FILES) {
     try {
-      out.push({ file, env: parseEnv(await readFile12(join14(repoRoot, file), "utf8")) });
+      out.push({ file, env: parseEnv(await readFile15(join17(repoRoot, file), "utf8")) });
     } catch {
       continue;
     }
@@ -15812,7 +15980,7 @@ function describeUrl(url) {
 // src/format/closing.ts
 function closingLines(project, exit, env = process.env, mode = "onboard") {
   if (exit !== 0) return [];
-  const build = mode === "start" ? `nanopm accept <ref> takes an option; when one needs code, in its repo: nanopm onboard --project ${project.id ?? "<id>"} attaches it, then nanopm next builds it` : "nanopm accept <ref> takes an option, nanopm next builds it";
+  const build2 = mode === "start" ? `nanopm accept <ref> takes an option; when one needs code, in its repo: nanopm onboard --project ${project.id ?? "<id>"} attaches it, then nanopm build <ref> builds it` : "nanopm spec <ref> --write writes its specs, nanopm build <ref> builds it";
   const chain = chainedAfter(mode).map((skill) => skillSentence(skill));
   return [
     "",
@@ -15820,7 +15988,7 @@ function closingLines(project, exit, env = process.env, mode = "onboard") {
     ...chain.length ? [`NanoPM is now ${joinAnd(chain)}; the Roadmap fills in as it goes. Watch it at ${webUrl(env)}/p/${project.slug}/journal`] : [],
     // The map is no longer chained after onboarding, so the first three clauses are what
     // builds it: what users said, where they leave traces, then the map that reads both.
-    `Next: nanopm add <file> adds what users said \xB7 nanopm connect adds where they leave traces \xB7 nanopm opportunities run ranks what to work on \xB7 ${build} \xB7 nanopm schedule weekly monday 7 sets the review`,
+    `Next: nanopm add <file> adds what users said \xB7 nanopm connect adds where they leave traces \xB7 nanopm opportunities run ranks what to work on \xB7 ${build2} \xB7 nanopm schedule weekly monday 7 sets the review`,
     "With a partner: nanopm invite <email> prints a link; they open it, or in their clone: nanopm login, then nanopm join <code>"
   ];
 }
@@ -16521,7 +16689,7 @@ async function seedWatches(watches2, read6) {
 }
 
 // src/commands/watch.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 function cursorFor(source, watchId) {
   const all = source.cursor ?? {};
   return all[watchId] ?? {};
@@ -16582,7 +16750,7 @@ async function addWatch(labelOrId, id, opts) {
   const paint = painter(color);
   if (!labelOrId || !id) throw new Error('say which feed and what to call it: nanopm watch add <source> <id> --query "\u2026"');
   if (opts.query && opts.queryFile) throw new Error("--query or --query-file, not both");
-  const query = opts.queryFile ? await readFile13(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 });
@@ -16769,9 +16937,9 @@ async function review(opts) {
   }
   const usable = connections.filter((c) => c.status === "ok");
   if (!usable.length) {
-    const failed = connections.map((c) => c.label).join(", ");
+    const failed2 = connections.map((c) => c.label).join(", ");
     throw new Error(
-      `no connection is working (${failed}), so a review would have nothing to read.
+      `no connection is working (${failed2}), so a review would have nothing to read.
   nanopm connect --list                      see what is wrong`
     );
   }
@@ -17406,12 +17574,12 @@ function renderDirection(rows2) {
   const out = [];
   for (const line of DIRECTION_ROWS) {
     const row = rows2.find((r) => r.key === directionKey(line));
-    const next2 = rows2.find((r) => r.key === directionKey(line, true));
+    const next = rows2.find((r) => r.key === directionKey(line, true));
     out.push(`${DIRECTION_ROW_TITLE[line]}${mark(row)}`);
     out.push(`  ${row?.content ?? "\u2014"}`);
-    if (next2) {
-      const because = reasonOf2(next2.sources);
-      out.push(`  proposed: ${next2.content}${because ? `  \xB7 ${because}` : ""}`);
+    if (next) {
+      const because = reasonOf2(next.sources);
+      out.push(`  proposed: ${next.content}${because ? `  \xB7 ${because}` : ""}`);
     }
   }
   out.push("Objective");
@@ -17451,13 +17619,13 @@ function render2(rows2) {
   const out = [];
   for (const line of PITCH_LINE_KEYS) {
     const row = rows2.find((r) => r.key === pitchKey(line));
-    const next2 = rows2.find((r) => r.key === pitchKey(line, true));
+    const next = rows2.find((r) => r.key === pitchKey(line, true));
     const mark2 = row && row.provenance !== "stated" ? `  \xB7 to review${row.confidence != null ? ` (${row.confidence}% sure)` : ""}` : "";
     out.push(`${PITCH_LINE_TITLE[line]}${mark2}`);
     out.push(`  ${row?.content ?? "\u2014"}`);
-    if (next2) {
-      const because = reasonOf3(next2.sources);
-      out.push(`  proposed: ${next2.content}${because ? `  \xB7 ${because}` : ""}`);
+    if (next) {
+      const because = reasonOf3(next.sources);
+      out.push(`  proposed: ${next.content}${because ? `  \xB7 ${because}` : ""}`);
     }
   }
   return out.join("\n");
@@ -17515,7 +17683,7 @@ async function invite(email, opts) {
   const [, ...rest] = inviteLines({ name: project.name, code, email: email.trim().toLowerCase(), web: webUrl() });
   return [`Invite to ${paint(ANSI.bold, project.name)}: ${paint(ANSI.bold, code)}`, ...rest.map((l) => l ? paint(ANSI.dim, l) : l)].join("\n");
 }
-async function join15(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);
@@ -17800,7 +17968,7 @@ async function showSchedule(opts) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 async function status(opts) {
   const auth = await authenticate();
   const color = opts.color ?? useColor();
@@ -17853,7 +18021,7 @@ async function projectStatus(client, project) {
     openProblems: (problems2.data ?? []).length,
     unprovenProblems: (problems2.data ?? []).filter((p) => p.importance_basis === "judgment").length,
     search: describeSearch(search, await localWebSearch()),
-    onThisMachine: Boolean(project.repoPath && existsSync6(project.repoPath)),
+    onThisMachine: Boolean(project.repoPath && existsSync8(project.repoPath)),
     measures: measures({
       solutionStatuses: (roadmap2.data ?? []).map((r) => r.status),
       decisions: decisions2.data ?? [],
@@ -18216,7 +18384,7 @@ function buildProgram() {
     console.log(await invite(email, { cwd: process.cwd(), projectId: opts.project, color: colorOf(opts) }));
   });
   program.command("join <code>").description("Join a project you were invited to, from inside your clone of its repository").option("--no-color", "plain output").action(async (code, opts) => {
-    console.log(await join15(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) }));
@@ -18238,16 +18406,11 @@ function buildProgram() {
   program.command("status").description("What is happening with this product: next review, what is waiting on you, whether the daemon is awake").option("--project <id>", "project id (default: the project of the current repo)").option("--no-color", "plain output").action(async (opts) => {
     console.log(await status({ cwd: process.cwd(), projectId: opts.project, color: colorOf(opts) }));
   });
-  program.command("next [ref]").description("Build an accepted solution, or the top one: a branch, a diff, and a pull request").option("--project <id>", "project id (default: the project of the current repo)").option("--ref <ref>", "same as the positional argument").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 next({
-      cwd: process.cwd(),
-      projectId: opts.project,
-      ref: ref ?? opts.ref,
-      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 }));