wayari 0.1.0

package/dist/evidence.mjs

@@ -0,0 +1,1848 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+
+// scripts/evidence.mjs
+import { existsSync as existsSync2 } from "node:fs";
+import { readdir as readdir2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// src/shared/factory/channel.ts
+function isWorkChannel(channel2) {
+  return channel2.type === "work";
+}
+
+// src/shared/factory/pipeline.ts
+var PIPELINE_STAGES = ["plan", "build", "verify", "ship"];
+var STAGES_FOR_SIZE = {
+  small: ["build", "ship"],
+  full: ["plan", "build", "verify", "ship"]
+};
+
+// src/core/factory/channels/create.ts
+function createWorkChannel(input) {
+  const goal = input.goal.trim();
+  if (!goal) throw new Error("A work channel needs a goal, because the goal is what says it is finished.");
+  return {
+    id: input.id,
+    type: "work",
+    categoryId: input.categoryId,
+    name: input.name,
+    goal,
+    pipeline: {
+      size: input.size,
+      stage: STAGES_FOR_SIZE[input.size][0],
+      attempts: [],
+      ...input.requiredChecks?.length ? { requiredChecks: [...new Set(input.requiredChecks)] } : {}
+    },
+    shifts: [],
+    worktrees: [],
+    budgetSpent: { spentUsd: 0, startedAt: input.now },
+    memory: { content: "", updatedAt: input.now },
+    ...input.blockedBy?.length ? { blockedBy: [...new Set(input.blockedBy)] } : {},
+    ...input.crew?.length ? { crew: input.crew.map((member) => ({ ...member })) } : {},
+    ...input.builders !== void 0 && !input.crew?.length ? { builders: input.builders } : {}
+  };
+}
+function createFeedChannel(input) {
+  return {
+    id: input.id,
+    type: "feed",
+    ...input.categoryId ? { categoryId: input.categoryId } : {},
+    ...input.name ? { name: input.name } : {},
+    members: [...new Set(input.members)]
+  };
+}
+function createCategory(input) {
+  const name = input.name.trim();
+  if (!name) throw new Error("A category needs a name.");
+  if (!input.repoPath) throw new Error("A category needs the repo every one of its channels binds to.");
+  return { id: input.id, name, repoPath: input.repoPath, leadMemberId: input.leadMemberId, roster: [] };
+}
+function assertOneWorktreePerMember(worktrees) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const tree of worktrees) {
+    if (seen.has(tree.memberId)) {
+      throw new Error(`${tree.memberId} already holds a worktree in this channel, and one member gets one.`);
+    }
+    seen.add(tree.memberId);
+  }
+}
+var WORK_ONLY_FIELDS = {
+  goal: true,
+  pipeline: true,
+  shifts: true,
+  worktrees: true,
+  budget: true,
+  budgetSpent: true,
+  memory: true,
+  blockedBy: true,
+  crew: true,
+  builders: true,
+  pr: true,
+  archive: true
+};
+function assertThinFeed(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+  const record = value;
+  const carried = Object.keys(WORK_ONLY_FIELDS).filter((field) => record[field] !== void 0);
+  if (carried.length === 0) return;
+  throw new Error(
+    `A feed channel cannot hold ${carried.join(", ")}. A feed channel never ships, so it owns no pipeline, no worktree and no budget.`
+  );
+}
+function archiveChannel(channel2, endState, now) {
+  if (channel2.archive) return channel2;
+  return {
+    ...channel2,
+    shifts: channel2.shifts.map((shift) => shift.endedAt === void 0 ? { ...shift, endedAt: now } : shift),
+    archive: { archivedAt: now, endState }
+  };
+}
+
+// src/core/factory/channels/paths.ts
+import { join } from "node:path";
+var REPO_CHANNELS_DIR = join(".wayari", "channels");
+var LEGACY_REPO_CHANNELS_DIR = join(".skribbl", "channels");
+var USER_DATA_FACTORY_DIR = "factory";
+function sanitizeChannelId(channelId) {
+  const safe = channelId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  if (safe === "" || safe === "." || safe === "..") {
+    throw new Error(`A channel id of "${channelId}" would not stay inside its own directory.`);
+  }
+  return safe;
+}
+function channelLocation(userDataDir2, repoPath, channelId) {
+  return {
+    channelId,
+    repoPath,
+    userDataPath: join(userDataDir2, USER_DATA_FACTORY_DIR, sanitizeChannelId(channelId))
+  };
+}
+function repoRecordPath(location) {
+  return join(location.repoPath, REPO_CHANNELS_DIR, `${sanitizeChannelId(location.channelId)}.json`);
+}
+function legacyRepoRecordPath(location) {
+  return join(location.repoPath, LEGACY_REPO_CHANNELS_DIR, `${sanitizeChannelId(location.channelId)}.json`);
+}
+function runtimeRecordPath(location) {
+  return join(location.userDataPath, "runtime.json");
+}
+function runtimePathFor(userDataDir2, channelId) {
+  return join(userDataDir2, USER_DATA_FACTORY_DIR, sanitizeChannelId(channelId), "runtime.json");
+}
+function feedRecordPath(userDataDir2, channelId) {
+  return join(userDataDir2, USER_DATA_FACTORY_DIR, sanitizeChannelId(channelId), "feed.json");
+}
+function categoriesPath(userDataDir2) {
+  return join(userDataDir2, USER_DATA_FACTORY_DIR, "categories.json");
+}
+function evidencePathFor(userDataDir2, channelId) {
+  return join(userDataDir2, USER_DATA_FACTORY_DIR, sanitizeChannelId(channelId), "evidence.json");
+}
+
+// src/core/factory/channels/records.ts
+var CHANNEL_FILE_VERSION = 1;
+function splitWork(channel2, repoPath, claims = {}) {
+  return {
+    repo: {
+      version: CHANNEL_FILE_VERSION,
+      id: channel2.id,
+      type: "work",
+      categoryId: channel2.categoryId,
+      name: channel2.name,
+      // An empty `blockedBy` is dropped rather than written. Absent and empty mean the same thing,
+      // and `"blockedBy": []` in every channel file is a line in a teammate's diff that says nothing.
+      record: {
+        goal: channel2.goal,
+        pipeline: channel2.pipeline,
+        memory: channel2.memory,
+        ...channel2.blockedBy?.length ? { blockedBy: [...channel2.blockedBy] } : {},
+        // Same rule as `blockedBy`: absent and empty mean the same thing, and an empty list in every
+        // channel file is a line in a teammate's diff that says nothing.
+        ...channel2.crew?.length ? { crew: channel2.crew.map((member) => ({ ...member })) } : {},
+        ...channel2.builders !== void 0 ? { builders: channel2.builders } : {}
+      }
+    },
+    runtime: {
+      version: CHANNEL_FILE_VERSION,
+      id: channel2.id,
+      type: "work",
+      categoryId: channel2.categoryId,
+      repoPath,
+      record: { budgetSpent: channel2.budgetSpent, claims },
+      shifts: channel2.shifts,
+      worktrees: channel2.worktrees,
+      budget: channel2.budget,
+      pr: channel2.pr,
+      archive: channel2.archive
+    }
+  };
+}
+function joinWork(repo, runtime) {
+  return {
+    id: runtime.id,
+    type: "work",
+    categoryId: runtime.categoryId,
+    name: repo.name,
+    goal: repo.record.goal,
+    pipeline: repo.record.pipeline,
+    shifts: runtime.shifts,
+    worktrees: runtime.worktrees,
+    budget: runtime.budget,
+    budgetSpent: runtime.record.budgetSpent,
+    memory: repo.record.memory,
+    pr: runtime.pr,
+    archive: runtime.archive,
+    ...repo.record.blockedBy?.length ? { blockedBy: [...repo.record.blockedBy] } : {},
+    ...repo.record.crew?.length ? { crew: repo.record.crew.map((member) => ({ ...member })) } : {},
+    ...repo.record.builders !== void 0 ? { builders: repo.record.builders } : {}
+  };
+}
+function emptyRuntimeFor(repo, repoPath) {
+  return {
+    version: CHANNEL_FILE_VERSION,
+    id: repo.id,
+    type: "work",
+    categoryId: repo.categoryId,
+    repoPath,
+    record: { budgetSpent: { spentUsd: 0, startedAt: 0 }, claims: {} },
+    shifts: [],
+    worktrees: []
+  };
+}
+function toFeedFile(channel2) {
+  return {
+    version: CHANNEL_FILE_VERSION,
+    id: channel2.id,
+    type: "feed",
+    categoryId: channel2.categoryId,
+    name: channel2.name,
+    members: channel2.members
+  };
+}
+function fromFeedFile(file) {
+  return {
+    id: file.id,
+    type: "feed",
+    categoryId: file.categoryId,
+    name: file.name,
+    members: file.members
+  };
+}
+
+// src/core/factory/channels/store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/core/factory/channels/files.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function readJson(path, options = {}) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return void 0;
+    throw error;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    if (options.rescue !== false) await quarantine(path);
+    return void 0;
+  }
+}
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await rename(temporaryPath, path);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function quarantine(path) {
+  const kept = `${path}.bad-${Date.now()}`;
+  try {
+    await rename(path, kept);
+  } catch {
+    console.warn(`[wayari] ${path} was not readable as JSON and could not be moved aside; it is still there`);
+    return false;
+  }
+  console.warn(`[wayari] ${path} was not readable as JSON; kept it beside itself as ${kept}`);
+  return true;
+}
+
+// src/shared/agents/config.ts
+var AGENTS = {
+  claude: {
+    id: "claude",
+    label: "Claude Code",
+    color: "#d97757",
+    launch: "claude",
+    hasHooks: true,
+    prompt: { kind: "flag" }
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    color: "#10a37f",
+    launch: "codex",
+    hasHooks: true,
+    prompt: { kind: "flag" }
+  },
+  // `gemini <prompt>` (and `-p`) runs one-shot and exits. The flag submits the prompt and keeps the
+  // session open, which is the only shape we can put on a canvas.
+  gemini: {
+    id: "gemini",
+    label: "Gemini",
+    color: "#4285f4",
+    launch: "gemini",
+    hasHooks: true,
+    prompt: { kind: "flag", flag: "--prompt-interactive" }
+  },
+  // grok's launch command is a placeholder. Confirm the real CLI in Phase 1 and file a contract
+  // change if different. hasHooks:false means the node summons and runs, but the badge stays idle.
+  // No key on any machine we have, so both prompt variants only ever rendered an auth error.
+  // Untested is untested: `none` until the pty test can actually run.
+  grok: {
+    id: "grok",
+    label: "Grok",
+    color: "#8b8b8b",
+    launch: "grok",
+    hasHooks: false,
+    prompt: { kind: "none" }
+  },
+  // Devin is a cloud agent first; the launch command assumes a local CLI shim on PATH. Same
+  // summon-and-run tier as grok: hasHooks:false, so no status seam, no authority links, no
+  // agent-requested spawns. Promoting it is a contract change once a hook seam actually exists.
+  devin: {
+    id: "devin",
+    label: "Devin",
+    color: "#6d5ce7",
+    launch: "devin",
+    hasHooks: false,
+    prompt: { kind: "none" }
+  },
+  // OpenCode (opencode.ai). Launch command machine-verified against v1.18.15 (`opencode` bare
+  // opens the TUI in the cwd): see Orchestration/CONTRACT-CHANGES.md 2026-08-08. Same
+  // summon-and-run tier as grok/devin - hasHooks:false, and in no capability list until each
+  // flag's BEHAVIOR is tested, not just its presence in --help.
+  // Its brand is a neutral dark, which grok already wears; magenta is the accent no other agent
+  // holds, in either theme.
+  // `opencode --prompt <msg>` submits and stays interactive (pty-tested, v1.18.15). Its bare
+  // positional is a project path, and `opencode run <msg>` is the one-shot.
+  // Cursor's CLI. Every line here is read off Cursor's own documentation on 2026-08-24, because no
+  // machine we have has it installed and a guessed spelling fails at spawn looking like an outage.
+  //
+  // THE BINARY IS `cursor-agent`, THOUGH THE DOCS NOW WRITE `agent`. The installer symlinks both
+  // into `~/.local/bin` (cursor.com/docs/cli/installation), and `agent` is a name any unrelated
+  // program can take, so probing PATH for it would report somebody else's binary as Cursor.
+  //
+  // The prompt rides as a bare positional, which is the docs' own first example:
+  // `agent "refactor the auth module to use JWT tokens"`. `-p/--print` is what makes a run
+  // one-shot, so a positional with no flag is the interactive shape a canvas needs.
+  //
+  // hasHooks:false: Cursor publishes no hook seam we have read, so the node summons and runs and
+  // the badge stays idle. Same tier as grok and devin.
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    // Cursor's own ink is black on white, which no theme here can spend on a mark. This is the
+    // steel the app gives a vendor whose brand is monochrome, and no other agent holds it: grok's
+    // neutral is a flat grey and this reads blue beside it.
+    color: "#5b7a99",
+    launch: "cursor-agent",
+    hasHooks: false,
+    prompt: { kind: "flag" }
+  },
+  opencode: {
+    id: "opencode",
+    label: "OpenCode",
+    color: "#b83280",
+    launch: "opencode",
+    // True since 2026-08-17: it reaches the bridge. Not a claim that it REPORTS status, which is
+    // `STATUS_CAPABLE` and still Claude alone, and the same arrangement codex and gemini have had
+    // since they were added.
+    hasHooks: true,
+    prompt: { kind: "flag", flag: "--prompt" }
+  }
+};
+var HOOK_CAPABLE = ["claude", "codex", "gemini", "opencode"];
+var HOOK_CAPABLE_USAGE = HOOK_CAPABLE.join("|");
+var HOOK_CAPABLE_PROSE = HOOK_CAPABLE.length > 1 ? `${HOOK_CAPABLE.slice(0, -1).join(", ")} or ${HOOK_CAPABLE[HOOK_CAPABLE.length - 1]}` : HOOK_CAPABLE.join("");
+var DOCK_ORDER = ["claude", "codex", "grok", "gemini", "devin", "opencode", "cursor"];
+var OFFERED_AGENTS = DOCK_ORDER.filter((id) => id !== "devin");
+
+// src/shared/agents/models.ts
+var CLAUDE_MODELS = ["fable", "opus", "sonnet", "haiku"];
+var CODEX_MODELS = ["gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.4-mini"];
+var AGENT_MODELS = {
+  claude: CLAUDE_MODELS,
+  codex: CODEX_MODELS
+};
+var MODEL_CAPABLE = Object.keys(AGENT_MODELS);
+function modelsFor(agentId2) {
+  const models = agentId2 ? AGENT_MODELS[agentId2] : void 0;
+  return models ?? [];
+}
+function isModelIdFor(agentId2, value) {
+  return typeof value === "string" && modelsFor(agentId2).some((model) => model === value);
+}
+
+// src/shared/role-presets.ts
+var ROLE_PRESETS = [
+  // ── Builder ────────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.builder",
+    name: "Builder",
+    archetype: "builder",
+    stance: "writes",
+    head: true,
+    blurb: "Writes the feature end to end, in the style the repo already uses.",
+    instructions: "You build. Write the change the user asked for, end to end, and leave it working.\n\nRead the code around the change before you write any of it, and follow the conventions you find there rather than the ones you prefer. Match the naming, the file layout and the comment density of the files you are editing. When the request is ambiguous, make the ordinary choice and say which one you made."
+  },
+  {
+    id: "builtin.implementer",
+    name: "Implementer",
+    archetype: "builder",
+    stance: "writes",
+    blurb: "Takes a settled plan and turns it into working code, without redesigning it.",
+    instructions: "You implement a decision that has already been made. The design is not yours to relitigate: build what was specified.\n\nIf you find a real problem with the plan, say so in a sentence or two and keep building under a stated assumption. Finish the whole thing, including the parts that are dull. Report what you skipped and why, rather than reporting done."
+  },
+  {
+    id: "builtin.prototyper",
+    name: "Prototyper",
+    archetype: "builder",
+    stance: "writes",
+    blurb: "Fastest thing that proves the idea. Throwaway code, and it says so.",
+    instructions: "You prototype. The goal is to answer a question about whether something works or feels right, in the least code that can answer it.\n\nSkip the tests, the error handling and the edge cases on purpose. Hardcode what you would otherwise wire up. Say plainly at the end that this is throwaway code and name what would have to be real before it ships."
+  },
+  {
+    id: "builtin.refactorer",
+    name: "Refactorer",
+    archetype: "builder",
+    stance: "writes",
+    blurb: "Changes shape, never behaviour. Leaves the tests green at every step.",
+    instructions: "You refactor. Behaviour does not change: the same inputs produce the same outputs when you are done.\n\nRun the tests before you start so you know they were green. Work in steps small enough that you can run them again after each one. If you find a bug while you are in there, do not fix it in the same change; report it and leave it."
+  },
+  {
+    id: "builtin.migrator",
+    name: "Migrator",
+    archetype: "builder",
+    stance: "writes",
+    blurb: "Moves code to a new API or version, one mechanical step at a time.",
+    instructions: "You migrate code from one API, framework or version to the next.\n\nFind every call site before you change any of them, and say how many there are. Prefer one mechanical transformation applied everywhere over a clever rewrite of each. Do not improve the code while you are converting it: a migration that also refactors is a migration nobody can review."
+  },
+  {
+    id: "builtin.janitor",
+    name: "Janitor",
+    archetype: "builder",
+    stance: "writes",
+    blurb: "Deletes dead code, unused deps and stale flags, after proving each one is unused.",
+    instructions: "You remove things. Dead code, unused dependencies, flags nobody reads, files nothing imports.\n\nProve it before you delete it: search the whole repo, including tests, config, scripts and docs. Anything reached by a dynamic name, a string key or a build step counts as used. List what you removed and the evidence for each. When you are not sure, leave it and say why."
+  },
+  // ── Inspector ──────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.inspector",
+    name: "Inspector",
+    archetype: "inspector",
+    stance: "reads",
+    head: true,
+    blurb: "Reads the work and reports what is wrong with it. Does not edit.",
+    instructions: "You inspect. Read the work and report what is wrong with it. Do not edit any file.\n\nRank what you find by what it would actually cost, and give each one a concrete failure: the input, the state and the wrong result. Say when you are unsure rather than padding the list. Finding nothing is a real answer and you may give it."
+  },
+  {
+    id: "builtin.reviewer",
+    name: "Reviewer",
+    archetype: "inspector",
+    stance: "reads",
+    blurb: "Reads the diff and reports problems. Never edits.",
+    instructions: "You review a diff. Report problems; do not fix them and do not edit any file.\n\nFor each finding give the file, the line, the failure it causes and how sure you are. Judge the change against the code around it, not against how you would have written it from scratch. Style opinions with no consequence are noise: leave them out."
+  },
+  {
+    id: "builtin.debugger",
+    name: "Debugger",
+    archetype: "inspector",
+    stance: "writes",
+    blurb: "Reproduces first, one hypothesis at a time, fixes the cause not the symptom.",
+    instructions: "You debug. Reproduce the failure before you theorise about it, and say exactly how you reproduced it.\n\nForm one hypothesis at a time and test it. When a fix works, say why it works: a change that makes the symptom go away without an explanation is not a fix. Leave the diagnostic scaffolding out of the final change."
+  },
+  {
+    id: "builtin.test-writer",
+    name: "Test Writer",
+    archetype: "inspector",
+    stance: "writes",
+    blurb: "Writes the failing test before the fix. Covers the edges, not the happy path twice.",
+    instructions: "You write tests. Write the failing test first and watch it fail, so you know it tests something.\n\nCover the edges: empty, missing, duplicate, out of order, too large, concurrent. Test behaviour through the public seam rather than the internals, so a refactor does not break the suite. Match the style of the tests already in the repo."
+  },
+  {
+    id: "builtin.security",
+    name: "Security Auditor",
+    archetype: "inspector",
+    stance: "reads",
+    blurb: "Hunts injection, secrets, authz holes and unsafe defaults. Reports, does not patch.",
+    instructions: "You audit for security. Do not edit any file; report what you find.\n\nLook for untrusted input reaching a sink, secrets in the repo or in logs, missing authorisation between authentication and the action, unsafe defaults, and dependencies with known holes. Give each finding a severity you can defend and a concrete path an attacker would take. Do not pad the report with theoretical issues."
+  },
+  {
+    id: "builtin.performance",
+    name: "Performance Profiler",
+    archetype: "inspector",
+    stance: "writes",
+    blurb: "Measures before it changes anything. No optimisation without a number.",
+    instructions: "You work on performance, and you measure first. State the number you are starting from and how you got it.\n\nFind where the time or the memory actually goes rather than where you expect it to. Change one thing, measure again, and report both numbers. An optimisation with no measurement behind it does not go in."
+  },
+  {
+    id: "builtin.red-team",
+    name: "Red Team",
+    archetype: "inspector",
+    stance: "reads",
+    blurb: "Argues the other side on purpose. Tries to break the plan before it is built.",
+    instructions: "You argue against. Take the plan or the code in front of you and try to break it. Do not edit any file.\n\nName the assumption it rests on that could be false, the case it does not handle, and the way it fails in production rather than in the demo. Be specific: an objection with no scenario attached is a mood. If you cannot break it, say so, and say what you tried."
+  },
+  // ── Scout ──────────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.scout",
+    name: "Scout",
+    archetype: "scout",
+    stance: "reads",
+    head: true,
+    blurb: "Goes and finds out, then reports. Reads only.",
+    instructions: "You find things out and report back. Do not edit any file.\n\nAnswer the question that was asked, with the evidence attached: file and line for code, a link for anything external. Say what you could not determine rather than filling the gap with a plausible guess."
+  },
+  {
+    id: "builtin.cartographer",
+    name: "Cartographer",
+    archetype: "scout",
+    stance: "reads",
+    blurb: "Maps an unfamiliar codebase. Returns the shape and the seams, not a file list.",
+    instructions: "You map unfamiliar code. Do not edit any file.\n\nReturn the shape: the few zones the code divides into, what each one owns, and the seams between them. Name the files that matter and skip the ones that do not. A directory listing is not a map. Finish with where a newcomer should make their first change."
+  },
+  {
+    id: "builtin.explainer",
+    name: "Explainer",
+    archetype: "scout",
+    stance: "reads",
+    blurb: "Answers questions about the code in plain language. Reads, never writes.",
+    instructions: "You explain code to someone who has not read it. Do not edit any file.\n\nAnswer in plain language, shortest path first, and cite the file and line so the reader can go and look. Explain what the code does and why it is like that, when the repo says why. Do not invent a rationale that is not there."
+  },
+  {
+    id: "builtin.researcher",
+    name: "Researcher",
+    archetype: "scout",
+    stance: "reads",
+    blurb: "Gathers options from outside the repo, then recommends one with reasons.",
+    instructions: "You research options outside this repo. Do not edit any file.\n\nGather the real candidates, compare them on the things this project actually cares about, and recommend one. Give the trade-off you are accepting, not just the win. Say how current your information is, and flag anything you could not verify."
+  },
+  // ── Shipper ────────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.shipper",
+    name: "Shipper",
+    archetype: "shipper",
+    stance: "writes",
+    head: true,
+    blurb: "Takes finished work the last mile and verifies it landed.",
+    instructions: "You ship. Take work that is finished and get it out: build it, release it, document it, announce it.\n\nVerify the result rather than the command. A green exit code is not evidence the artifact works. Say what you checked and what you could not."
+  },
+  {
+    id: "builtin.release",
+    name: "Release Engineer",
+    archetype: "shipper",
+    stance: "writes",
+    blurb: "Versions, builds, signs and publishes. Verifies the artifact before calling it done.",
+    instructions: "You cut releases. Follow the repo's own release process rather than inventing one, and read it first.\n\nCheck the working tree is clean and on the right branch before you build. After publishing, fetch the published artifact and verify it, rather than trusting the upload. Never skip a signing or verification step to save time; say if one failed."
+  },
+  {
+    id: "builtin.ci-fixer",
+    name: "CI Fixer",
+    archetype: "shipper",
+    stance: "writes",
+    blurb: "Owns the red build. Reads the log, reproduces locally, keeps going until green.",
+    instructions: "You own a failing build. Read the actual log before you guess, and find the first failure rather than the loudest one.\n\nReproduce it locally where you can. Fix the cause. Never make a test pass by weakening what it asserts, and never disable one without saying you did and why. Keep going until it is green."
+  },
+  {
+    id: "builtin.docs",
+    name: "Docs Writer",
+    archetype: "shipper",
+    stance: "writes",
+    blurb: "Writes for a reader who has not seen the code. Updates what exists before adding more.",
+    instructions: "You write documentation for someone who has not seen this code.\n\nUpdate what already exists before you add a new file; a second document about the same thing is how both go stale. Show the command or the snippet rather than describing it. Cut every sentence that would not change what the reader does."
+  },
+  {
+    id: "builtin.changelog",
+    name: "Changelog Writer",
+    archetype: "shipper",
+    stance: "writes",
+    blurb: "Turns commits into user-facing lines: what changed for a person, not for a file.",
+    instructions: "You turn commits into a changelog a user reads.\n\nEvery line says what changed for the person using the app, not which file moved. Group by what it means to them: new, fixed, changed. Drop the internal refactors nobody outside can see. Keep each line to one sentence."
+  },
+  // ── Designer ───────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.designer",
+    name: "Designer",
+    archetype: "designer",
+    stance: "writes",
+    head: true,
+    blurb: "Works on how it looks and feels, using the tokens that already exist.",
+    instructions: "You work on the design: layout, spacing, hierarchy, motion and the empty and error states.\n\nUse the design tokens and components the project already has. Do not invent a new colour, a new radius or a new font size when an existing one is close. Every state gets designed, not only the full one: empty, loading, error, too much content."
+  },
+  {
+    id: "builtin.interface",
+    name: "Interface",
+    archetype: "designer",
+    stance: "writes",
+    blurb: "Builds the component: real states, real focus, real motion.",
+    instructions: "You build interface. The component is not done when it renders; it is done when every state of it does.\n\nHandle hover, focus, active, disabled, loading, empty and overflow. Make focus visible and the keyboard path work. Keep motion short and give it a reason. Match the surrounding components rather than starting a second style."
+  },
+  {
+    id: "builtin.copy-editor",
+    name: "Copy Editor",
+    archetype: "designer",
+    stance: "writes",
+    blurb: "Tightens UI text and docs. Cuts words that carry no weight.",
+    instructions: 'You edit the words. Cut every word that carries no weight, and say each thing once.\n\nOne idea per sentence, active voice, and name the thing rather than writing "this". Write the way a person speaks to someone they respect: no hype, no corporate fog. An error message says what happened and what to do next.'
+  },
+  {
+    id: "builtin.accessibility",
+    name: "Accessibility",
+    archetype: "designer",
+    stance: "writes",
+    blurb: "Keyboard paths, focus order, labels and contrast. Tests with the mouse put away.",
+    instructions: "You work on accessibility. Walk the whole flow with the keyboard alone before you change anything.\n\nCheck focus order, visible focus, labels on every control, correct roles, and contrast. Announce what changes: a live region for anything that appears without a click. Prefer a real element over a div with a role bolted on."
+  },
+  // ── Director ───────────────────────────────────────────────────────────────────────────────────
+  {
+    id: "builtin.director",
+    name: "Director",
+    archetype: "director",
+    stance: "reads",
+    head: true,
+    blurb: "Decides and delegates rather than doing. Writes no code.",
+    instructions: "You direct. Decide what should happen and who should do it. Do not write the code yourself.\n\nSplit the work so the pieces do not collide, say what each piece is done when, and name the order they have to happen in. Where you are choosing between approaches, give the trade-off and pick one."
+  },
+  {
+    id: "builtin.architect",
+    name: "Architect",
+    archetype: "director",
+    stance: "reads",
+    blurb: "Designs before building. Produces a plan with trade-offs, and writes no code.",
+    instructions: "You design before anything is built. Do not write the implementation.\n\nRead enough of the existing code to know what shape it is already. Produce a plan: the seams, what each piece owns, what changes on disk, and what could go wrong. Give the alternative you rejected and why. Name the one-way doors."
+  },
+  {
+    id: "builtin.lead",
+    name: "Lead",
+    archetype: "director",
+    stance: "reads",
+    blurb: "Splits work across the agents wired to it and integrates what comes back.",
+    instructions: "You lead the agents wired to you. Do not edit any file yourself: the work goes to them, and a lead who starts coding stops leading.\n\nSplit the work so two of them never edit the same file, brief each one with enough context to start without asking, and integrate what comes back. Check the work rather than accepting the report. When a piece comes back wrong, say specifically what is wrong and send it back."
+  },
+  {
+    id: "builtin.scope-keeper",
+    name: "Scope Keeper",
+    archetype: "director",
+    stance: "reads",
+    blurb: "Guards the brief. Flags anything the request did not ask for.",
+    instructions: "You guard the scope. Hold the work against what was actually asked for. Do not edit any file.\n\nFlag anything added that nobody requested, anything requested that is missing, and anything quietly narrowed. Say which of the three each item is. Cutting scope is the user's decision, so report it rather than approving it."
+  }
+];
+var BY_ID = new Map(ROLE_PRESETS.map((preset) => [preset.id, preset]));
+
+// src/shared/factory-crew.ts
+var STAFF_ROLES = ["lead", "worker", "reviewer"];
+function isStaffRole(value) {
+  return typeof value === "string" && STAFF_ROLES.includes(value);
+}
+
+// src/core/factory/channels/parse.ts
+var BUILTIN_AGENT_IDS = Object.keys(AGENTS);
+function agentId(value) {
+  if (typeof value !== "string") return void 0;
+  if (BUILTIN_AGENT_IDS.includes(value)) return value;
+  return value.startsWith("custom:") && value.length > "custom:".length ? value : void 0;
+}
+function bag(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function strList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function isStage(value) {
+  return typeof value === "string" && PIPELINE_STAGES.includes(value);
+}
+function isSize(value) {
+  return value === "small" || value === "full";
+}
+function parseGateResult(value) {
+  const raw = bag(value);
+  const gate = bag(raw?.gate);
+  const fromStage = gate?.fromStage;
+  const ranAt = num(raw?.ranAt);
+  const attempt = num(raw?.attempt);
+  if (!raw || !gate || !isStage(fromStage) || ranAt === void 0 || attempt === void 0) return void 0;
+  const requiresRoleSignoff = gate.requiresRoleSignoff === true;
+  const base = {
+    gate: {
+      fromStage,
+      machineChecks: strList(gate.machineChecks),
+      requiresRoleSignoff
+    },
+    passed: raw.passed === true,
+    attempt,
+    failures: strList(raw.failures),
+    ranAt
+  };
+  if (!requiresRoleSignoff) {
+    if (raw.requiresRoleSignoff === true || str(raw.signedByMemberId) !== void 0) return void 0;
+    return { ...base, requiresRoleSignoff: false };
+  }
+  const signedByMemberId = str(raw.signedByMemberId);
+  if (!signedByMemberId || raw.requiresRoleSignoff === false) return void 0;
+  return { ...base, requiresRoleSignoff: true, signedByMemberId };
+}
+function parsePipeline(value) {
+  const raw = bag(value);
+  if (!raw || !isSize(raw.size)) return void 0;
+  const walked = STAGES_FOR_SIZE[raw.size];
+  const stage = isStage(raw.stage) && walked.includes(raw.stage) ? raw.stage : walked[0];
+  const attempts = Array.isArray(raw.attempts) ? raw.attempts.map(parseGateResult).filter((entry) => entry !== void 0) : [];
+  const requiredChecks = strList(raw.requiredChecks);
+  return { size: raw.size, stage, attempts, ...requiredChecks.length ? { requiredChecks } : {} };
+}
+function parseBinding(value) {
+  const raw = bag(value);
+  if (!raw) return void 0;
+  const nodeId = str(raw.nodeId);
+  const attempt = num(raw.attempt);
+  const sha = raw.startedAtSha;
+  const startedAtSha = sha === null ? null : str(sha);
+  if (!nodeId || attempt === void 0 || startedAtSha === void 0) return void 0;
+  const handovers = num(raw.handovers);
+  return { nodeId, startedAtSha, attempt, ...handovers !== void 0 && handovers > 0 ? { handovers } : {} };
+}
+function parseShift(value) {
+  const raw = bag(value);
+  const memberId = str(raw?.memberId);
+  const agent = agentId(raw?.agentId);
+  const startedAt = num(raw?.startedAt);
+  if (!raw || !memberId || !agent || startedAt === void 0) return void 0;
+  const endedAt = num(raw.endedAt);
+  const binding = parseBinding(raw.binding);
+  return {
+    memberId,
+    agentId: agent,
+    roleIds: strList(raw.roleIds),
+    ...binding ? { binding } : {},
+    startedAt,
+    ...endedAt === void 0 ? {} : { endedAt }
+  };
+}
+function firstWorktreePerMember(worktrees) {
+  const seen = /* @__PURE__ */ new Set();
+  return worktrees.filter((tree) => {
+    if (seen.has(tree.memberId)) return false;
+    seen.add(tree.memberId);
+    return true;
+  });
+}
+function parseWorktree(value) {
+  const raw = bag(value);
+  const memberId = str(raw?.memberId);
+  const path = str(raw?.path);
+  const branch = str(raw?.branch);
+  if (!memberId || !path || !branch) return void 0;
+  return { memberId, path, branch };
+}
+function parseClaim(value) {
+  const raw = bag(value);
+  const channelId = str(raw?.channelId);
+  const memberId = str(raw?.memberId);
+  const path = str(raw?.path);
+  const claimedAt = num(raw?.claimedAt);
+  if (!channelId || !memberId || !path || claimedAt === void 0) return void 0;
+  return { channelId, memberId, path, claimedAt };
+}
+function parseClaimSet(value) {
+  const raw = bag(value);
+  if (!raw) return {};
+  const claims = {};
+  for (const [path, entry] of Object.entries(raw)) {
+    const claim = parseClaim(entry);
+    if (claim) claims[path] = claim;
+  }
+  return claims;
+}
+function parseRepoFile(value) {
+  const raw = bag(value);
+  const record = bag(raw?.record);
+  const id = str(raw?.id);
+  const categoryId = str(raw?.categoryId);
+  const name = str(raw?.name);
+  const goal = str(record?.goal);
+  const pipeline = parsePipeline(record?.pipeline);
+  if (!raw || raw.type !== "work" || !id || !categoryId || !name || !goal || !pipeline) return void 0;
+  const memory = bag(record?.memory);
+  const blockedBy = parseBlockedBy(record?.blockedBy, id);
+  const crew = parseCrew(record?.crew);
+  const buildersRaw = num(record?.builders);
+  const builders = buildersRaw !== void 0 && Number.isInteger(buildersRaw) && buildersRaw >= 1 ? buildersRaw : void 0;
+  return {
+    version: num(raw.version) ?? CHANNEL_FILE_VERSION,
+    id,
+    type: "work",
+    categoryId,
+    name,
+    record: {
+      goal,
+      pipeline,
+      memory: {
+        content: typeof memory?.content === "string" ? memory.content : "",
+        updatedAt: num(memory?.updatedAt) ?? 0
+      },
+      ...blockedBy.length ? { blockedBy } : {},
+      ...crew.length ? { crew } : {},
+      ...builders !== void 0 ? { builders } : {}
+    }
+  };
+}
+function parseCrew(value) {
+  if (!Array.isArray(value) || !value.length) return [];
+  const crew = [];
+  for (const entry of value) {
+    const raw = bag(entry);
+    const role = raw?.role;
+    const agent = raw?.agentId;
+    const model = raw?.model;
+    if (!isStaffRole(role)) return [];
+    if (typeof agent !== "string" || !Object.hasOwn(AGENTS, agent)) return [];
+    if (typeof model !== "string" || !isModelIdFor(agent, model)) return [];
+    crew.push({ role, agentId: agent, model });
+  }
+  return crew;
+}
+function parseBlockedBy(value, self) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const id = str(entry);
+    if (!id || id === self) continue;
+    seen.add(id);
+  }
+  return [...seen];
+}
+function parseRuntimeFile(value) {
+  const raw = bag(value);
+  const id = str(raw?.id);
+  const categoryId = str(raw?.categoryId);
+  const repoPath = str(raw?.repoPath);
+  if (!raw || raw.type !== "work" || !id || !categoryId || !repoPath) return void 0;
+  const record = bag(raw.record);
+  const spent = bag(record?.budgetSpent);
+  const budget = parseBudget(bag(raw.budget));
+  const pr = parsePullRequest(bag(raw.pr));
+  const archive = parseArchive(bag(raw.archive));
+  return {
+    version: num(raw.version) ?? CHANNEL_FILE_VERSION,
+    id,
+    type: "work",
+    categoryId,
+    repoPath,
+    record: {
+      budgetSpent: { spentUsd: num(spent?.spentUsd) ?? 0, startedAt: num(spent?.startedAt) ?? 0 },
+      claims: parseClaimSet(record?.claims)
+    },
+    shifts: Array.isArray(raw.shifts) ? raw.shifts.map(parseShift).filter((entry) => entry !== void 0) : [],
+    worktrees: firstWorktreePerMember(
+      Array.isArray(raw.worktrees) ? raw.worktrees.map(parseWorktree).filter((entry) => entry !== void 0) : []
+    ),
+    ...budget ? { budget } : {},
+    ...pr ? { pr } : {},
+    ...archive ? { archive } : {}
+  };
+}
+function parseBudget(raw) {
+  const limitUsd = num(raw?.limitUsd);
+  const endsAt = num(raw?.endsAt);
+  if (limitUsd === void 0 || endsAt === void 0) return void 0;
+  return {
+    limitUsd,
+    endsAt,
+    armedByMemberId: str(raw?.armedByMemberId) ?? "",
+    armedAt: num(raw?.armedAt) ?? 0
+  };
+}
+function parsePullRequest(raw) {
+  const ref = str(raw?.ref);
+  const status = raw?.status;
+  if (!ref || !isPrStatus(status)) return void 0;
+  return { ref, status, openedAt: num(raw?.openedAt) ?? 0 };
+}
+function parseArchive(raw) {
+  const endState = raw?.endState;
+  if (!isEndState(endState)) return void 0;
+  return { archivedAt: num(raw?.archivedAt) ?? 0, endState };
+}
+var PR_STATUSES = {
+  draft: true,
+  ready: true,
+  merged: true,
+  closed: true
+};
+var END_STATES = {
+  shipped: true,
+  held: true,
+  "out-of-money": true,
+  "out-of-clock": true,
+  died: true
+};
+function isPrStatus(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(PR_STATUSES, value);
+}
+function isEndState(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(END_STATES, value);
+}
+function parseFeedFile(value) {
+  assertThinFeed(value);
+  const raw = bag(value);
+  const id = str(raw?.id);
+  if (!raw || raw.type !== "feed" || !id) return void 0;
+  const categoryId = str(raw.categoryId);
+  const name = str(raw.name);
+  return {
+    version: num(raw.version) ?? CHANNEL_FILE_VERSION,
+    id,
+    type: "feed",
+    ...categoryId ? { categoryId } : {},
+    ...name ? { name } : {},
+    members: strList(raw.members)
+  };
+}
+function parseEmployedAgent(value, taken) {
+  const raw = bag(value);
+  const memberId = str(raw?.memberId);
+  const agent = agentId(raw?.agentId);
+  if (!memberId || !agent) return void 0;
+  const defaultModel = str(raw?.defaultModel);
+  const name = str(raw?.name);
+  return {
+    memberId,
+    agentId: agent,
+    ...name && !taken.has(name) ? { name } : {},
+    defaultRoleIds: strList(raw?.defaultRoleIds),
+    ...defaultModel ? { defaultModel } : {}
+  };
+}
+function parseCategory(value) {
+  const raw = bag(value);
+  const id = str(raw?.id);
+  const name = str(raw?.name);
+  const repoPath = str(raw?.repoPath);
+  if (!id || !name || !repoPath) return void 0;
+  const roster = [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const seat of Array.isArray(raw?.roster) ? raw.roster : []) {
+    const employed = parseEmployedAgent(seat, taken);
+    if (!employed) continue;
+    if (employed.name) taken.add(employed.name);
+    roster.push(employed);
+  }
+  return { id, name, repoPath, leadMemberId: str(raw?.leadMemberId) ?? "", roster };
+}
+function parseCategoriesFile(value) {
+  const raw = bag(value);
+  const list = Array.isArray(raw?.categories) ? raw.categories : Array.isArray(value) ? value : [];
+  return {
+    version: num(raw?.version) ?? CHANNEL_FILE_VERSION,
+    categories: list.map(parseCategory).filter((entry) => entry !== void 0)
+  };
+}
+
+// src/core/factory/channels/store.ts
+var ChannelStore = class {
+  constructor(userDataDir2, options = {}) {
+    this.userDataDir = userDataDir2;
+    this.now = options.now ?? (() => Date.now());
+    this.newId = options.newId ?? (() => randomUUID2());
+    this.rescue = options.rescue ?? true;
+  }
+  userDataDir;
+  now;
+  newId;
+  rescue;
+  /** The tail of the read-modify-write queue. Never rejects: each turn swallows before the next. */
+  pending = Promise.resolve();
+  /** Settle whatever turn is in flight. Tests await this. */
+  async flush() {
+    await this.pending.catch(() => void 0);
+  }
+  // -- categories -----------------------------------------------------------------------------
+  categories() {
+    return this.enqueue(() => this.readCategories());
+  }
+  category(id) {
+    return this.enqueue(async () => (await this.readCategories()).find((entry) => entry.id === id));
+  }
+  /** Create a category and hand back the category itself rather than the list: the caller has just
+   *  named a thing and needs its id to make a channel under it. */
+  createCategory(input) {
+    return this.enqueue(async () => {
+      const category = createCategory({ ...input, id: input.id ?? this.newId() });
+      const current = await this.readCategories();
+      await this.writeCategories([...current.filter((entry) => entry.id !== category.id), category]);
+      return category;
+    });
+  }
+  /** Upsert by id. Order is the roster's only ordering and an existing id keeps its seat. */
+  saveCategory(category) {
+    return this.enqueue(async () => {
+      const current = await this.readCategories();
+      const at = current.findIndex((entry) => entry.id === category.id);
+      const next = at === -1 ? [...current, category] : current.map((e, i) => i === at ? category : e);
+      await this.writeCategories(next);
+      return next;
+    });
+  }
+  // -- channels -------------------------------------------------------------------------------
+  /**
+   * Create a work channel under a category and persist both halves at once.
+   *
+   * The repo comes from the category and is never passed in: one channel binds to exactly one repo,
+   * inherited from its category (ticket 02). A channel whose category is gone cannot be created,
+   * because there would be nowhere to commit its goal.
+   */
+  createWork(input) {
+    return this.enqueue(async () => {
+      const category = (await this.readCategories()).find((entry) => entry.id === input.categoryId);
+      if (!category) throw new Error(`No category ${input.categoryId}, so there is no repo to commit its goal to.`);
+      const channel2 = createWorkChannel({ ...input, id: input.id ?? this.newId(), now: this.now() });
+      await this.writeWork(channel2, category.repoPath, {});
+      return channel2;
+    });
+  }
+  createFeed(input) {
+    return this.enqueue(async () => {
+      const channel2 = createFeedChannel({ ...input, id: input.id ?? this.newId() });
+      await writeJson(feedRecordPath(this.userDataDir, channel2.id), toFeedFile(channel2));
+      return channel2;
+    });
+  }
+  /** Persist a channel that already exists. Claims are passed separately, and omitting them keeps
+   *  whatever is already on disk rather than clearing it: a caller saving a stage transition has no
+   *  business dropping another agent's claims. */
+  save(channel2, claims) {
+    return this.enqueue(async () => {
+      if (!isWorkChannel(channel2)) {
+        await writeJson(feedRecordPath(this.userDataDir, channel2.id), toFeedFile(channel2));
+        return;
+      }
+      const repoPath = await this.repoPathFor(channel2);
+      const held = claims ?? (await this.readRuntime(channel2.id))?.record.claims ?? {};
+      await this.writeWork(channel2, repoPath, held);
+    });
+  }
+  /** Replace the claims held against a channel, leaving both other halves alone. */
+  saveClaims(channelId, claims) {
+    return this.enqueue(async () => {
+      const runtime = await this.readRuntime(channelId);
+      if (!runtime) throw new Error(`No channel ${channelId} in userData, so its claims have nowhere to go.`);
+      await writeJson(runtimeRecordPath(this.locationOf(channelId, runtime.repoPath)), {
+        ...runtime,
+        record: { ...runtime.record, claims }
+      });
+    });
+  }
+  /** One channel, both halves, or undefined when there is no such channel. A work channel whose
+   *  committed half is missing is NOT half-loaded: the goal and the pipeline are the channel, and a
+   *  channel with neither cannot say what it is doing or where it is. */
+  load(channelId) {
+    return this.enqueue(() => this.readChannel(channelId));
+  }
+  /** A work channel and the claims held against it. Undefined for a feed channel, which holds none. */
+  loadWork(channelId) {
+    return this.enqueue(async () => {
+      const runtime = await this.readRuntime(channelId);
+      if (!runtime) return void 0;
+      const channel2 = await this.readChannel(channelId);
+      if (!channel2 || !isWorkChannel(channel2)) return void 0;
+      return { channel: channel2, claims: runtime.record.claims };
+    });
+  }
+  /**
+   * Every channel this machine knows about, work and feed, and every one it could not read.
+   *
+   * The failures come back rather than being swallowed. A `catch (() => undefined)` here made a
+   * channel with a bad record vanish from the listing with no error and no log line, which is a
+   * worse version of the mistake `assertThinFeed` throws to avoid: the surface renders a room short
+   * and nobody can say which room or why. A caller that only wants the good ones reads `channels`.
+   *
+   * No order is promised. Neither store has one, so the caller sorts by whatever it is showing.
+   */
+  list(categoryId) {
+    return this.enqueue(async () => {
+      const ids = await this.channelIds();
+      const read = await Promise.all(
+        ids.map(async (channelId) => {
+          try {
+            return { channelId, channel: await this.readChannel(channelId) };
+          } catch (error) {
+            return { channelId, reason: error instanceof Error ? error.message : String(error) };
+          }
+        })
+      );
+      const channels2 = [];
+      const failed = [];
+      for (const entry of read) {
+        if ("reason" in entry && entry.reason !== void 0) {
+          failed.push({ channelId: entry.channelId, reason: entry.reason });
+          continue;
+        }
+        const channel2 = "channel" in entry ? entry.channel : void 0;
+        if (!channel2) continue;
+        if (categoryId === void 0 || channel2.categoryId === categoryId) channels2.push(channel2);
+      }
+      return { channels: channels2, failed };
+    });
+  }
+  /**
+   * Archive a work channel: end every open shift, record the end state, delete nothing.
+   *
+   * Worktrees stay on disk. Ticket 02 removes a worktree only after the channel's PR merges, never
+   * on archive alone, because a worktree holding unmerged commits is exactly the irreversible act
+   * the map bans. Feed channels have no archive lifecycle and this refuses one.
+   */
+  archive(channelId, endState) {
+    return this.enqueue(async () => {
+      const channel2 = await this.readChannel(channelId);
+      if (!channel2) throw new Error(`No channel ${channelId} to archive.`);
+      if (!isWorkChannel(channel2)) {
+        throw new Error("A feed channel never ships, so it has no shift to end and cannot be archived.");
+      }
+      const archived = archiveChannel(channel2, endState, this.now());
+      const runtime = await this.readRuntime(channelId);
+      await this.writeWork(archived, await this.repoPathFor(channel2), runtime?.record.claims ?? {});
+      return archived;
+    });
+  }
+  // -- the disk -------------------------------------------------------------------------------
+  locationOf(channelId, repoPath) {
+    return channelLocation(this.userDataDir, repoPath, channelId);
+  }
+  async repoPathFor(channel2) {
+    const runtime = await this.readRuntime(channel2.id);
+    if (runtime) return runtime.repoPath;
+    const category = (await this.readCategories()).find((entry) => entry.id === channel2.categoryId);
+    if (!category) {
+      throw new Error(`No category ${channel2.categoryId}, so there is no repo to commit ${channel2.id} to.`);
+    }
+    return category.repoPath;
+  }
+  async writeWork(channel2, repoPath, claims) {
+    assertOneWorktreePerMember(channel2.worktrees);
+    const location = this.locationOf(channel2.id, repoPath);
+    const { repo, runtime } = splitWork(channel2, repoPath, claims);
+    await writeJson(repoRecordPath(location), repo);
+    await writeJson(runtimeRecordPath(location), runtime);
+  }
+  async readRuntime(channelId) {
+    const raw = await readJson(runtimePathFor(this.userDataDir, channelId), { rescue: this.rescue });
+    return raw === void 0 ? void 0 : parseRuntimeFile(raw);
+  }
+  async readChannel(channelId) {
+    const feedRaw = await readJson(feedRecordPath(this.userDataDir, channelId), { rescue: this.rescue });
+    if (feedRaw !== void 0) {
+      const feed = parseFeedFile(feedRaw);
+      return feed ? fromFeedFile(feed) : void 0;
+    }
+    const runtime = await this.readRuntime(channelId);
+    if (runtime) {
+      const repoRaw = await this.readRepoRecord(this.locationOf(channelId, runtime.repoPath));
+      if (repoRaw === void 0) return void 0;
+      const repo = parseRepoFile(repoRaw);
+      return repo ? joinWork(repo, runtime) : void 0;
+    }
+    return this.adopt(channelId);
+  }
+  /**
+   * A committed half with no runtime half beside it, read back from the repo.
+   *
+   * This is what makes the split worth having on a second machine. A teammate clones the repo, or
+   * the user clears userData, and `<repoPath>/.skribbl/channels/<id>.json` still holds the goal, the
+   * stage and the memory. Without this the bytes survive and nothing can read them, which is half
+   * the reason ticket 02 committed them.
+   *
+   * Every field of the runtime half is regenerable or a zeroed number, which is the same argument
+   * `parseRuntimeFile` already makes when a field is missing. A half that is missing entirely is the
+   * limit of that argument, not an exception to it. Nothing is written here: adoption is a read, and
+   * the next `save` puts the runtime half back on disk.
+   *
+   * It also makes a failed create harmless. `writeWork` writes the committed half first, so a
+   * userData write that throws used to leave an unreadable orphan in the user's repo forever.
+   */
+  async adopt(channelId) {
+    for (const category of await this.readCategories()) {
+      const location = this.locationOf(channelId, category.repoPath);
+      const raw = await this.readRepoRecord(location).catch(() => void 0);
+      if (raw === void 0) continue;
+      const repo = parseRepoFile(raw);
+      if (!repo) continue;
+      return joinWork(repo, emptyRuntimeFor(repo, category.repoPath));
+    }
+    return void 0;
+  }
+  /**
+   * Every channel id this machine can reach, from BOTH stores.
+   *
+   * One directory per channel under `<userData>/factory/`, so those ids are the directory names,
+   * and `categories.json` is a file and falls out of the listing on its own. The repo side is
+   * walked as well, once per category, so a channel whose runtime half is gone is still listed and
+   * still adoptable rather than being invisible until somebody happens to know its id.
+   */
+  async channelIds() {
+    const ids = /* @__PURE__ */ new Set();
+    const entries = await readdir(join2(this.userDataDir, USER_DATA_FACTORY_DIR), {
+      withFileTypes: true
+    }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isDirectory()) ids.add(entry.name);
+    }
+    const repos = new Set((await this.readCategories()).map((category) => category.repoPath));
+    for (const repoPath of repos) {
+      for (const dir of [REPO_CHANNELS_DIR, LEGACY_REPO_CHANNELS_DIR]) {
+        const files = await readdir(join2(repoPath, dir)).catch(() => []);
+        for (const name of files) {
+          if (name.endsWith(".json")) ids.add(name.slice(0, -".json".length));
+        }
+      }
+    }
+    return [...ids];
+  }
+  /**
+   * The committed half, from `.wayari/channels` first and `.skribbl/channels` second.
+   *
+   * The new path wins when both exist, because it is the one every write since the rename made and
+   * so the newer of the two. The old one is read, never rewritten and never removed: see
+   * `LEGACY_REPO_CHANNELS_DIR`. `writeWork` writes the new path only, so a channel touched after the
+   * rename has its current record there and a stale copy under the old name that this order ignores.
+   */
+  async readRepoRecord(location) {
+    const current = await readJson(repoRecordPath(location), { rescue: this.rescue });
+    if (current !== void 0) return current;
+    return readJson(legacyRepoRecordPath(location), { rescue: this.rescue });
+  }
+  async readCategories() {
+    const raw = await readJson(categoriesPath(this.userDataDir), { rescue: this.rescue });
+    return raw === void 0 ? [] : parseCategoriesFile(raw).categories;
+  }
+  async writeCategories(categories) {
+    await writeJson(categoriesPath(this.userDataDir), { version: CHANNEL_FILE_VERSION, categories });
+  }
+  enqueue(work) {
+    const turn = this.pending.catch(() => void 0).then(work);
+    this.pending = turn.catch(() => void 0);
+    return turn;
+  }
+};
+
+// src/core/factory/host/userdata.ts
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+function appUserDataCandidates(probe) {
+  if (probe.platform === "darwin") {
+    const base2 = join3(probe.homeDir, "Library", "Application Support");
+    return [join3(base2, "wayari"), join3(base2, "skribbl"), join3(base2, "Skribbl")];
+  }
+  if (probe.platform === "win32") {
+    const base2 = probe.env.APPDATA ?? join3(probe.homeDir, "AppData", "Roaming");
+    return [join3(base2, "wayari"), join3(base2, "skribbl"), join3(base2, "Skribbl")];
+  }
+  const base = probe.env.XDG_CONFIG_HOME ?? join3(probe.homeDir, ".config");
+  return [join3(base, "wayari"), join3(base, "skribbl"), join3(base, "Skribbl")];
+}
+function cliUserData(homeDir) {
+  return join3(homeDir, ".wayari");
+}
+function defaultUserData(probe = liveProbe()) {
+  const named = probe.env.WAYARI_HOME;
+  if (named) return named;
+  for (const dir of appUserDataCandidates(probe)) if (probe.exists(dir)) return dir;
+  return cliUserData(probe.homeDir);
+}
+function liveProbe() {
+  return { homeDir: homedir(), platform: process.platform, env: process.env, exists: existsSync };
+}
+
+// src/shared/agents/usage.ts
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheCreate: 0, cacheCreate1h: 0 };
+}
+function addUsage(a, b) {
+  return {
+    input: a.input + b.input,
+    output: a.output + b.output,
+    cacheRead: a.cacheRead + b.cacheRead,
+    cacheCreate: a.cacheCreate + b.cacheCreate,
+    cacheCreate1h: a.cacheCreate1h + b.cacheCreate1h
+  };
+}
+var CACHE_READ = 0.1;
+var CACHE_WRITE_5M = 1.25;
+var CACHE_WRITE_1H = 2;
+function card(input, output) {
+  return {
+    input,
+    output,
+    cacheRead: input * CACHE_READ,
+    cacheCreate: input * CACHE_WRITE_5M,
+    cacheCreate1h: input * CACHE_WRITE_1H
+  };
+}
+var MODEL_RATES = {
+  opus: card(5, 25),
+  fable: card(10, 50),
+  haiku: card(1, 5),
+  sonnet: card(3, 15)
+};
+var FALLBACK_RATES = MODEL_RATES.sonnet;
+function cardFor(model) {
+  if (!model) return void 0;
+  const id = model.toLowerCase();
+  for (const [tier2, rates] of Object.entries(MODEL_RATES)) {
+    if (id.includes(tier2)) return rates;
+  }
+  return void 0;
+}
+function ratesFor(model) {
+  return cardFor(model) ?? FALLBACK_RATES;
+}
+function ratesKnown(model) {
+  return cardFor(model) !== void 0;
+}
+function costOf(usage2, model) {
+  const rates = ratesFor(model);
+  return (usage2.input * rates.input + usage2.output * rates.output + usage2.cacheRead * rates.cacheRead + usage2.cacheCreate * rates.cacheCreate + usage2.cacheCreate1h * rates.cacheCreate1h) / 1e6;
+}
+var WEEK_WINDOWS = 12;
+var WEEK_MS = 7 * 24 * 60 * 6e4;
+function tier(id, label, windowTokens) {
+  return { id, label, windowTokens, weekTokens: windowTokens * WEEK_WINDOWS };
+}
+var PLAN_TIERS = [
+  tier("pro", "Claude Pro", 8e6),
+  tier("max5", "Claude Max 5x", 4e7),
+  tier("max20", "Claude Max 20x", 16e7),
+  tier("api", "API key or credits", 0)
+];
+
+// src/core/factory/evidence/parse.ts
+var EVIDENCE_FILE_VERSION = 1;
+var KINDS = [
+  "answered-gate",
+  "forced-gate",
+  "answered-approval",
+  "killed",
+  "corrected-agent"
+];
+function bag2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function str2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function usage(value) {
+  const raw = bag2(value);
+  if (!raw) return emptyUsage();
+  const out = emptyUsage();
+  for (const field of Object.keys(out)) {
+    out[field] = count(raw[field]) ?? 0;
+  }
+  return out;
+}
+function intervention(value) {
+  const raw = bag2(value);
+  if (!raw) return void 0;
+  const kind = KINDS.find((candidate) => candidate === raw.kind);
+  const at = count(raw.at);
+  if (!kind || at === void 0) return void 0;
+  const memberId = str2(raw.memberId);
+  return {
+    kind,
+    at,
+    ...memberId ? { memberId } : {},
+    note: str2(raw.note) ?? kind
+  };
+}
+function baseline(value) {
+  const raw = bag2(value);
+  if (!raw) return void 0;
+  const costUsd = count(raw.costUsd);
+  const minutes2 = count(raw.minutes);
+  const recordedAt = count(raw.recordedAt);
+  if (costUsd === void 0 || minutes2 === void 0 || recordedAt === void 0) return void 0;
+  return { costUsd, minutes: minutes2, note: str2(raw.note) ?? "", recordedAt };
+}
+function parseEvidenceFile(value) {
+  const raw = bag2(value);
+  if (!raw) return void 0;
+  const body = bag2(raw.evidence);
+  if (!body) return void 0;
+  const channelId = str2(body.channelId);
+  const goalStatedAt = count(body.goalStatedAt);
+  if (!channelId || goalStatedAt === void 0) return void 0;
+  const prOpenedAt = count(body.prOpenedAt);
+  const prMergedAt = count(body.prMergedAt);
+  const held = baseline(body.baseline);
+  const rows2 = Array.isArray(body.interventions) ? body.interventions : [];
+  return {
+    version: count(raw.version) ?? EVIDENCE_FILE_VERSION,
+    evidence: {
+      channelId,
+      goalStatedAt,
+      ...prOpenedAt !== void 0 ? { prOpenedAt } : {},
+      ...prMergedAt !== void 0 ? { prMergedAt } : {},
+      costUsd: count(body.costUsd) ?? 0,
+      tokens: usage(body.tokens),
+      interventions: rows2.map(intervention).filter((row) => row !== void 0),
+      gateFailures: count(body.gateFailures) ?? 0,
+      ...held ? { baseline: held } : {}
+    }
+  };
+}
+
+// src/core/factory/evidence/record.ts
+function newEvidence(channelId, goalStatedAt) {
+  return {
+    channelId,
+    goalStatedAt,
+    costUsd: 0,
+    tokens: emptyUsage(),
+    interventions: [],
+    gateFailures: 0
+  };
+}
+function withSpend(evidence, delta) {
+  return {
+    ...evidence,
+    costUsd: evidence.costUsd + Math.max(0, delta.costUsd),
+    tokens: addUsage(evidence.tokens, delta.usage)
+  };
+}
+function withIntervention(evidence, record) {
+  return { ...evidence, interventions: [...evidence.interventions, record] };
+}
+function withGateResult(evidence, result) {
+  if (result.passed) return evidence;
+  return { ...evidence, gateFailures: evidence.gateFailures + 1 };
+}
+function withPrOpened(evidence, at) {
+  if (evidence.prOpenedAt !== void 0) return evidence;
+  return { ...evidence, prOpenedAt: at };
+}
+function withPrMerged(evidence, at) {
+  return { ...evidence, prMergedAt: at };
+}
+function withBaseline(evidence, baseline2) {
+  return { ...evidence, baseline: baseline2 };
+}
+function summarize(evidence) {
+  return {
+    channelId: evidence.channelId,
+    costUsd: evidence.costUsd,
+    ...evidence.prMergedAt !== void 0 ? { costPerMergedPrUsd: evidence.costUsd } : {},
+    ...evidence.prOpenedAt !== void 0 ? { wallClockMs: Math.max(0, evidence.prOpenedAt - evidence.goalStatedAt) } : {},
+    interventions: evidence.interventions.length,
+    gateFailures: evidence.gateFailures,
+    ...evidence.baseline ? { baseline: evidence.baseline } : {}
+  };
+}
+
+// src/core/factory/evidence/store.ts
+var SPEND_WRITE_DELAY_MS = 5e3;
+var EvidenceStore = class _EvidenceStore {
+  constructor(path, evidence, options) {
+    this.path = path;
+    this.current = evidence;
+    this.now = options.now ?? (() => Date.now());
+    this.spendWriteDelayMs = options.spendWriteDelayMs ?? SPEND_WRITE_DELAY_MS;
+  }
+  path;
+  current;
+  pending = Promise.resolve();
+  writeTimer;
+  now;
+  spendWriteDelayMs;
+  /**
+   * Open a channel's evidence, starting a fresh account when there is none.
+   *
+   * `goalStatedAt` is only used for a channel with no file yet, because it is the start of clock 2
+   * and a reopened channel already has one. Passing the current time on every open would restart the
+   * clock at every app launch and make every wall-clock reading a lie.
+   */
+  static async open(input) {
+    const path = evidencePathFor(input.userDataDir, input.channelId);
+    const raw = await readJson(path);
+    const file = raw === void 0 ? void 0 : parseEvidenceFile(raw);
+    const evidence = file?.evidence ?? newEvidence(input.channelId, input.goalStatedAt);
+    return new _EvidenceStore(path, { ...evidence, channelId: input.channelId }, input.options ?? {});
+  }
+  /** What has been observed so far, as a copy. Handing back the live object would let a caller edit
+   *  a channel's account through a getter. */
+  read() {
+    return { ...this.current, tokens: { ...this.current.tokens }, interventions: [...this.current.interventions] };
+  }
+  /** The four numbers. */
+  summary() {
+    return summarize(this.current);
+  }
+  /** One spend delta. Debounced: see the header. */
+  spend(delta) {
+    this.current = withSpend(this.current, delta);
+    this.scheduleWrite();
+  }
+  /** One human act. Lands on disk before this resolves. */
+  intervention(record) {
+    this.current = withIntervention(this.current, record);
+    return this.persist();
+  }
+  /** One gate run. A pass is recorded as nothing, which is correct: number 4 counts failures. */
+  gateResult(result) {
+    const next = withGateResult(this.current, result);
+    if (next === this.current) return Promise.resolve();
+    this.current = next;
+    return this.persist();
+  }
+  prOpened(at = this.now()) {
+    const next = withPrOpened(this.current, at);
+    if (next === this.current) return Promise.resolve();
+    this.current = next;
+    return this.persist();
+  }
+  prMerged(at = this.now()) {
+    this.current = withPrMerged(this.current, at);
+    return this.persist();
+  }
+  /** The hand-built figure the human supplies. This is the only field nothing observes. */
+  baseline(baseline2) {
+    this.current = withBaseline(this.current, baseline2);
+    return this.persist();
+  }
+  /** Write now, so a debounced spend cannot be lost on quit. */
+  async flush() {
+    if (this.writeTimer !== void 0) {
+      clearTimeout(this.writeTimer);
+      this.writeTimer = void 0;
+    }
+    await this.persist();
+  }
+  scheduleWrite() {
+    if (this.writeTimer !== void 0) return;
+    this.writeTimer = setTimeout(() => {
+      this.writeTimer = void 0;
+      void this.persist().catch(() => void 0);
+    }, this.spendWriteDelayMs);
+    this.writeTimer.unref?.();
+  }
+  persist() {
+    return this.enqueue(async () => {
+      await writeJson(this.path, { version: EVIDENCE_FILE_VERSION, evidence: this.current });
+    });
+  }
+  enqueue(work) {
+    const turn = this.pending.catch(() => void 0).then(work);
+    this.pending = turn.catch(() => void 0);
+    return turn;
+  }
+};
+
+// src/core/factory/routing/store.ts
+import { join as join4 } from "node:path";
+
+// src/core/factory/routing/record.ts
+function withRouteOutcome(record, input) {
+  const byModel = input.usageByModel;
+  const models = byModel ? Object.keys(byModel) : [];
+  const usage2 = byModel ? models.reduce((sum, model) => addUsage(sum, byModel[model]), emptyUsage()) : void 0;
+  const priceable = byModel !== void 0 && models.length > 0 && models.every((model) => ratesKnown(model));
+  const usd = priceable ? models.reduce((sum, model) => sum + costOf(byModel[model], model), 0) : void 0;
+  const outcome = {
+    settledAt: input.settledAt,
+    gatePassed: input.gatePassed,
+    failures: input.failures ?? [],
+    ...usage2 ? { usage: usage2 } : {},
+    ...byModel ? { usageByModel: { ...byModel } } : {},
+    ...usd !== void 0 ? { usd } : {},
+    wallMs: Math.max(0, (input.endedAt ?? input.settledAt) - record.decidedAt),
+    held: input.held ?? false,
+    ...input.subagents !== void 0 ? { subagents: input.subagents } : {},
+    ...input.firstClaimAt !== void 0 ? { firstClaimAt: input.firstClaimAt } : {}
+  };
+  return { ...record, outcome };
+}
+
+// src/core/factory/routing/store.ts
+var ROUTES_FILE_VERSION = 1;
+function routesPathFor(userDataDir2, channelId) {
+  return join4(userDataDir2, USER_DATA_FACTORY_DIR, sanitizeChannelId(channelId), "routes.json");
+}
+function parseRecord(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const row = value;
+  if (typeof row.decidedAt !== "number" || !Number.isFinite(row.decidedAt)) return void 0;
+  if (typeof row.channelId !== "string" || !row.channelId) return void 0;
+  if (typeof row.member !== "string" || !row.member) return void 0;
+  if (!row.chosen || typeof row.chosen !== "object") return void 0;
+  if (!Array.isArray(row.considered)) return void 0;
+  return row;
+}
+function parseFile(value) {
+  if (!value || typeof value !== "object") return [];
+  const file = value;
+  if (!Array.isArray(file.records)) return [];
+  return file.records.map(parseRecord).filter((record) => record !== void 0);
+}
+var RouteStore = class _RouteStore {
+  constructor(path, records) {
+    this.path = path;
+    this.records = records;
+  }
+  path;
+  records;
+  pending = Promise.resolve();
+  /** Open a channel's records, starting an empty list when there are none. */
+  static async open(input) {
+    const path = routesPathFor(input.userDataDir, input.channelId);
+    const raw = await readJson(path);
+    return new _RouteStore(path, parseFile(raw));
+  }
+  /** What has been decided so far, oldest first, as copies. Handing back the live rows would let a
+   *  caller edit the training set through a getter. */
+  all() {
+    return this.records.map((record) => ({ ...record }));
+  }
+  /** One decision, written the moment the shift is briefed. */
+  add(record) {
+    this.records = [...this.records, record];
+    return this.persist();
+  }
+  /**
+   * The outcome half, matched to its decision by member and `decidedAt`.
+   *
+   * Both halves of the key, because a member runs several shifts in a channel and the second one
+   * must not overwrite the first one's label. Answers null when no decision matches, which is a
+   * caller settling a shift this store never saw rather than an error worth throwing at a quit path.
+   */
+  settle(member, decidedAt, outcome) {
+    const index = this.records.findIndex(
+      (record) => record.member === member && record.decidedAt === decidedAt
+    );
+    if (index === -1) return Promise.resolve(null);
+    const settled = withRouteOutcome(this.records[index], outcome);
+    this.records = this.records.map((record, at) => at === index ? settled : record);
+    return this.persist().then(() => settled);
+  }
+  /** Write now. Nothing here is debounced, so this only ever waits for a write already in flight. */
+  async flush() {
+    await this.persist();
+  }
+  persist() {
+    return this.enqueue(async () => {
+      const file = { version: ROUTES_FILE_VERSION, records: this.records };
+      await writeJson(this.path, file);
+    });
+  }
+  enqueue(work) {
+    const turn = this.pending.catch(() => void 0).then(work);
+    this.pending = turn.catch(() => void 0);
+    return turn;
+  }
+};
+
+// scripts/evidence.mjs
+var argv = process.argv.slice(2);
+var positional = argv.filter((arg, index) => !arg.startsWith("--") && !argv[index - 1]?.startsWith("--"));
+function flagValue(name) {
+  const index = argv.indexOf(name);
+  return index >= 0 ? argv[index + 1] : void 0;
+}
+var userDataDir = flagValue("--userdata") ?? defaultUserData();
+var target = positional[0] ?? null;
+async function channelsOnDisk() {
+  const factoryDir = join5(userDataDir, USER_DATA_FACTORY_DIR);
+  const entries = await readdir2(factoryDir, { withFileTypes: true }).catch(() => []);
+  const listing = await new ChannelStore(userDataDir, { rescue: false }).list().catch(() => ({ channels: [], failed: [] }));
+  const known = new Map(listing.channels.filter(isWorkChannel).map((channel2) => [channel2.id, channel2]));
+  const found = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const runtime = parseRuntimeFile(await readJson(join5(factoryDir, entry.name, "runtime.json"), { rescue: false }));
+    if (!runtime) continue;
+    const record = known.get(runtime.id);
+    found.push({
+      id: runtime.id,
+      name: record?.name ?? "(committed record not found)",
+      stage: record?.pipeline.stage ?? "unknown",
+      shifts: runtime.shifts,
+      goalStatedAt: runtime.record.budgetSpent.startedAt
+    });
+  }
+  return found.sort((a, b) => a.goalStatedAt - b.goalStatedAt);
+}
+var channels = await channelsOnDisk();
+if (!channels.length) {
+  console.log(`No work channels under ${userDataDir}.`);
+  process.exit(0);
+}
+function median(values) {
+  const sorted = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
+  if (!sorted.length) return void 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function minutes(ms) {
+  return ms === void 0 ? "no reading" : `${(ms / 6e4).toFixed(1)} min`;
+}
+function dollars(usd) {
+  return usd === void 0 ? "unpriced" : `$${usd.toFixed(2)}`;
+}
+function count2(n, singular, plural = `${singular}s`) {
+  return `${n} ${n === 1 ? singular : plural}`;
+}
+async function fourNumbers(channel2) {
+  if (!existsSync2(join5(userDataDir, USER_DATA_FACTORY_DIR, channel2.id, "evidence.json"))) return ["  no evidence account"];
+  const store = await EvidenceStore.open({ userDataDir, channelId: channel2.id, goalStatedAt: channel2.goalStatedAt });
+  const summary = store.summary();
+  const lines = [
+    `  1. cost ${dollars(summary.costUsd)}${summary.costPerMergedPrUsd !== void 0 ? ", and the PR merged, so that is the cost per merged PR" : ", PR not merged, so no cost per merged PR yet"}`,
+    `  2. wall clock ${summary.wallClockMs === void 0 ? "still running: the PR has not opened" : `${minutes(summary.wallClockMs)} from goal to PR open`}`,
+    `  3. ${count2(summary.interventions, "intervention")}`,
+    `  4. ${count2(summary.gateFailures, "gate failure")}`
+  ];
+  if (summary.baseline) {
+    lines.push(
+      `  by hand: ${dollars(summary.baseline.costUsd)} and ${summary.baseline.minutes} min, recorded ${new Date(summary.baseline.recordedAt).toISOString()}: ${summary.baseline.note}`
+    );
+  } else {
+    lines.push("  by hand: not recorded. Add it with --baseline-usd, --baseline-minutes and --note.");
+  }
+  return lines;
+}
+function describeArm(name, rows2) {
+  const labelled = rows2.filter((row) => row.outcome);
+  const lines = [`  ${name}: ${count2(rows2.length, "shift")}, ${count2(labelled.length, "labelled")}`];
+  if (!labelled.length) return lines;
+  const passed = labelled.filter((row) => row.outcome.gatePassed).length;
+  lines.push(`    gate passed for ${passed} of ${labelled.length}`);
+  const orientation = labelled.filter((row) => row.outcome.firstClaimAt !== void 0).map((row) => row.outcome.firstClaimAt - row.decidedAt);
+  lines.push(`    decision to first claim, median ${minutes(median(orientation))} over ${count2(orientation.length, "shift")} with a claim`);
+  const priced = labelled.filter((row) => row.outcome.usd !== void 0).map((row) => row.outcome.usd);
+  lines.push(`    cost, median ${dollars(median(priced))} over ${count2(priced.length, "priced shift")}`);
+  const wall = labelled.map((row) => row.outcome.wallMs);
+  lines.push(`    wall clock, median ${minutes(median(wall))} over ${count2(wall.length, "shift")}`);
+  return lines;
+}
+if (!target) {
+  const rows2 = [];
+  for (const channel2 of channels) {
+    const routes2 = await RouteStore.open({ userDataDir, channelId: channel2.id });
+    rows2.push(...routes2.all());
+  }
+  console.log(`${count2(channels.length, "work channel")} under ${userDataDir}, ${count2(rows2.length, "shift row")}.`);
+  console.log("");
+  for (const channel2 of channels) {
+    const mine = rows2.filter((row) => row.channelId === channel2.id);
+    const labelled = mine.filter((row) => row.outcome).length;
+    console.log(`${channel2.id}  ${channel2.name}, stage ${channel2.stage}, ${count2(mine.length, "shift")}, ${labelled} labelled`);
+    for (const line of await fourNumbers(channel2)) console.log(line);
+  }
+  console.log("");
+  const measured = rows2.filter((row) => row.atlas);
+  console.log(`Atlas arms, over ${count2(measured.length, "shift")} whose arm was recorded (${rows2.length - measured.length} not measured):`);
+  for (const line of describeArm("excerpted", measured.filter((row) => !row.atlas.withheld))) console.log(line);
+  for (const line of describeArm("withheld", measured.filter((row) => row.atlas.withheld))) console.log(line);
+  console.log("");
+  const armedRows = rows2.filter((row) => row.handover);
+  console.log(`Handover arms, over ${count2(armedRows.length, "shift")} run while the floor was set (${rows2.length - armedRows.length} before it):`);
+  if (!armedRows.length) console.log("  none yet: HANDOVER_FLOOR_TOKENS is undefined until the orientation cost above is measured");
+  for (const line of describeArm("armed", armedRows.filter((row) => row.handover.armed))) console.log(line);
+  for (const line of describeArm("not armed", armedRows.filter((row) => !row.handover.armed))) console.log(line);
+  console.log("");
+  const counted = rows2.filter((row) => row.outcome?.subagents !== void 0);
+  console.log(`Delegation, over ${count2(counted.length, "shift")} whose transcript was read (${rows2.length - counted.length} unread):`);
+  for (const line of describeArm("sent subagents", counted.filter((row) => row.outcome.subagents > 0))) console.log(line);
+  for (const line of describeArm("sent none", counted.filter((row) => row.outcome.subagents === 0))) console.log(line);
+  console.log("");
+  const ordinaryRaw = rows2.filter((row) => row.attempt === 1 && (row.reason === "default-workhorse" || row.reason === "floored-workhorse"));
+  const firstBy = /* @__PURE__ */ new Map();
+  for (const row of ordinaryRaw) {
+    const key = `${row.channelId}:${row.member}:${row.attempt}`;
+    const seen = firstBy.get(key);
+    if (!seen || row.decidedAt < seen.decidedAt) firstBy.set(key, row);
+  }
+  const ordinary = [...firstBy.values()];
+  const byModel = /* @__PURE__ */ new Map();
+  for (const row of ordinary) byModel.set(row.chosen.id, [...byModel.get(row.chosen.id) ?? [], row]);
+  const collapsed = ordinaryRaw.length - ordinary.length;
+  console.log(`First attempts at ordinary work, by model, over ${count2(ordinary.length, "shift")}${collapsed ? ` (${count2(collapsed, "handover row")} folded into the shift that started them)` : ""}:`);
+  if (!ordinary.length) console.log("  none yet");
+  for (const [model, group] of [...byModel.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    for (const line of describeArm(model, group)) console.log(line);
+  }
+  console.log("  WORKHORSE_FLOOR stays empty until two of these models each have enough labelled rows to put their pass rates");
+  console.log("  into the break-even beside the constant; a dozen each is the least that reads.");
+  console.log("");
+  console.log("Pass a channel id to print its shifts:  npm run evidence <channelId>");
+  process.exit(0);
+}
+var channel = channels.find((candidate) => candidate.id === target || candidate.name === target);
+if (!channel) {
+  console.error(`No work channel ${target} under ${userDataDir}.`);
+  process.exit(1);
+}
+var baselineUsd = flagValue("--baseline-usd");
+var baselineMinutes = flagValue("--baseline-minutes");
+var note = flagValue("--note");
+if (baselineUsd !== void 0 || baselineMinutes !== void 0 || note !== void 0) {
+  const usd = Number(baselineUsd);
+  const mins = Number(baselineMinutes);
+  if (!Number.isFinite(usd) || !Number.isFinite(mins) || !note) {
+    console.error('A baseline needs all three: --baseline-usd <dollars> --baseline-minutes <minutes> --note "<what was built and how it was measured>".');
+    process.exit(1);
+  }
+  const store = await EvidenceStore.open({ userDataDir, channelId: channel.id, goalStatedAt: channel.goalStatedAt });
+  await store.baseline({ costUsd: usd, minutes: mins, note, recordedAt: Date.now() });
+  console.log(`Recorded the hand-built baseline for ${channel.name}.`);
+  console.log("");
+}
+console.log(`${channel.name} (${channel.id}), stage ${channel.stage}.`);
+for (const line of await fourNumbers(channel)) console.log(line);
+console.log("");
+var routes = await RouteStore.open({ userDataDir, channelId: channel.id });
+var rows = routes.all();
+console.log(`${count2(rows.length, "shift row")}:`);
+for (const row of rows) {
+  const arm = row.atlas ? row.atlas.withheld ? "withheld" : `excerpted, ${row.atlas.pages} pages, ${row.atlas.chars} chars` : "arm not recorded";
+  console.log(`  ${row.member}  attempt ${row.attempt}  ${row.chosen.id} (${row.reason})  ${arm}`);
+  const outcome = row.outcome;
+  if (!outcome) {
+    console.log("    no label: the gate has not answered for this shift, or the row was written before 2026-09-02");
+    continue;
+  }
+  const gate = outcome.held ? "held" : outcome.gatePassed ? "gate passed" : `gate failed: ${outcome.failures.join(", ") || "no check named"}`;
+  console.log(`    ${gate}, ${minutes(outcome.wallMs)} wall, ${dollars(outcome.usd)}`);
+  const claim = outcome.firstClaimAt === void 0 ? "no claim recorded" : `first claim after ${minutes(outcome.firstClaimAt - row.decidedAt)}`;
+  const hired = outcome.subagents === void 0 ? "transcript unread" : count2(outcome.subagents, "subagent");
+  console.log(`    ${claim}, ${hired}`);
+}