agent-standup 0.20.0

package/dist/bin/standup.js

@@ -0,0 +1,3351 @@
+#!/usr/bin/env node
+import {
+  EXIT,
+  HOOK_VERBS,
+  createHttpFlush,
+  exitCodeFor,
+  fileSpool,
+  isHookVerb,
+  malformed,
+  ok,
+  rejected,
+  runHookCommand,
+  spoolPath
+} from "../chunk-N7G677FC.js";
+import {
+  NotFoundError,
+  SERVICE_ERROR_CODES,
+  faultContext,
+  getDefinition,
+  isRehearsalRollback,
+  isSettingKey,
+  listOperations,
+  log,
+  newRequestId,
+  toServiceError
+} from "../chunk-4TIZQTUZ.js";
+import "../chunk-VBXNDGOD.js";
+
+// src/lib/cli/args.ts
+function parseArgs(argv) {
+  const words = [];
+  const flags = {};
+  let literal = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === void 0) continue;
+    if (literal) {
+      words.push(token);
+      continue;
+    }
+    if (token === "--") {
+      literal = true;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const body = token.slice(2);
+      if (body.length === 0) continue;
+      const equals = body.indexOf("=");
+      if (equals !== -1) {
+        const name = body.slice(0, equals);
+        if (name.length === 0) {
+          return { ok: false, envelope: malformed(`Not a flag: ${token}.`) };
+        }
+        flags[name] = body.slice(equals + 1);
+        continue;
+      }
+      const next = argv[index + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        flags[body] = next;
+        index += 1;
+      } else {
+        flags[body] = true;
+      }
+      continue;
+    }
+    if (token.startsWith("-") && token.length > 1) {
+      return {
+        ok: false,
+        envelope: malformed(
+          `Not a flag this build understands: ${token}. Flags are spelled --name.`
+        )
+      };
+    }
+    words.push(token);
+  }
+  return { ok: true, parsed: { words, flags } };
+}
+function stringFlag(flags, name) {
+  const value = flags[name];
+  if (value === void 0) return { ok: true };
+  if (value === true) {
+    return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+  }
+  return { ok: true, value };
+}
+function booleanFlag(flags, name) {
+  const value = flags[name];
+  if (value === void 0) return { ok: true, value: false };
+  if (value !== true) {
+    return { ok: false, envelope: malformed(`--${name} does not take a value.`, [name]) };
+  }
+  return { ok: true, value: true };
+}
+function numericFlag(flags, name) {
+  const raw = stringFlag(flags, name);
+  if (!raw.ok) return raw;
+  if (raw.value === void 0) return { ok: true };
+  const text = raw.value.trim();
+  const parsed = text === "" ? Number.NaN : Number(text);
+  if (!Number.isInteger(parsed)) {
+    return { ok: false, envelope: malformed(`--${name} must be a whole number.`, [name]) };
+  }
+  return { ok: true, value: parsed };
+}
+
+// src/lib/cli/commands-admin.ts
+function idArg(rest, label) {
+  const id = rest[0];
+  if (id === void 0) {
+    return { ok: false, envelope: malformed(`\`standup ${label}\` needs an id.`, ["id"]) };
+  }
+  return { ok: true, id };
+}
+function sourceGlobsFlag(flags) {
+  const clear = booleanFlag(flags, "clear-source-globs");
+  if (!clear.ok) return clear;
+  const raw = stringFlag(flags, "source-globs");
+  if (!raw.ok) return raw;
+  if (clear.value && raw.value !== void 0) {
+    return {
+      ok: false,
+      envelope: malformed("--source-globs and --clear-source-globs are mutually exclusive.", [
+        "sourceGlobs"
+      ])
+    };
+  }
+  if (clear.value) return { ok: true, value: null };
+  if (raw.value === void 0) return { ok: true };
+  return {
+    ok: true,
+    value: raw.value.split(",").map((glob) => glob.trim()).filter((glob) => glob.length > 0)
+  };
+}
+function budgetWindowsFlag(flags) {
+  const clear = booleanFlag(flags, "clear-budget-windows");
+  if (!clear.ok) return clear;
+  const raw = stringFlag(flags, "budget-windows");
+  if (!raw.ok) return raw;
+  if (clear.value && raw.value !== void 0) {
+    return {
+      ok: false,
+      envelope: malformed("--budget-windows and --clear-budget-windows are mutually exclusive.", [
+        "budgetWindows"
+      ])
+    };
+  }
+  if (clear.value) return { ok: true, value: null };
+  if (raw.value === void 0) return { ok: true };
+  try {
+    return { ok: true, value: JSON.parse(raw.value) };
+  } catch {
+    return {
+      ok: false,
+      envelope: malformed("--budget-windows must be valid JSON.", ["budgetWindows"])
+    };
+  }
+}
+var ADMIN_COMMANDS = Object.freeze([
+  // ── repo ──────────────────────────────────────────────────────────────
+  {
+    noun: "repo",
+    verb: "list",
+    operation: "list_repos",
+    summary: "List repositories.",
+    buildInput: (_rest, flags) => {
+      const includeArchived = booleanFlag(flags, "include-archived");
+      if (!includeArchived.ok) return includeArchived;
+      return { ok: true, input: { includeArchived: includeArchived.value } };
+    }
+  },
+  {
+    noun: "repo",
+    verb: "get",
+    operation: "get_repo",
+    summary: "Show one repository.",
+    buildInput: (rest) => {
+      const idResult = idArg(rest, "repo get");
+      if (!("id" in idResult)) return idResult;
+      return { ok: true, input: { id: idResult.id } };
+    }
+  },
+  {
+    noun: "repo",
+    verb: "create",
+    operation: "create_repo",
+    summary: "Create a repository. Refused if the id already exists.",
+    buildInput: (rest, flags) => {
+      const idResult = idArg(rest, "repo create");
+      if (!("id" in idResult)) return idResult;
+      const displayName = stringFlag(flags, "display-name");
+      if (!displayName.ok) return displayName;
+      const defaultBranch = stringFlag(flags, "default-branch");
+      if (!defaultBranch.ok) return defaultBranch;
+      const host = stringFlag(flags, "host");
+      if (!host.ok) return host;
+      const needsVisualReview = booleanFlag(flags, "needs-visual-review");
+      if (!needsVisualReview.ok) return needsVisualReview;
+      return {
+        ok: true,
+        input: {
+          id: idResult.id,
+          ...displayName.value === void 0 ? {} : { displayName: displayName.value },
+          ...defaultBranch.value === void 0 ? {} : { defaultBranch: defaultBranch.value },
+          ...host.value === void 0 ? {} : { host: host.value },
+          needsVisualReview: needsVisualReview.value
+        }
+      };
+    }
+  },
+  {
+    noun: "repo",
+    verb: "update",
+    operation: "update_repo",
+    summary: "Edit a repository, and archive or un-archive it.",
+    buildInput: (rest, flags) => {
+      const idResult = idArg(rest, "repo update");
+      if (!("id" in idResult)) return idResult;
+      const displayName = stringFlag(flags, "display-name");
+      if (!displayName.ok) return displayName;
+      const defaultBranch = stringFlag(flags, "default-branch");
+      if (!defaultBranch.ok) return defaultBranch;
+      const host = stringFlag(flags, "host");
+      if (!host.ok) return host;
+      const needsVisualReview = booleanFlag(flags, "needs-visual-review");
+      if (!needsVisualReview.ok) return needsVisualReview;
+      const archive = booleanFlag(flags, "archive");
+      if (!archive.ok) return archive;
+      const unarchive = booleanFlag(flags, "unarchive");
+      if (!unarchive.ok) return unarchive;
+      if (archive.value && unarchive.value) {
+        return {
+          ok: false,
+          envelope: malformed("--archive and --unarchive are mutually exclusive.", ["archived"])
+        };
+      }
+      return {
+        ok: true,
+        input: {
+          id: idResult.id,
+          ...displayName.value === void 0 ? {} : { displayName: displayName.value },
+          ...defaultBranch.value === void 0 ? {} : { defaultBranch: defaultBranch.value },
+          ...host.value === void 0 ? {} : { host: host.value },
+          ...needsVisualReview.value ? { needsVisualReview: true } : {},
+          ...archive.value ? { archived: true } : {},
+          ...unarchive.value ? { archived: false } : {}
+        }
+      };
+    }
+  },
+  // ── area ──────────────────────────────────────────────────────────────
+  {
+    noun: "area",
+    verb: "list",
+    operation: "list_areas",
+    summary: "List areas.",
+    buildInput: (_rest, flags) => {
+      const includeArchived = booleanFlag(flags, "include-archived");
+      if (!includeArchived.ok) return includeArchived;
+      return { ok: true, input: { includeArchived: includeArchived.value } };
+    }
+  },
+  {
+    noun: "area",
+    verb: "get",
+    operation: "get_area",
+    summary: "Show one area.",
+    buildInput: (rest) => {
+      const idResult = idArg(rest, "area get");
+      if (!("id" in idResult)) return idResult;
+      return { ok: true, input: { id: idResult.id } };
+    }
+  },
+  {
+    noun: "area",
+    verb: "create",
+    operation: "create_area",
+    summary: "Find or create an area by its normalised name.",
+    buildInput: (rest) => {
+      const name = rest[0];
+      if (name === void 0) {
+        return { ok: false, envelope: malformed("`standup area create` needs a name.", ["name"]) };
+      }
+      return { ok: true, input: { name } };
+    }
+  },
+  {
+    noun: "area",
+    verb: "update",
+    operation: "update_area",
+    summary: "Rename an area's display name, and archive or un-archive it.",
+    buildInput: (rest, flags) => {
+      const idResult = idArg(rest, "area update");
+      if (!("id" in idResult)) return idResult;
+      const displayName = stringFlag(flags, "display-name");
+      if (!displayName.ok) return displayName;
+      const archive = booleanFlag(flags, "archive");
+      if (!archive.ok) return archive;
+      const unarchive = booleanFlag(flags, "unarchive");
+      if (!unarchive.ok) return unarchive;
+      if (archive.value && unarchive.value) {
+        return {
+          ok: false,
+          envelope: malformed("--archive and --unarchive are mutually exclusive.", ["archived"])
+        };
+      }
+      return {
+        ok: true,
+        input: {
+          id: idResult.id,
+          ...displayName.value === void 0 ? {} : { displayName: displayName.value },
+          ...archive.value ? { archived: true } : {},
+          ...unarchive.value ? { archived: false } : {}
+        }
+      };
+    }
+  },
+  {
+    noun: "area",
+    verb: "merge",
+    operation: "merge_areas",
+    summary: "Fold one area's membership into another, and archive the losing area.",
+    // No local "needs two ids" or "from === to" check: `merge_areas`'
+    // own schema (`min(1)` on both fields) and its `SAME_AREA_GUARD` are
+    // what refuse those, exactly as they do for the `http` and `mcp`
+    // adapters — the http route (`../../app/api/areas/merge/route.ts`)
+    // passes its body straight through with no route-side validation
+    // either. Refusing here first would mean this adapter answers a
+    // missing/duplicate `from`/`to` with `malformed_command` while the
+    // other two answer `invalid_input`/`area_merge.same_area` for the
+    // identical caller mistake — the divergence the conformance suite's
+    // assertion 4 bound exists to catch. `from`/`to` are simply passed
+    // through, undefined or not, and the operation says what is wrong.
+    buildInput: (rest) => ({ ok: true, input: { from: rest[0], to: rest[1] } })
+  },
+  // ── machine ───────────────────────────────────────────────────────────
+  {
+    noun: "machine",
+    verb: "list",
+    operation: "list_machines",
+    summary: "List machines.",
+    buildInput: () => ({ ok: true, input: {} })
+  },
+  {
+    noun: "machine",
+    verb: "get",
+    operation: "get_machine",
+    summary: "Show one machine.",
+    buildInput: (rest) => {
+      const id = rest[0];
+      if (id === void 0) {
+        return { ok: false, envelope: malformed("`standup machine get` needs a name.", ["name"]) };
+      }
+      return { ok: true, input: { name: id } };
+    }
+  },
+  {
+    noun: "machine",
+    verb: "update",
+    operation: "update_machine",
+    summary: "Set or clear a machine's source-globs override, creating it if it is new.",
+    buildInput: (rest, flags) => {
+      const name = rest[0];
+      if (name === void 0) {
+        return {
+          ok: false,
+          envelope: malformed("`standup machine update` needs a name.", ["name"])
+        };
+      }
+      const sourceGlobs = sourceGlobsFlag(flags);
+      if (!sourceGlobs.ok) return sourceGlobs;
+      return {
+        ok: true,
+        input: {
+          name,
+          ..."value" in sourceGlobs ? { sourceGlobs: sourceGlobs.value } : {}
+        }
+      };
+    }
+  },
+  // ── account ───────────────────────────────────────────────────────────
+  {
+    noun: "account",
+    verb: "list",
+    operation: "list_accounts",
+    summary: "List accounts.",
+    buildInput: () => ({ ok: true, input: {} })
+  },
+  {
+    noun: "account",
+    verb: "get",
+    operation: "get_account",
+    summary: "Show one account.",
+    buildInput: (rest) => {
+      const idResult = idArg(rest, "account get");
+      if (!("id" in idResult)) return idResult;
+      return { ok: true, input: { id: idResult.id } };
+    }
+  },
+  {
+    noun: "account",
+    verb: "update",
+    operation: "update_account",
+    summary: "Edit an account, or create one if the id is new (needs vendor, display-name, plan-type).",
+    buildInput: (rest, flags) => {
+      const idResult = idArg(rest, "account update");
+      if (!("id" in idResult)) return idResult;
+      const vendor = stringFlag(flags, "vendor");
+      if (!vendor.ok) return vendor;
+      const displayName = stringFlag(flags, "display-name");
+      if (!displayName.ok) return displayName;
+      const planType = stringFlag(flags, "plan-type");
+      if (!planType.ok) return planType;
+      const budgetWindows = budgetWindowsFlag(flags);
+      if (!budgetWindows.ok) return budgetWindows;
+      return {
+        ok: true,
+        input: {
+          id: idResult.id,
+          ...vendor.value === void 0 ? {} : { vendor: vendor.value },
+          ...displayName.value === void 0 ? {} : { displayName: displayName.value },
+          ...planType.value === void 0 ? {} : { planType: planType.value },
+          ..."value" in budgetWindows ? { budgetWindows: budgetWindows.value } : {}
+        }
+      };
+    }
+  }
+]);
+
+// src/lib/cli/commands-ownership.ts
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["json", "direct", "as", "session", "url", "help"]);
+function passThroughFlags(flags, consumed = []) {
+  const input = {};
+  for (const [name, value] of Object.entries(flags)) {
+    if (GLOBAL_FLAGS.has(name)) continue;
+    if (consumed.includes(name)) continue;
+    if (value === true) {
+      return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+    }
+    input[name] = value;
+  }
+  return { ok: true, input };
+}
+function itemIdPositional(rest, usage) {
+  const itemId = rest[0];
+  if (itemId === void 0) {
+    return { ok: false, envelope: malformed(`\`standup ${usage}\` needs an item id.`, ["itemId"]) };
+  }
+  return { ok: true, itemId };
+}
+function withSessionId(input, flags) {
+  const session = stringFlag(flags, "session");
+  if (!session.ok) return session;
+  return {
+    ok: true,
+    input: session.value === void 0 ? input : { ...input, sessionId: session.value }
+  };
+}
+function buildClaimInput(rest, flags) {
+  const idResult = itemIdPositional(rest, "session claim <item-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  const input = { ...withSession.input, itemId: idResult.itemId };
+  const pid = numericFlag(flags, "pid");
+  if (!pid.ok) return pid;
+  if (pid.value !== void 0) input.pid = pid.value;
+  return { ok: true, input };
+}
+function buildItemSessionInput(usage) {
+  return (rest, flags) => {
+    const idResult = itemIdPositional(rest, usage);
+    if (!idResult.ok) return idResult;
+    const passthrough = passThroughFlags(flags);
+    if (!passthrough.ok) return passthrough;
+    const withSession = withSessionId(passthrough.input, flags);
+    if (!withSession.ok) return withSession;
+    return { ok: true, input: { ...withSession.input, itemId: idResult.itemId } };
+  };
+}
+function buildCheckpointInput(rest, flags) {
+  const idResult = itemIdPositional(rest, "session checkpoint <item-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return { ok: true, input: { ...withSession.input, itemId: idResult.itemId } };
+}
+function buildTakeoverInput(rest, flags) {
+  const idResult = itemIdPositional(rest, "session takeover <item-id>");
+  if (!idResult.ok) return idResult;
+  const force = booleanFlag(flags, "force");
+  if (!force.ok) return force;
+  const others = Object.fromEntries(
+    Object.entries(flags).filter(([name]) => name !== "force")
+  );
+  const passthrough = passThroughFlags(others);
+  if (!passthrough.ok) return passthrough;
+  const input = { ...passthrough.input, itemId: idResult.itemId };
+  if (flags.force !== void 0) input.force = force.value;
+  return { ok: true, input };
+}
+function buildSweepInput(_rest, flags) {
+  const dryRun = booleanFlag(flags, "dry-run");
+  if (!dryRun.ok) return dryRun;
+  const others = Object.fromEntries(
+    Object.entries(flags).filter(([name]) => name !== "dry-run")
+  );
+  const passthrough = passThroughFlags(others);
+  if (!passthrough.ok) return passthrough;
+  const input = { ...passthrough.input };
+  if (flags["dry-run"] !== void 0) input.dryRun = dryRun.value;
+  return { ok: true, input };
+}
+function buildMyWorkInput(_rest, flags) {
+  const passthrough = passThroughFlags(flags);
+  if (!passthrough.ok) return passthrough;
+  return withSessionId(passthrough.input, flags);
+}
+function buildProgressReportInput(_rest, flags) {
+  const includeCompleted = booleanFlag(flags, "include-completed");
+  if (!includeCompleted.ok) return includeCompleted;
+  const passthrough = passThroughFlags(flags, ["include-completed"]);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return {
+    ok: true,
+    input: { ...withSession.input, includeCompleted: includeCompleted.value }
+  };
+}
+function buildNoteInput(rest, flags) {
+  const idResult = itemIdPositional(rest, "item note <item-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return { ok: true, input: { ...withSession.input, itemId: idResult.itemId } };
+}
+function buildOrientationInput(rest, flags) {
+  const idResult = itemIdPositional(rest, "item orientation <item-id>");
+  if (!idResult.ok) return idResult;
+  const limit = numericFlag(flags, "limit");
+  if (!limit.ok) return limit;
+  const passthrough = passThroughFlags(flags, ["limit"]);
+  if (!passthrough.ok) return passthrough;
+  return {
+    ok: true,
+    input: {
+      ...passthrough.input,
+      itemId: idResult.itemId,
+      ...limit.value === void 0 ? {} : { limit: limit.value }
+    }
+  };
+}
+function buildCrewNameInput(_rest, flags) {
+  const passthrough = passThroughFlags(flags);
+  if (!passthrough.ok) return passthrough;
+  return withSessionId(passthrough.input, flags);
+}
+var OWNERSHIP_COMMANDS = Object.freeze([
+  {
+    noun: "session",
+    verb: "claim",
+    operation: "claim",
+    summary: "Takes ownership of an item in a role. Atomic \u2014 two agents can't both win.",
+    buildInput: buildClaimInput
+  },
+  {
+    noun: "session",
+    verb: "release",
+    operation: "release",
+    summary: "Gives up ownership of an item.",
+    buildInput: buildItemSessionInput("session release <item-id>")
+  },
+  {
+    noun: "session",
+    verb: "heartbeat",
+    operation: "heartbeat",
+    summary: "Still alive. Unnecessary if your hook flushes tool calls; needed if you run no hook.",
+    buildInput: buildItemSessionInput("session heartbeat <item-id>")
+  },
+  {
+    noun: "session",
+    verb: "takeover",
+    operation: "takeover",
+    summary: "Takes an item from another session. Free if that session is dead; needs --force and --reason if it may be alive.",
+    buildInput: buildTakeoverInput
+  },
+  {
+    noun: "session",
+    verb: "sweep",
+    operation: "sweep",
+    summary: "Runs the liveness sweep: ages quiet sessions, releases claims held by dead ones, escalates stuck items. --dry-run reports what it would do and writes nothing.",
+    buildInput: buildSweepInput
+  },
+  {
+    noun: "session",
+    verb: "checkpoint",
+    operation: "checkpoint",
+    summary: "Records what you tried, what you ruled out, what's next. --headline gives it a one-line BLUF that reads pick up without the prose.",
+    buildInput: buildCheckpointInput
+  },
+  {
+    noun: "session",
+    verb: "my-work",
+    operation: "my_work",
+    summary: "What this session holds right now, and in what role.",
+    buildInput: buildMyWorkInput
+  },
+  {
+    noun: "session",
+    verb: "progress",
+    operation: "progress_report",
+    summary: "A progress report on everything this session holds, in one fixed shape every time it is asked. Finished work is counted but not listed; --include-completed lists it.",
+    buildInput: buildProgressReportInput
+  },
+  {
+    noun: "item",
+    verb: "note",
+    operation: "note",
+    summary: "Leaves a timestamped remark on an item.",
+    buildInput: buildNoteInput
+  },
+  {
+    noun: "item",
+    verb: "orientation",
+    operation: "orientation",
+    summary: "Catch me up: latest checkpoint, current state, what changed since, open loops, and crew.",
+    buildInput: buildOrientationInput
+  },
+  {
+    noun: "crew",
+    verb: "name",
+    operation: "get_crew_name",
+    summary: "Requests a name for a new agent. Hands out one available name, atomically.",
+    buildInput: buildCrewNameInput
+  }
+]);
+var OWNERSHIP_ALIASES = Object.freeze(
+  {
+    claim: ["session", "claim"],
+    sweep: ["session", "sweep"]
+  }
+);
+
+// src/lib/cli/config-command.ts
+function parseSettingValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function confirmationGate(key, flags, verb) {
+  if (!isSettingKey(key)) return void 0;
+  const definition = getDefinition(key);
+  if (!definition.sensitive && !definition.irreversible) return void 0;
+  const confirm = booleanFlag(flags, "confirm");
+  if (!confirm.ok) return confirm;
+  if (confirm.value) return void 0;
+  const why = definition.irreversible ? "irreversible \u2014 it can destroy data that cannot be recreated" : "sensitive \u2014 it relaxes something this build enforces";
+  return {
+    ok: false,
+    envelope: malformed(`${key} is ${why}. Re-run with --confirm to ${verb} it.`, ["confirm"])
+  };
+}
+function buildListInput() {
+  return { ok: true, input: {} };
+}
+function buildGetInput(rest, verb) {
+  const key = rest[0];
+  if (key === void 0) {
+    return {
+      ok: false,
+      envelope: malformed(`\`standup config ${verb}\` needs a setting key.`, ["key"])
+    };
+  }
+  return { ok: true, input: { key } };
+}
+function buildSetInput(rest, flags) {
+  const key = rest[0];
+  if (key === void 0) {
+    return {
+      ok: false,
+      envelope: malformed("`standup config set` needs a setting key and a value.", ["key"])
+    };
+  }
+  if (rest.length < 2) {
+    return {
+      ok: false,
+      envelope: malformed(`\`standup config set ${key}\` needs a value.`, ["value"])
+    };
+  }
+  const gated = confirmationGate(key, flags, "set");
+  if (gated) return gated;
+  const raw = rest[1];
+  return { ok: true, input: { key, value: parseSettingValue(raw) } };
+}
+function buildClearInput(rest, flags) {
+  const key = rest[0];
+  if (key === void 0) {
+    return {
+      ok: false,
+      envelope: malformed("`standup config clear` needs a setting key.", ["key"])
+    };
+  }
+  const gated = confirmationGate(key, flags, "clear");
+  if (gated) return gated;
+  return { ok: true, input: { key } };
+}
+var CONFIG_COMMANDS = Object.freeze([
+  {
+    noun: "config",
+    verb: "list",
+    operation: "get_settings",
+    summary: "List every declared setting: value, source, label, help and category.",
+    buildInput: buildListInput
+  },
+  {
+    noun: "config",
+    verb: "get",
+    operation: "get_setting",
+    summary: "Show one setting: its value, source, label, help and category.",
+    buildInput: (rest) => buildGetInput(rest, "get")
+  },
+  {
+    noun: "config",
+    verb: "describe",
+    operation: "get_setting",
+    summary: "Explain one setting \u2014 same detail as `get`, worded for reading before changing it.",
+    buildInput: (rest) => buildGetInput(rest, "describe")
+  },
+  {
+    noun: "config",
+    verb: "set",
+    operation: "put_setting",
+    summary: "Set one setting's override. `sensitive`/`irreversible` keys need --confirm.",
+    buildInput: (rest, flags) => buildSetInput(rest, flags)
+  },
+  {
+    noun: "config",
+    verb: "clear",
+    operation: "delete_setting",
+    summary: "Clear one setting's override, reverting it to the registry default. `sensitive`/`irreversible` keys need --confirm.",
+    buildInput: (rest, flags) => buildClearInput(rest, flags)
+  }
+]);
+
+// src/lib/cli/commands-backfill.ts
+import { readFileSync } from "node:fs";
+var BACKFILL_FILE_FLAG = "file";
+function readPayloadFile(flags) {
+  const file2 = flags[BACKFILL_FILE_FLAG];
+  if (file2 === void 0) {
+    return {
+      ok: false,
+      envelope: malformed("`standup backfill run` needs --file <payload.json>.", [
+        BACKFILL_FILE_FLAG
+      ])
+    };
+  }
+  if (file2 === true) {
+    return {
+      ok: false,
+      envelope: malformed(`--${BACKFILL_FILE_FLAG} needs a value.`, [BACKFILL_FILE_FLAG])
+    };
+  }
+  let text;
+  try {
+    text = readFileSync(file2, "utf-8");
+  } catch {
+    return {
+      ok: false,
+      envelope: malformed(`Could not read ${file2}.`, [BACKFILL_FILE_FLAG])
+    };
+  }
+  try {
+    return { ok: true, input: { payload: JSON.parse(text) } };
+  } catch {
+    return {
+      ok: false,
+      envelope: malformed(`${file2} is not valid JSON.`, [BACKFILL_FILE_FLAG])
+    };
+  }
+}
+var BACKFILL_COMMANDS = Object.freeze([
+  {
+    noun: "backfill",
+    verb: "run",
+    operation: "backfill",
+    summary: "Bulk-load an existing body of work from a payload file. Needs ENABLE_BACKFILL=true.",
+    buildInput: (_rest, flags) => readPayloadFile(flags)
+  }
+]);
+
+// src/lib/cli/commands-artifacts.ts
+var GLOBAL_FLAGS2 = /* @__PURE__ */ new Set(["json", "direct", "as", "session", "url", "help"]);
+function passThroughFlags2(flags) {
+  const input = {};
+  for (const [name, value] of Object.entries(flags)) {
+    if (GLOBAL_FLAGS2.has(name)) continue;
+    if (value === true) {
+      return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+    }
+    input[name] = value;
+  }
+  return { ok: true, input };
+}
+function itemIdPositional2(rest, usage) {
+  const itemId = rest[0];
+  if (itemId === void 0) {
+    return { ok: false, envelope: malformed(`\`standup ${usage}\` needs an item id.`, ["itemId"]) };
+  }
+  return { ok: true, itemId };
+}
+function withSessionId2(input, flags) {
+  const session = stringFlag(flags, "session");
+  if (!session.ok) return session;
+  if (session.value === void 0) return { ok: true, input };
+  return { ok: true, input: { ...input, sessionId: session.value } };
+}
+function buildRecordArtifactInput(rest, flags) {
+  const idResult = itemIdPositional2(rest, "item artifact <item-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags2(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId2(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return { ok: true, input: { ...withSession.input, itemId: idResult.itemId } };
+}
+function buildRequestReviewInput(rest, flags) {
+  const idResult = itemIdPositional2(rest, "item request-review <item-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags2(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId2(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return { ok: true, input: { ...withSession.input, itemId: idResult.itemId } };
+}
+var ARTIFACT_COMMANDS = Object.freeze([
+  {
+    noun: "item",
+    verb: "artifact",
+    operation: "record_artifact",
+    summary: "Records an artifact \u2014 a plan, a review, a commit, a screenshot \u2014 against an item.",
+    buildInput: buildRecordArtifactInput
+  },
+  {
+    noun: "item",
+    verb: "request-review",
+    operation: "request_review",
+    summary: "Requests a review of an item, recording that one was asked for.",
+    buildInput: buildRequestReviewInput
+  }
+]);
+
+// src/lib/cli/commands-loops.ts
+var GLOBAL_FLAGS3 = /* @__PURE__ */ new Set(["json", "direct", "as", "session", "url", "help"]);
+function passThroughFlags3(flags, consumed = []) {
+  const input = {};
+  for (const [name, value] of Object.entries(flags)) {
+    if (GLOBAL_FLAGS3.has(name)) continue;
+    if (consumed.includes(name)) continue;
+    if (value === true) {
+      return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+    }
+    input[name] = value;
+  }
+  return { ok: true, input };
+}
+function itemIdPositional3(rest, usage) {
+  const itemId = rest[0];
+  if (itemId === void 0) {
+    return { ok: false, envelope: malformed(`\`standup ${usage}\` needs an item id.`, ["itemId"]) };
+  }
+  return { ok: true, itemId };
+}
+function withSessionId3(input, flags) {
+  const session = stringFlag(flags, "session");
+  if (!session.ok) return session;
+  if (session.value === void 0) return { ok: true, input };
+  return { ok: true, input: { ...input, sessionId: session.value } };
+}
+function buildLoopAddInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loop <item-id> <text>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags3(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId3(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  const words = rest.slice(1);
+  const input = { ...withSession.input, itemId: idResult.itemId };
+  if (words.length > 0) {
+    input.text = words.join(" ");
+  }
+  return { ok: true, input };
+}
+function buildLoopCloseInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loop-close <item-id> <loop-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags3(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId3(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  const input = { ...withSession.input, itemId: idResult.itemId };
+  const loopId = rest[1];
+  if (loopId !== void 0) {
+    input.loopId = loopId;
+  }
+  return { ok: true, input };
+}
+function buildLoopListInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loops <item-id>");
+  if (!idResult.ok) return idResult;
+  const all = booleanFlag(flags, "all");
+  if (!all.ok) return all;
+  const deleted = booleanFlag(flags, "deleted");
+  if (!deleted.ok) return deleted;
+  const notes = booleanFlag(flags, "notes");
+  if (!notes.ok) return notes;
+  const passthrough = passThroughFlags3(flags, ["all", "deleted", "notes"]);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId3(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  return {
+    ok: true,
+    input: {
+      ...withSession.input,
+      itemId: idResult.itemId,
+      includeClosed: all.value,
+      includeDeleted: deleted.value,
+      includeNonWork: notes.value
+    }
+  };
+}
+function buildLoopGetInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loop-get <item-id> <loop-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags3(flags);
+  if (!passthrough.ok) return passthrough;
+  const input = { ...passthrough.input, itemId: idResult.itemId };
+  const loopId = rest[1];
+  if (loopId !== void 0) {
+    input.loopId = loopId;
+  }
+  return { ok: true, input };
+}
+function buildLoopEditInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loop-edit <item-id> <loop-id> <text>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags3(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId3(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  const input = { ...withSession.input, itemId: idResult.itemId };
+  const loopId = rest[1];
+  if (loopId !== void 0) {
+    input.loopId = loopId;
+  }
+  const words = rest.slice(2);
+  if (words.length > 0) {
+    input.text = words.join(" ");
+  }
+  return { ok: true, input };
+}
+function buildLoopDeleteInput(rest, flags) {
+  const idResult = itemIdPositional3(rest, "item loop-delete <item-id> <loop-id>");
+  if (!idResult.ok) return idResult;
+  const passthrough = passThroughFlags3(flags);
+  if (!passthrough.ok) return passthrough;
+  const withSession = withSessionId3(passthrough.input, flags);
+  if (!withSession.ok) return withSession;
+  const input = { ...withSession.input, itemId: idResult.itemId };
+  const loopId = rest[1];
+  if (loopId !== void 0) {
+    input.loopId = loopId;
+  }
+  return { ok: true, input };
+}
+var LOOP_COMMANDS = Object.freeze([
+  {
+    noun: "item",
+    verb: "loop",
+    operation: "loop_add",
+    summary: "Records a loose end on an item \u2014 a piece of work that still needs doing but is not big enough to be its own item. Loops track WORK: a reference or a status note belongs in the repo or in a note, not here. --kind note keeps one out of the count of work outstanding; --kind blocked_on_person is for something real waiting on a human.",
+    buildInput: buildLoopAddInput
+  },
+  {
+    noun: "item",
+    verb: "loop-close",
+    operation: "loop_close",
+    summary: "Closes an open loop on an item. --reason optionally records how it was resolved, and is reported with the closed loop.",
+    buildInput: buildLoopCloseInput
+  },
+  {
+    noun: "item",
+    verb: "loops",
+    operation: "loop_list",
+    summary: "List an item's loops \u2014 id, kind, status, when it opened and the first 200 characters. Open loops that track work only; --all includes closed ones, --deleted includes retracted ones, --notes includes loops filed as notes.",
+    buildInput: buildLoopListInput
+  },
+  {
+    noun: "item",
+    verb: "loop-get",
+    operation: "loop_get",
+    summary: "Show one loop on an item in full, by its loop id.",
+    buildInput: buildLoopGetInput
+  },
+  {
+    noun: "item",
+    verb: "loop-edit",
+    operation: "loop_edit",
+    summary: "Rewrite an open loop's text. Keeps its original openedAt.",
+    buildInput: buildLoopEditInput
+  },
+  {
+    noun: "item",
+    verb: "loop-delete",
+    operation: "loop_delete",
+    summary: "Retract a loop that should never have existed \u2014 a duplicate, or one recorded by accident. Needs --reason. Use loop-close for a real loose end that is resolved.",
+    buildInput: buildLoopDeleteInput
+  }
+]);
+
+// src/lib/cli/commands-sessions.ts
+var GLOBAL_FLAGS4 = /* @__PURE__ */ new Set(["json", "direct", "as", "session", "url", "help"]);
+function buildRegisterInput(_rest, flags) {
+  const session = stringFlag(flags, "session");
+  if (!session.ok) return session;
+  if (session.value === void 0) {
+    return {
+      ok: false,
+      envelope: malformed("`standup session register` needs --session.", ["sessionId"])
+    };
+  }
+  const hookVersion = numericFlag(flags, "hook-version");
+  if (!hookVersion.ok) return hookVersion;
+  const input = { sessionId: session.value };
+  for (const [name, value] of Object.entries(flags)) {
+    if (GLOBAL_FLAGS4.has(name)) continue;
+    if (name === "hook-version") continue;
+    if (value === true) {
+      return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+    }
+    input[name === "hook-variant" ? "hookVariant" : name] = value;
+  }
+  if (hookVersion.value !== void 0) input.hookVersion = hookVersion.value;
+  return { ok: true, input };
+}
+var SESSION_COMMANDS = Object.freeze([
+  {
+    noun: "session",
+    verb: "register",
+    operation: "register_session",
+    summary: "Registers this session and reports which hook to install, and whether it may claim (`hook.require_registration_to_claim`, off by default, is what decides this \u2014 the protocol version alone does not).",
+    buildInput: buildRegisterInput
+  }
+]);
+
+// src/lib/cli/commands.ts
+function noInput() {
+  return { ok: true, input: {} };
+}
+var GLOBAL_FLAGS5 = /* @__PURE__ */ new Set(["json", "direct", "as", "session", "url", "help"]);
+function flagsToInput(flags, consumed = []) {
+  const input = {};
+  for (const [name, value] of Object.entries(flags)) {
+    if (GLOBAL_FLAGS5.has(name)) continue;
+    if (consumed.includes(name)) continue;
+    if (value === true) {
+      return { ok: false, envelope: malformed(`--${name} needs a value.`, [name]) };
+    }
+    input[name] = value;
+  }
+  return { ok: true, input };
+}
+function jsonFlag(flags, name) {
+  const raw = stringFlag(flags, name);
+  if (!raw.ok) return raw;
+  if (raw.value === void 0) return { ok: true };
+  try {
+    return { ok: true, value: JSON.parse(raw.value) };
+  } catch {
+    return { ok: false, envelope: malformed(`--${name} must be valid JSON.`, [name]) };
+  }
+}
+var COMMANDS = Object.freeze([
+  {
+    noun: "item",
+    verb: "get",
+    operation: "get_item",
+    summary: "Show one item \u2014 id, title, state, headline and the latest checkpoint's headline; --full for the whole record.",
+    /**
+     * `--full` is the command line's spelling of the `full` opt-in
+     * (MILESTONES.md #107) — a bare switch, for the same reason `--all` is
+     * on `item list`: `--full true` is not a thing anyone types. It goes
+     * through `booleanFlag` rather than `flagsToInput`, which refuses a
+     * valueless flag outright.
+     */
+    buildInput: (rest, flags) => {
+      const id = rest[0];
+      if (id === void 0) {
+        return { ok: false, envelope: malformed("`standup item get` needs an item id.", ["id"]) };
+      }
+      const full = booleanFlag(flags, "full");
+      if (!full.ok) return full;
+      return { ok: true, input: { id, full: full.value } };
+    }
+  },
+  {
+    noun: "item",
+    verb: "search",
+    operation: "search",
+    summary: "Find items by text in their title, headline or body, best match first. Searches every state including finished work \u2014 --open-only excludes it.",
+    /**
+     * The query is a positional argument rather than a flag, because it is
+     * the whole point of the command and `standup item search hook script`
+     * is how anyone would type it. The words are rejoined with single
+     * spaces: a shell splits an unquoted phrase into several arguments, and
+     * refusing everything past the first would make the quoting mandatory
+     * for the most ordinary use of the verb.
+     */
+    buildInput: (rest, flags) => {
+      const query = rest.join(" ").trim();
+      if (query === "") {
+        return {
+          ok: false,
+          envelope: malformed("`standup item search` needs something to search for.", ["query"])
+        };
+      }
+      const openOnly = booleanFlag(flags, "open-only");
+      if (!openOnly.ok) return openOnly;
+      const limit = numericFlag(flags, "limit");
+      if (!limit.ok) return limit;
+      const built = flagsToInput(flags, ["open-only", "limit"]);
+      if (!built.ok) return built;
+      return {
+        ok: true,
+        input: {
+          ...built.input,
+          query,
+          openOnly: openOnly.value,
+          ...limit.value === void 0 ? {} : { limit: limit.value }
+        }
+      };
+    }
+  },
+  {
+    noun: "item",
+    verb: "list",
+    operation: "list_items",
+    summary: "List items, filtered by state, priority, area, repo or parent. Returns id, title, state and headline; --full for whole records. Finished work is excluded by default; --all includes it.",
+    /**
+     * `--all` is the command line's spelling of `includeTerminal`
+     * (MILESTONES.md #103) — a bare flag, because that is what a switch
+     * looks like here and `--include-terminal true` is not a thing anyone
+     * would type. It cannot go through `flagsToInput`, which refuses a
+     * valueless flag outright ("--all needs a value"), so this verb builds
+     * its own input: `booleanFlag` for the switch, `flagsToInput` for
+     * everything else, with `--all` declared consumed so it does not arrive
+     * at the operation twice under two names.
+     */
+    buildInput: (_rest, flags) => {
+      const all = booleanFlag(flags, "all");
+      if (!all.ok) return all;
+      const full = booleanFlag(flags, "full");
+      if (!full.ok) return full;
+      const limit = numericFlag(flags, "limit");
+      if (!limit.ok) return limit;
+      const built = flagsToInput(flags, ["all", "full", "limit"]);
+      if (!built.ok) return built;
+      return {
+        ok: true,
+        input: {
+          ...built.input,
+          includeTerminal: all.value,
+          full: full.value,
+          ...limit.value === void 0 ? {} : { limit: limit.value }
+        }
+      };
+    }
+  },
+  {
+    noun: "item",
+    verb: "stale",
+    operation: "get_stale_candidates",
+    summary: "List open rows that another row's recorded work already named \u2014 the check that catches a stale row before a crew is dispatched onto it. Reports evidence and closes nothing. --include-unlanded also shows rows named only by a plan or a review.",
+    /**
+     * `--include-unlanded` is a bare switch, so it cannot go through
+     * `flagsToInput` (which refuses a valueless flag), and `--limit` is a
+     * `z.number()` field where a flag is always a string. Both are built
+     * here and declared consumed so neither reaches the operation twice
+     * under two spellings — the same shape `item list` uses for `--all`.
+     */
+    buildInput: (_rest, flags) => {
+      const includeUnlanded = booleanFlag(flags, "include-unlanded");
+      if (!includeUnlanded.ok) return includeUnlanded;
+      const limit = numericFlag(flags, "limit");
+      if (!limit.ok) return limit;
+      const built = flagsToInput(flags, ["include-unlanded", "limit"]);
+      if (!built.ok) return built;
+      return {
+        ok: true,
+        input: {
+          ...built.input,
+          includeUnlanded: includeUnlanded.value,
+          ...limit.value === void 0 ? {} : { limit: limit.value }
+        }
+      };
+    }
+  },
+  {
+    noun: "item",
+    verb: "create",
+    operation: "create_item",
+    summary: "Deprecated \u2014 use `project create`, `task create` or `subtask create`. Creates an item whose kind is inferred from --parentId.",
+    buildInput: (_rest, flags) => flagsToInput(flags)
+  },
+  // The three explicit creates, one noun each. A separate noun rather than
+  // `item create --kind project`: a `--kind` flag would be a value the
+  // operation would then have to reconcile against the parent it was given,
+  // which is the ambiguity these commands exist to remove. The noun *is* the
+  // kind, so there is nothing to reconcile.
+  //
+  // The parent goes through `flagsToInput` like every other field rather
+  // than being read as a positional. It is required, but requiredness is the
+  // operation's schema's to enforce (this file's header: "Field validation
+  // is not done here"), and a positional would produce a second rejection
+  // this adapter could give that no other adapter would.
+  {
+    noun: "project",
+    verb: "create",
+    operation: "create_project",
+    summary: "Create a project \u2014 a root container for tasks. A project has no state of its own and cannot be transitioned.",
+    buildInput: (_rest, flags) => flagsToInput(flags)
+  },
+  {
+    noun: "task",
+    verb: "create",
+    operation: "create_task",
+    summary: 'Create a task under a project. --projectId is required; pass a project id, or "inbox" for the configured inbox project.',
+    buildInput: (_rest, flags) => flagsToInput(flags)
+  },
+  {
+    noun: "subtask",
+    verb: "create",
+    operation: "create_subtask",
+    summary: "Create a subtask under a task. --taskId is required and must name a task, not a project.",
+    buildInput: (_rest, flags) => flagsToInput(flags)
+  },
+  {
+    noun: "item",
+    verb: "update",
+    operation: "update_item",
+    summary: "Edit an item's non-state fields.",
+    buildInput: (rest, flags) => {
+      const id = rest[0];
+      if (id === void 0) {
+        return {
+          ok: false,
+          envelope: malformed("`standup item update` needs an item id.", ["id"])
+        };
+      }
+      const built = flagsToInput(flags);
+      if (!built.ok) return built;
+      return { ok: true, input: { id, ...built.input } };
+    }
+  },
+  {
+    noun: "item",
+    verb: "transition",
+    operation: "transition_item",
+    summary: "Move an item to a new state. --dry-run previews the outcome, including a rejection, without writing (routes to the service layer's rehearsal mode \u2014 MILESTONES.md #27).",
+    buildInput: (rest, flags) => {
+      const id = rest[0];
+      if (id === void 0) {
+        return {
+          ok: false,
+          envelope: malformed("`standup item transition` needs an item id.", ["id"])
+        };
+      }
+      const to = stringFlag(flags, "to");
+      if (!to.ok) return to;
+      if (to.value === void 0) {
+        return { ok: false, envelope: malformed("`standup item transition` needs --to.", ["to"]) };
+      }
+      const dryRun = booleanFlag(flags, "dry-run");
+      if (!dryRun.ok) return dryRun;
+      const fields = jsonFlag(flags, "fields");
+      if (!fields.ok) return fields;
+      const input = { id, to: to.value, dryRun: dryRun.value };
+      if (fields.value !== void 0) input.fields = fields.value;
+      return { ok: true, input };
+    }
+  },
+  {
+    noun: "item",
+    verb: "complete",
+    operation: "complete_item",
+    summary: "Finish an item: move it into a completed state and record the closing summary.",
+    buildInput: (rest, flags) => {
+      const id = rest[0];
+      if (id === void 0) {
+        return {
+          ok: false,
+          envelope: malformed("`standup item complete` needs an item id.", ["id"])
+        };
+      }
+      const to = stringFlag(flags, "to");
+      if (!to.ok) return to;
+      if (to.value === void 0) {
+        return { ok: false, envelope: malformed("`standup item complete` needs --to.", ["to"]) };
+      }
+      const summary = jsonFlag(flags, "summary");
+      if (!summary.ok) return summary;
+      if (summary.value === void 0) {
+        return {
+          ok: false,
+          envelope: malformed("`standup item complete` needs --summary (JSON).", ["summary"])
+        };
+      }
+      const fields = jsonFlag(flags, "fields");
+      if (!fields.ok) return fields;
+      const input = { id, to: to.value, summary: summary.value };
+      if (fields.value !== void 0) input.fields = fields.value;
+      return { ok: true, input };
+    }
+  },
+  {
+    noun: "service",
+    verb: "info",
+    operation: "service_info",
+    summary: "What this build exposes, and the limits a caller has to respect.",
+    buildInput: noInput
+  },
+  // MILESTONES.md #92 — repo/area/machine/account nouns. Kept in their own
+  // module (./commands-admin.ts) and appended here as a single spread, per
+  // that module's own header, so concurrent CLI rows landing entries above
+  // never conflict with this one.
+  ...ADMIN_COMMANDS,
+  ...OWNERSHIP_COMMANDS,
+  ...CONFIG_COMMANDS,
+  // row #83 — `standup config`
+  ...BACKFILL_COMMANDS,
+  // the one-time bulk load (docs/plans/BACKFILL.md)
+  ...ARTIFACT_COMMANDS,
+  // row #98 — artifact writes
+  ...LOOP_COMMANDS,
+  // row #100 - open-loop writes
+  ...SESSION_COMMANDS
+  // the registration handshake (MILESTONES.md #43, SCHEMA.md §21)
+]);
+var ALIASES = Object.freeze({
+  ls: ["item", "list"],
+  show: ["item", "get"],
+  new: ["item", "create"],
+  ...OWNERSHIP_ALIASES
+});
+function nouns() {
+  return [...new Set(COMMANDS.map((command) => command.noun))].sort();
+}
+function verbsFor(noun) {
+  return COMMANDS.filter((command) => command.noun === noun).map((command) => command.verb).sort();
+}
+function lookupCommand(words) {
+  const first = words[0];
+  if (first === void 0) {
+    return {
+      ok: false,
+      envelope: malformed(
+        `Nothing to do. Usage: standup <noun> <verb>. Nouns: ${nouns().join(", ")}.`
+      )
+    };
+  }
+  const alias = ALIASES[first];
+  const [noun, verb, rest, viaAlias] = alias ? [alias[0], alias[1], words.slice(1), first] : [first, words[1], words.slice(2), void 0];
+  const known = COMMANDS.filter((command2) => command2.noun === noun);
+  if (known.length === 0) {
+    return {
+      ok: false,
+      envelope: malformed(`No such noun: ${noun}. Nouns: ${nouns().join(", ")}.`, ["noun"])
+    };
+  }
+  if (verb === void 0) {
+    return {
+      ok: false,
+      envelope: malformed(
+        `\`standup ${noun}\` needs a verb. Verbs: ${verbsFor(noun).join(", ")}.`,
+        ["verb"]
+      )
+    };
+  }
+  const command = known.find((candidate) => candidate.verb === verb);
+  if (!command) {
+    return {
+      ok: false,
+      envelope: malformed(
+        `No such verb for ${noun}: ${verb}. Verbs: ${verbsFor(noun).join(", ")}.`,
+        ["verb"]
+      )
+    };
+  }
+  return {
+    ok: true,
+    match: { command, rest, ...viaAlias === void 0 ? {} : { viaAlias } }
+  };
+}
+function identityFlags(flags) {
+  const as = stringFlag(flags, "as");
+  if (!as.ok) return as;
+  const session = stringFlag(flags, "session");
+  if (!session.ok) return session;
+  const url = stringFlag(flags, "url");
+  if (!url.ok) return url;
+  return {
+    ok: true,
+    ...as.value === void 0 ? {} : { as: as.value },
+    ...session.value === void 0 ? {} : { session: session.value },
+    ...url.value === void 0 ? {} : { url: url.value }
+  };
+}
+
+// src/lib/cli/binding.ts
+function bindingOk(data) {
+  return { ok: true, data };
+}
+function bindingRejected(rejection, message) {
+  return { ok: false, rejection, message };
+}
+
+// src/lib/cli/config.ts
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== void 0 && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+function resolveConfig({ flags = {}, env = {}, file: file2 = {} } = {}) {
+  const standupUrl = firstDefined(flags.url, env.STANDUP_URL, file2.standupUrl);
+  const databaseUrl = firstDefined(env.DATABASE_URL, file2.databaseUrl);
+  const sessionId = firstDefined(flags.session, env.STANDUP_SESSION_ID, file2.sessionId);
+  const actor = firstDefined(flags.as, env.STANDUP_ACTOR, file2.actor);
+  const token = firstDefined(env.STANDUP_TOKEN, file2.token);
+  const identity = {
+    ...sessionId === void 0 ? {} : { sessionId },
+    ...actor === void 0 ? {} : { actor }
+  };
+  if (flags.direct === true) {
+    if (databaseUrl === void 0) {
+      return unconfigured(
+        "--direct needs a database to talk to, and neither DATABASE_URL nor the local configuration supplied one. Run `standup init` first.",
+        ["DATABASE_URL"]
+      );
+    }
+    return { ok: true, config: { binding: "direct", databaseUrl, ...identity } };
+  }
+  if (standupUrl !== void 0) {
+    return {
+      ok: true,
+      config: {
+        binding: "http",
+        standupUrl,
+        ...identity,
+        ...token === void 0 ? {} : { token }
+      }
+    };
+  }
+  if (databaseUrl !== void 0) {
+    return { ok: true, config: { binding: "direct", databaseUrl, ...identity } };
+  }
+  return unconfigured(
+    "Neither STANDUP_URL nor DATABASE_URL resolved, so there is nothing to talk to. Run `standup init` first.",
+    ["STANDUP_URL", "DATABASE_URL"]
+  );
+}
+function unconfigured(message, fields) {
+  return { ok: false, envelope: malformed(message, fields), exitCode: EXIT.UNCONFIGURED };
+}
+function sourceOf(flag, env, file2) {
+  if (firstDefined(flag) !== void 0) return "flag";
+  if (firstDefined(env) !== void 0) return "environment";
+  if (firstDefined(file2) !== void 0) return "file";
+  return "none";
+}
+function describeResolution({
+  flags = {},
+  env = {},
+  file: file2 = {}
+} = {}) {
+  const entries = [
+    ["STANDUP_URL", flags.url, env.STANDUP_URL, file2.standupUrl],
+    ["DATABASE_URL", void 0, env.DATABASE_URL, file2.databaseUrl],
+    ["STANDUP_SESSION_ID", flags.session, env.STANDUP_SESSION_ID, file2.sessionId],
+    ["STANDUP_ACTOR", flags.as, env.STANDUP_ACTOR, file2.actor]
+  ];
+  return entries.map(([name, flag, envValue, fileValue]) => {
+    const source = sourceOf(flag, envValue, fileValue);
+    return { name, present: source !== "none", source };
+  });
+}
+
+// src/lib/cli/bindings/direct.ts
+function createDirectBinding({ service, sessionId, actor }) {
+  const caller = {
+    transport: "cli-direct",
+    ...sessionId === void 0 ? {} : { sessionId },
+    ...actor === void 0 ? {} : { actor }
+  };
+  return {
+    name: "direct",
+    async invoke(operation, input) {
+      const requestId = newRequestId();
+      try {
+        return bindingOk(
+          await service.call(operation, input, { caller: { ...caller, requestId } })
+        );
+      } catch (error) {
+        if (isRehearsalRollback(error)) {
+          return bindingOk({ outcome: error.outcome });
+        }
+        const serviceError = toServiceError(error);
+        if (serviceError.fault === "server") {
+          log.error("Command failed unexpectedly.", {
+            requestId,
+            transport: caller.transport,
+            operation,
+            ...faultContext(serviceError),
+            err: serviceError
+          });
+        } else {
+          log.debug("Command refused.", {
+            requestId,
+            transport: caller.transport,
+            operation,
+            code: serviceError.code,
+            ...faultContext(serviceError),
+            ...serviceError.guard === void 0 ? {} : { guard: serviceError.guard }
+          });
+        }
+        return bindingRejected(serviceError.toRejection(), serviceError.message);
+      }
+    }
+  };
+}
+
+// src/lib/cli/bindings/http-routes-admin.ts
+function property(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+function queryString(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0) continue;
+    params.set(key, value === null ? "" : String(value));
+  }
+  const query = params.toString();
+  return query.length === 0 ? "" : `?${query}`;
+}
+function without(input, key) {
+  return Object.fromEntries(Object.entries(input).filter(([k]) => k !== key));
+}
+var ADMIN_HTTP_ROUTES = Object.freeze({
+  list_repos: {
+    method: "GET",
+    request: (input) => ({ path: `/api/repos${queryString(input)}` }),
+    unwrap: (body) => body
+  },
+  get_repo: {
+    method: "GET",
+    request: (input) => ({ path: `/api/repos/${encodeURIComponent(String(input.id ?? ""))}` }),
+    unwrap: (body) => property(body, "repo")
+  },
+  create_repo: {
+    method: "POST",
+    request: (input) => ({ path: "/api/repos", body: input }),
+    unwrap: (body) => property(body, "repo")
+  },
+  update_repo: {
+    method: "PATCH",
+    request: (input) => ({
+      path: `/api/repos/${encodeURIComponent(String(input.id ?? ""))}`,
+      body: without(input, "id")
+    }),
+    unwrap: (body) => property(body, "repo")
+  },
+  list_areas: {
+    method: "GET",
+    request: (input) => ({ path: `/api/areas${queryString(input)}` }),
+    unwrap: (body) => body
+  },
+  get_area: {
+    method: "GET",
+    request: (input) => ({ path: `/api/areas/${encodeURIComponent(String(input.id ?? ""))}` }),
+    unwrap: (body) => property(body, "area")
+  },
+  create_area: {
+    method: "POST",
+    request: (input) => ({ path: "/api/areas", body: input }),
+    unwrap: (body) => property(body, "area")
+  },
+  update_area: {
+    method: "PATCH",
+    request: (input) => ({
+      path: `/api/areas/${encodeURIComponent(String(input.id ?? ""))}`,
+      body: without(input, "id")
+    }),
+    unwrap: (body) => property(body, "area")
+  },
+  merge_areas: {
+    method: "POST",
+    request: (input) => ({ path: "/api/areas/merge", body: input }),
+    // `POST /api/areas/merge` returns `MergeAreasOutput` unwrapped — `to`,
+    // `from`, `itemsMerged`, `duplicatesResolved` — same as `list_areas`,
+    // not nested under a named key the way the single-row `get`/`create`
+    // routes are.
+    unwrap: (body) => body
+  },
+  list_machines: {
+    method: "GET",
+    request: () => ({ path: "/api/machines" }),
+    unwrap: (body) => body
+  },
+  get_machine: {
+    method: "GET",
+    request: (input) => ({ path: `/api/machines/${encodeURIComponent(String(input.name ?? ""))}` }),
+    unwrap: (body) => property(body, "machine")
+  },
+  update_machine: {
+    method: "PATCH",
+    request: (input) => ({
+      path: `/api/machines/${encodeURIComponent(String(input.name ?? ""))}`,
+      body: without(input, "name")
+    }),
+    unwrap: (body) => property(body, "machine")
+  },
+  list_accounts: {
+    method: "GET",
+    request: () => ({ path: "/api/accounts" }),
+    unwrap: (body) => body
+  },
+  get_account: {
+    method: "GET",
+    request: (input) => ({ path: `/api/accounts/${encodeURIComponent(String(input.id ?? ""))}` }),
+    unwrap: (body) => property(body, "account")
+  },
+  update_account: {
+    method: "PATCH",
+    request: (input) => ({
+      path: `/api/accounts/${encodeURIComponent(String(input.id ?? ""))}`,
+      body: without(input, "id")
+    }),
+    unwrap: (body) => property(body, "account")
+  }
+});
+
+// src/lib/cli/bindings/http-routes-ownership.ts
+function property2(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+function queryString2(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0) continue;
+    params.set(key, value === null ? "" : String(value));
+  }
+  const query = params.toString();
+  return query.length === 0 ? "" : `?${query}`;
+}
+var OWNERSHIP_HTTP_ROUTES = Object.freeze({
+  claim: {
+    method: "POST",
+    request: (input) => ({ path: "/api/claims", body: input }),
+    unwrap: (body) => property2(body, "assignment")
+  },
+  release: {
+    method: "POST",
+    request: (input) => ({ path: "/api/claims/release", body: input }),
+    unwrap: (body) => property2(body, "assignment")
+  },
+  heartbeat: {
+    method: "POST",
+    request: (input) => ({ path: "/api/claims/heartbeat", body: input }),
+    unwrap: (body) => property2(body, "assignment")
+  },
+  // Reclamation (MILESTONES.md #99). Both return their operation's result
+  // object whole rather than under a key — `takeover`'s result is not just an
+  // assignment (it carries how alive the holder was judged, whether the
+  // warning had to be forced, and what has NOT been enforced), and `sweep`'s
+  // is a report with four lists in it. Unwrapping either to one field would
+  // discard the part the caller most needs to read.
+  takeover: {
+    method: "POST",
+    request: (input) => ({ path: "/api/claims/takeover", body: input }),
+    unwrap: (body) => body
+  },
+  sweep: {
+    method: "POST",
+    request: (input) => ({ path: "/api/sweep", body: input }),
+    unwrap: (body) => body
+  },
+  checkpoint: {
+    method: "POST",
+    request: (input) => ({ path: "/api/checkpoints", body: input }),
+    unwrap: (body) => property2(body, "event")
+  },
+  note: {
+    method: "POST",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return { path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/notes`, body: rest };
+    },
+    unwrap: (body) => property2(body, "event")
+  },
+  orientation: {
+    method: "GET",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return {
+        path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/orientation${queryString2(rest)}`
+      };
+    },
+    unwrap: (body) => body
+  },
+  my_work: {
+    method: "GET",
+    request: (input) => ({ path: `/api/my-work${queryString2(input)}` }),
+    unwrap: (body) => body
+  },
+  progress_report: {
+    method: "GET",
+    request: (input) => ({ path: `/api/progress-report${queryString2(input)}` }),
+    unwrap: (body) => body
+  },
+  get_crew_name: {
+    method: "POST",
+    request: (input) => ({ path: "/api/crew/name", body: input }),
+    unwrap: (body) => property2(body, "name")
+  }
+});
+
+// src/lib/cli/bindings/http-routes-backfill.ts
+var BACKFILL_HTTP_ROUTES = Object.freeze({
+  backfill: {
+    method: "POST",
+    // The whole input is the body. `POST /api/backfill` takes the same
+    // `{ payload }` wrapper the operation's own schema does, so there is
+    // nothing to move into a path or a query string — and a payload of this
+    // size could not go in one anyway.
+    request: (input) => ({ path: "/api/backfill", body: input }),
+    // The route returns the operation's result unwrapped (no envelope key),
+    // so there is nothing to unwrap here.
+    unwrap: (body) => body
+  }
+});
+
+// src/lib/cli/bindings/http-routes-artifacts.ts
+function property3(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+var ARTIFACT_HTTP_ROUTES = Object.freeze({
+  record_artifact: {
+    method: "POST",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return {
+        path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/artifacts`,
+        body: rest
+      };
+    },
+    unwrap: (body) => property3(body, "artifact")
+  },
+  request_review: {
+    method: "POST",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return {
+        path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/review-requests`,
+        body: rest
+      };
+    },
+    unwrap: (body) => property3(body, "event")
+  }
+});
+
+// src/lib/cli/bindings/http-routes-loops.ts
+function property4(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+function queryString3(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const query = params.toString();
+  return query.length === 0 ? "" : `?${query}`;
+}
+function loopPath(itemId, loopId) {
+  return `/api/items/${encodeURIComponent(String(itemId ?? ""))}/loops/${encodeURIComponent(String(loopId ?? ""))}`;
+}
+var LOOP_HTTP_ROUTES = Object.freeze({
+  loop_add: {
+    method: "POST",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return { path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/loops`, body: rest };
+    },
+    // The whole body, not one property: `loop_add` returns `{loopId, event}`
+    // and the `loopId` is the half the caller cannot do without — it is
+    // generated server-side, and a loop whose id the caller never learns can
+    // never be closed. Unwrapping to `event` would throw it away.
+    unwrap: (body) => body
+  },
+  loop_close: {
+    method: "POST",
+    request: (input) => {
+      const { itemId, loopId, ...rest } = input;
+      return { path: `${loopPath(itemId, loopId)}/close`, body: rest };
+    },
+    unwrap: (body) => property4(body, "event")
+  },
+  // The list read. Everything but the item id travels in the query string,
+  // as it does for every other list-shaped read here, and the result object
+  // comes back unwrapped so `http` and `direct` return the same shape.
+  loop_list: {
+    method: "GET",
+    request: (input) => {
+      const { itemId, ...rest } = input;
+      return {
+        path: `/api/items/${encodeURIComponent(String(itemId ?? ""))}/loops${queryString3(rest)}`
+      };
+    },
+    unwrap: (body) => body
+  },
+  loop_get: {
+    method: "GET",
+    request: (input) => ({ path: loopPath(input.itemId, input.loopId) }),
+    unwrap: (body) => body
+  },
+  // The whole body, not just the event: `previousText` cannot be recovered
+  // from any later read, because the loop now reports its new wording.
+  loop_edit: {
+    method: "PATCH",
+    request: (input) => {
+      const { itemId, loopId, ...rest } = input;
+      return { path: loopPath(itemId, loopId), body: rest };
+    },
+    unwrap: (body) => body
+  },
+  loop_delete: {
+    method: "DELETE",
+    request: (input) => {
+      const { itemId, loopId, ...rest } = input;
+      return { path: loopPath(itemId, loopId), body: rest };
+    },
+    unwrap: (body) => body
+  }
+});
+
+// src/lib/cli/bindings/http-routes-sessions.ts
+function property5(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+var SESSION_HTTP_ROUTES = Object.freeze({
+  register_session: {
+    method: "POST",
+    /**
+     * The session id goes in the path and everything else in the body,
+     * matching the endpoint's shape. It is *not* also sent in the body: the
+     * route puts the path's id last when it composes the operation input, so
+     * a body copy would be overwritten by the identical value — dead weight
+     * that a reader would have to check was in fact identical.
+     */
+    request: (input) => {
+      const { sessionId, ...rest } = input;
+      return {
+        path: `/api/sessions/${encodeURIComponent(String(sessionId ?? ""))}/register`,
+        body: rest
+      };
+    },
+    unwrap: (body) => property5(body, "registration")
+  }
+});
+
+// src/lib/session-transport-header.ts
+var CLI_TRANSPORT_HEADER = "X-Standup-Transport";
+var SESSION_HEADER = "X-Standup-Session";
+var ACTOR_HEADER = "X-Standup-Actor";
+var CLI_TRANSPORTS = Object.freeze(["cli-http"]);
+
+// src/lib/request-id-header.ts
+var REQUEST_ID_HEADER = "X-Request-Id";
+
+// src/lib/cli/bindings/http.ts
+function asRecord(input) {
+  return typeof input === "object" && input !== null ? input : {};
+}
+function property6(body, key) {
+  return typeof body === "object" && body !== null ? body[key] : void 0;
+}
+function queryString4(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0) continue;
+    params.set(key, value === null ? "" : String(value));
+  }
+  const query = params.toString();
+  return query.length === 0 ? "" : `?${query}`;
+}
+var HTTP_ROUTES = Object.freeze({
+  create_item: {
+    method: "POST",
+    request: (input) => ({ path: "/api/items", body: input }),
+    unwrap: (body) => property6(body, "item")
+  },
+  // The three explicit creates. Each posts to its own collection, so which
+  // kind is being made is visible in the request rather than inferred from
+  // the body — the same property the operations exist to give a caller.
+  create_project: {
+    method: "POST",
+    request: (input) => ({ path: "/api/projects", body: input }),
+    unwrap: (body) => property6(body, "item")
+  },
+  create_task: {
+    method: "POST",
+    request: (input) => ({ path: "/api/tasks", body: input }),
+    unwrap: (body) => property6(body, "item")
+  },
+  create_subtask: {
+    method: "POST",
+    request: (input) => ({ path: "/api/subtasks", body: input }),
+    unwrap: (body) => property6(body, "item")
+  },
+  get_item: {
+    method: "GET",
+    // `id` goes in the path; every other input — `full` (MILESTONES.md
+    // #107) — goes in the query string. Without this the two
+    // bindings would disagree about what `--full` does: `direct` would
+    // return the whole record and `http` the slim shape, from one command
+    // line. Row #85's one-interface test compares exactly that.
+    request: (input) => {
+      const { id, ...rest } = input;
+      return {
+        path: `/api/items/${encodeURIComponent(String(id ?? ""))}${queryString4(rest)}`
+      };
+    },
+    unwrap: (body) => property6(body, "item")
+  },
+  update_item: {
+    method: "PATCH",
+    request: (input) => {
+      const { id, ...rest } = input;
+      return { path: `/api/items/${encodeURIComponent(String(id ?? ""))}`, body: rest };
+    },
+    unwrap: (body) => property6(body, "item")
+  },
+  list_items: {
+    method: "GET",
+    request: (input) => ({ path: `/api/items${queryString4(input)}` }),
+    unwrap: (body) => body
+  },
+  // Stale candidates. `GET /api/stale-candidates` returns the result object
+  // unwrapped, like every other list-shaped read, so `unwrap` is the
+  // identity — the same shape `direct` returns for the same call.
+  get_stale_candidates: {
+    method: "GET",
+    request: (input) => ({ path: `/api/stale-candidates${queryString4(input)}` }),
+    unwrap: (body) => body
+  },
+  // Row #105. `GET /search` returns the result object unwrapped, like every
+  // other list-shaped read, so `unwrap` is the identity — the same shape
+  // `direct` returns for the same call.
+  search: {
+    method: "GET",
+    request: (input) => ({ path: `/api/search${queryString4(input)}` }),
+    unwrap: (body) => body
+  },
+  // Row #83 — `standup config`. `src/app/api/settings/**` returns every
+  // settings operation's result unwrapped already (SCHEMA.md §19), so
+  // `unwrap` is the identity for all four — the same shape `direct` returns.
+  get_settings: {
+    method: "GET",
+    request: () => ({ path: "/api/settings" }),
+    unwrap: (body) => body
+  },
+  get_setting: {
+    method: "GET",
+    request: (input) => ({
+      path: `/api/settings/${encodeURIComponent(String(input.key ?? ""))}`
+    }),
+    unwrap: (body) => body
+  },
+  put_setting: {
+    method: "PUT",
+    request: (input) => {
+      const { key, ...rest } = input;
+      return { path: `/api/settings/${encodeURIComponent(String(key ?? ""))}`, body: rest };
+    },
+    unwrap: (body) => body
+  },
+  delete_setting: {
+    method: "DELETE",
+    request: (input) => ({
+      path: `/api/settings/${encodeURIComponent(String(input.key ?? ""))}`
+    }),
+    unwrap: (body) => body
+  },
+  transition_item: {
+    method: "POST",
+    request: (input) => {
+      const { id, dryRun, ...rest } = input;
+      const query = dryRun === true ? "?dry_run=true" : "";
+      return {
+        path: `/api/items/${encodeURIComponent(String(id ?? ""))}/transition${query}`,
+        body: rest
+      };
+    },
+    // The route answers `{ item, outcome }` for a real move and `{ outcome }`
+    // alone for a rehearsal (`transition/route.ts`'s `RehearsalRollback`
+    // unwrapping) — the same two shapes the `direct` binding's own
+    // rehearsal handling produces. Returning the body unchanged, rather
+    // than pulling one key out the way the single-item routes above do, is
+    // what keeps those two shapes identical between bindings.
+    unwrap: (body) => body
+  },
+  complete_item: {
+    method: "POST",
+    request: (input) => {
+      const { id, ...rest } = input;
+      return { path: `/api/items/${encodeURIComponent(String(id ?? ""))}/complete`, body: rest };
+    },
+    unwrap: (body) => property6(body, "item")
+  },
+  // MILESTONES.md #92 — repo/area/machine/account routes, kept in their own
+  // module (./http-routes-admin.ts) and spread in as a single line, per
+  // that module's own header, so concurrent CLI rows adding entries above
+  // never conflict with this one.
+  ...ADMIN_HTTP_ROUTES,
+  ...OWNERSHIP_HTTP_ROUTES,
+  ...BACKFILL_HTTP_ROUTES,
+  ...ARTIFACT_HTTP_ROUTES,
+  // row #98 — artifact writes
+  ...LOOP_HTTP_ROUTES,
+  // row #100 - open-loop writes
+  ...SESSION_HTTP_ROUTES
+  // row #43 — the registration handshake
+});
+function isServiceErrorCode(value) {
+  return typeof value === "string" && SERVICE_ERROR_CODES.includes(value);
+}
+function rejectionFromBody(body, status) {
+  const error = property6(body, "error");
+  const code = property6(error, "code");
+  const message = property6(error, "message");
+  const fields = property6(error, "fields");
+  const guard = property6(error, "guard");
+  if (!isServiceErrorCode(code)) {
+    return {
+      rejection: { code: "internal", fields: [] },
+      message: `The server answered ${status} with a body this build does not recognise.`
+    };
+  }
+  return {
+    rejection: {
+      code,
+      fields: Array.isArray(fields) ? fields.map(String) : [],
+      ...typeof guard === "string" ? { guard } : {}
+    },
+    message: typeof message === "string" ? message : `The server refused with ${code}.`
+  };
+}
+function createHttpBinding({
+  baseUrl: baseUrl2,
+  fetch: fetchImpl,
+  sessionId,
+  actor,
+  token
+}) {
+  const root = baseUrl2.replace(/\/+$/, "");
+  const doFetch = fetchImpl ?? ((url, init) => globalThis.fetch(url, init));
+  return {
+    name: "http",
+    async invoke(operation, input) {
+      const route = HTTP_ROUTES[operation];
+      if (!route) {
+        return bindingRejected(
+          { code: "not_implemented", fields: ["operation"] },
+          `The server does not expose ${operation} over HTTP.`
+        );
+      }
+      const { path, body } = route.request(asRecord(input));
+      const headers = { Accept: "application/json" };
+      if (body !== void 0) headers["Content-Type"] = "application/json";
+      if (sessionId !== void 0) headers[SESSION_HEADER] = sessionId;
+      if (actor !== void 0) headers[ACTOR_HEADER] = actor;
+      if (token !== void 0) headers.Authorization = `Bearer ${token}`;
+      headers[CLI_TRANSPORT_HEADER] = "cli-http";
+      const requestId = newRequestId();
+      headers[REQUEST_ID_HEADER] = requestId;
+      let response;
+      try {
+        response = await doFetch(`${root}${path}`, {
+          method: route.method,
+          headers,
+          ...body === void 0 ? {} : { body: JSON.stringify(body) }
+        });
+      } catch (cause) {
+        log.error("Could not reach the server.", {
+          requestId,
+          transport: "cli",
+          binding: "http",
+          operation,
+          method: route.method,
+          // The path, not the base URL: the path is this build's own route
+          // table and says which call failed, while the base URL is the
+          // configured address §20 keeps out of a rendered message. In a
+          // log it would be defensible; it is left out because the log line
+          // does not need it to be useful and the rule is easier to keep
+          // than to qualify.
+          path,
+          err: cause
+        });
+        return bindingRejected(
+          { code: "internal", fields: [] },
+          `Could not reach the server (${cause instanceof Error ? cause.name : "unknown error"}). Check the configured address.`
+        );
+      }
+      let parsed;
+      try {
+        parsed = await response.json();
+      } catch {
+        parsed = void 0;
+      }
+      if (!response.ok) {
+        const { rejection, message } = rejectionFromBody(parsed, response.status);
+        if (faultContext(rejection.code).fault === "server") {
+          log.error("The server failed or answered unrecognisably.", {
+            requestId,
+            transport: "cli",
+            binding: "http",
+            operation,
+            status: response.status,
+            ...faultContext(rejection.code)
+          });
+        } else {
+          log.debug("The server refused the command.", {
+            requestId,
+            transport: "cli",
+            binding: "http",
+            operation,
+            status: response.status,
+            code: rejection.code,
+            ...faultContext(rejection.code),
+            ...rejection.guard === void 0 ? {} : { guard: rejection.guard }
+          });
+        }
+        return bindingRejected(rejection, message);
+      }
+      return bindingOk(route.unwrap(parsed));
+    }
+  };
+}
+
+// src/lib/cli/doctor.ts
+function doctorReport(inputs = {}) {
+  const configuration = describeResolution(inputs);
+  const resolution = resolveConfig(inputs);
+  const byName = new Map(configuration.map((note) => [note.name, note]));
+  const serverConfigured = byName.get("STANDUP_URL")?.present === true;
+  const databaseConfigured = byName.get("DATABASE_URL")?.present === true;
+  const capabilities = [
+    {
+      name: "server",
+      status: serverConfigured ? "available" : "unavailable",
+      detail: serverConfigured ? "A server address is configured; commands can call the API." : "No server address configured. The front end and the long-poll need one."
+    },
+    {
+      name: "database",
+      status: databaseConfigured ? "available" : "unavailable",
+      detail: databaseConfigured ? "A database is configured; commands can run the service layer in this process." : "No database configured. --direct and `standup init` need one."
+    },
+    {
+      // #84's own check, as this file's other comment named it: `standup
+      // mcp` is `--direct`-only (`./mcp.ts`), so it is available under
+      // exactly the same condition as the `database` capability above — a
+      // separate entry rather than folding it into that one because a
+      // person asking "what can this installation do" reads MCP over stdio
+      // as its own capability, not as a detail of the database's.
+      name: "mcp_stdio",
+      status: databaseConfigured ? "available" : "unavailable",
+      detail: databaseConfigured ? "A database is configured; `standup mcp` can serve MCP over stdio." : "No database configured. `standup mcp` needs one, the same as --direct."
+    }
+  ];
+  if (resolution.ok) {
+    return {
+      configured: true,
+      binding: resolution.config.binding,
+      configuration,
+      problems: [],
+      capabilities
+    };
+  }
+  return {
+    configured: false,
+    configuration,
+    problems: [resolution.envelope.error.message],
+    capabilities
+  };
+}
+
+// src/lib/cli/config-file.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var FILE_KEYS = ["standupUrl", "databaseUrl", "sessionId", "actor"];
+function configFilePath(env = process.env) {
+  const override = env.STANDUP_CONFIG_FILE;
+  if (override !== void 0 && override.trim() !== "") return override;
+  const xdg = env.XDG_CONFIG_HOME;
+  const home = env.HOME ?? env.USERPROFILE ?? homedir();
+  const base = xdg !== void 0 && xdg.trim() !== "" ? xdg : join(home, ".config");
+  return join(base, "agent-standup", "config.json");
+}
+function sanitize(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const record = value;
+  const result = {};
+  for (const key of FILE_KEYS) {
+    const raw = record[key];
+    if (typeof raw === "string" && raw.trim() !== "") result[key] = raw;
+  }
+  return result;
+}
+function readConfigFile(path = configFilePath()) {
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    return sanitize(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+function writeConfigFile(patch, path = configFilePath()) {
+  const merged = { ...readConfigFile(path), ...patch };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(merged, null, 2)}
+`, { mode: 384 });
+  return merged;
+}
+
+// src/lib/cli/init/resolve.ts
+var DEFAULT_DATABASE_NAME = "standup";
+var DEFAULT_APP_ROLE = "standup_app";
+function resolveInitSource({
+  flags = {},
+  env = {},
+  file: file2 = {}
+} = {}) {
+  const databaseUrl = firstDefined(flags.databaseUrl, env.DATABASE_URL, file2.databaseUrl);
+  if (databaseUrl !== void 0) {
+    return { kind: "accept", databaseUrl };
+  }
+  const databaseName = firstDefined(flags.databaseName, env.STANDUP_DB_NAME) ?? DEFAULT_DATABASE_NAME;
+  const appRole = firstDefined(flags.appRole, env.STANDUP_APP_ROLE) ?? DEFAULT_APP_ROLE;
+  const appPassword = firstDefined(flags.appPassword, env.STANDUP_APP_PASSWORD);
+  const provisionUrl = firstDefined(flags.provisionUrl, env.STANDUP_PROVISION_URL);
+  if (provisionUrl !== void 0) {
+    return {
+      kind: "provision",
+      provisionUrl,
+      databaseName,
+      appRole,
+      ...appPassword === void 0 ? {} : { appPassword }
+    };
+  }
+  return {
+    kind: "auto",
+    databaseName,
+    appRole,
+    ...appPassword === void 0 ? {} : { appPassword }
+  };
+}
+
+// src/lib/cli/init/index.ts
+async function defaultRunInitSequence(options) {
+  const mod = await import("../run-init-VVQPJOTB.js");
+  return mod.runInitSequence(options);
+}
+function readInitFlags(flags) {
+  const names = [
+    "database-url",
+    "provision-url",
+    "database-name",
+    "app-role",
+    "app-password"
+  ];
+  const values = {};
+  for (const name of names) {
+    const result = stringFlag(flags, name);
+    if (!result.ok) return { ok: false, envelope: result.envelope };
+    if (result.value !== void 0) values[name] = result.value;
+  }
+  return {
+    ok: true,
+    value: {
+      ...values["database-url"] === void 0 ? {} : { databaseUrl: values["database-url"] },
+      ...values["provision-url"] === void 0 ? {} : { provisionUrl: values["provision-url"] },
+      ...values["database-name"] === void 0 ? {} : { databaseName: values["database-name"] },
+      ...values["app-role"] === void 0 ? {} : { appRole: values["app-role"] },
+      ...values["app-password"] === void 0 ? {} : { appPassword: values["app-password"] }
+    }
+  };
+}
+async function runInitCommand({
+  flags,
+  env = {},
+  file: file2 = {},
+  cwd,
+  deps = {}
+}) {
+  const parsedFlags = readInitFlags(flags);
+  if (!parsedFlags.ok) {
+    return { envelope: parsedFlags.envelope, exitCode: EXIT.MALFORMED };
+  }
+  const source = resolveInitSource({ flags: parsedFlags.value, env, file: file2 });
+  const runInitSequence = deps.runInitSequence ?? defaultRunInitSequence;
+  const write = deps.writeConfigFile ?? writeConfigFile;
+  const path = deps.configPath ?? configFilePath(env);
+  const result = await runInitSequence({ source, cwd, env });
+  if (!result.ok) {
+    return {
+      envelope: malformed(`standup init could not finish: ${result.message}`, [result.stage]),
+      exitCode: EXIT.UNCONFIGURED
+    };
+  }
+  write({ databaseUrl: result.databaseUrl }, path);
+  return {
+    envelope: ok({
+      source: result.source,
+      database: result.database,
+      ...result.appRole === void 0 ? {} : { appRole: result.appRole },
+      steps: result.steps,
+      configWritten: true,
+      configPath: path
+    }),
+    exitCode: EXIT.OK
+  };
+}
+
+// src/lib/mcp/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/lib/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/lib/adapters/registry.ts
+function defineAdapter(descriptor) {
+  return Object.freeze(descriptor);
+}
+var ADAPTER_REGISTRY = {
+  http: defineAdapter({
+    name: "http",
+    summary: "The web API \u2014 the JSON surface routes under src/app/api mount.",
+    transport: "network"
+  }),
+  mcp_http: defineAdapter({
+    name: "mcp_http",
+    summary: "The MCP server, reached over streamable HTTP.",
+    transport: "network"
+  }),
+  mcp_stdio: defineAdapter({
+    name: "mcp_stdio",
+    summary: "The MCP server, reached over stdio.",
+    transport: "embedded"
+  }),
+  cli: defineAdapter({
+    name: "cli",
+    summary: "The standup command line, on either of its two bindings.",
+    transport: "embedded"
+  })
+};
+var ADAPTER_NAMES = Object.freeze(
+  Object.keys(ADAPTER_REGISTRY).sort()
+);
+
+// src/lib/adapters/waivers.ts
+var ADAPTER_WAIVERS = Object.freeze([
+  {
+    adapter: "mcp_http",
+    operation: "backfill",
+    reason: "An MCP tool list is sent to the model on every session, so every tool costs context permanently. Backfill is a one-shot bulk load that is disabled during normal operation; paying a per-session cost for a surface open for minutes is the wrong trade. It carries no guard rejection, so \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "backfill",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_crew_name",
+    reason: "Naming is assigned server-side as a side effect of register_session and claim (ensureNameForSession, @/lib/agent-names) \u2014 an agent never needs to call this separately, so it has no business sitting in a tool list with a required sessionId field the other agent-facing tools' schemas do not explain. It carries no guard rejection (handOutName's only failure mode is an exhausted pool, mapped to a plain conflict), so \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line for the rare caller that wants a name with no other side effect."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_crew_name",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "readiness",
+    reason: "Readiness answers a question infrastructure asks \u2014 a deployment gate, a compose condition, a load balancer \u2014 and its consumers reach it as an unauthenticated HTTP probe, which is the one shape an MCP tool cannot be. An agent has no use for it: a session is already talking to a server that answered, so the question is settled by the time any tool could ask it. It carries no guard rejection \u2014 it runs one query and reports counts \u2014 so \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "readiness",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "hook_decision",
+    reason: "Hook and scheduler infrastructure. Its callers are the hook client and the launcher, which reach the service over its own HTTP routes, not through MCP; an agent session has no use for it and cannot act on what it returns. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "hook_decision",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "kill_guard",
+    reason: "Hook and scheduler infrastructure. Its callers are the hook client and the launcher, which reach the service over its own HTTP routes, not through MCP; an agent session has no use for it and cannot act on what it returns. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "kill_guard",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "record_tool_calls",
+    reason: "Hook and scheduler infrastructure. Its callers are the hook client and the launcher, which reach the service over its own HTTP routes, not through MCP; an agent session has no use for it and cannot act on what it returns. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "record_tool_calls",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_session_detail",
+    reason: "Hook and scheduler infrastructure. Its callers are the hook client and the launcher, which reach the service over its own HTTP routes, not through MCP; an agent session has no use for it and cannot act on what it returns. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_session_detail",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_fleet",
+    reason: "Hook and scheduler infrastructure. Its callers are the hook client and the launcher, which reach the service over its own HTTP routes, not through MCP; an agent session has no use for it and cannot act on what it returns. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_fleet",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_area",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_area",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "delete_area",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "delete_area",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_area",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_area",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "list_areas",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "list_areas",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "update_area",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "update_area",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "merge_areas",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "merge_areas",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_repo",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_repo",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "delete_repo",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "delete_repo",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_repo",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_repo",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "list_repos",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "list_repos",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "update_repo",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "update_repo",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_account",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_account",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "list_accounts",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "list_accounts",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "update_account",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "update_account",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_machine",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_machine",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "list_machines",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "list_machines",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "update_machine",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "update_machine",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "delete_person",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "delete_person",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "list_people",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "list_people",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "update_person",
+    reason: "Reference-entity administration - a person curates the areas, repos, accounts, machines and people a board refers to, through the web interface or the command line, and an agent consumes the result by name rather than maintaining the table. Twenty of these spend context on every session to serve an administrative task no agent performs. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "update_person",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_setting",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_setting",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_settings",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_settings",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "put_setting",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "put_setting",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "patch_settings",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "patch_settings",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "delete_setting",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "delete_setting",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "remove_unrecognised_setting",
+    reason: "Settings administration. A setting is a deployment-wide policy decision a person makes \u2014 what the guards require, what the caps are \u2014 and an agent that could rewrite one could turn off the checks it is subject to. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "remove_unrecognised_setting",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "retype_to_task",
+    reason: "Structural repair \u2014 rare, person-driven surgery on a board that has gone wrong, performed deliberately by someone who has looked at it rather than reached for mid-task by an agent. It runs no state transition through the guarded path, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "retype_to_task",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "restore_item",
+    reason: "Structural repair \u2014 rare, person-driven surgery on a board that has gone wrong, performed deliberately by someone who has looked at it rather than reached for mid-task by an agent. It runs no state transition through the guarded path, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "restore_item",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "delete_item",
+    reason: "Structural repair \u2014 rare, person-driven surgery on a board that has gone wrong, performed deliberately by someone who has looked at it rather than reached for mid-task by an agent. It runs no state transition through the guarded path, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "delete_item",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "record_intervention",
+    reason: "Scoring and telemetry with no agent consumer \u2014 these feed dashboards and the intervention scoring loop, both read by people. An agent neither records nor reads them in the course of doing work. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "record_intervention",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_costs",
+    reason: "Scoring and telemetry with no agent consumer \u2014 these feed dashboards and the intervention scoring loop, both read by people. An agent neither records nor reads them in the course of doing work. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_costs",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_activity",
+    reason: "Scoring and telemetry with no agent consumer \u2014 these feed dashboards and the intervention scoring loop, both read by people. An agent neither records nor reads them in the course of doing work. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_activity",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_needs_you",
+    reason: "A user-interface read (\xA722 names 'the board is a user-interface read' as the archetypal waiver). This one backs a specific screen \u2014 the needs-you inbox, the Activity tab's paging, the unread marker \u2014 and its shape is chosen for that screen rather than for a session. An agent asks about its own work with get_item, my_work and progress_report. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_needs_you",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "get_item_history",
+    reason: "A user-interface read (\xA722 names 'the board is a user-interface read' as the archetypal waiver). This one backs a specific screen \u2014 the needs-you inbox, the Activity tab's paging, the unread marker \u2014 and its shape is chosen for that screen rather than for a session. An agent asks about its own work with get_item, my_work and progress_report. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "get_item_history",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "mark_event_seen",
+    reason: "A user-interface read (\xA722 names 'the board is a user-interface read' as the archetypal waiver). This one backs a specific screen \u2014 the needs-you inbox, the Activity tab's paging, the unread marker \u2014 and its shape is chosen for that screen rather than for a session. An agent asks about its own work with get_item, my_work and progress_report. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "mark_event_seen",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_item",
+    reason: "Deprecated in favour of the purpose-built creation tools, which state their required fields in their own schemas rather than behind a conditional refinement. Keeping a superseded tool in a list sent on every session spends context to offer agents the worse of two ways to do the same thing. It remains on HTTP and the command line for callers already written against it."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_item",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, same reasoning."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_add",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_add",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_get",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_get",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_list",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_list",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_edit",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_edit",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_close",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_close",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "loop_delete",
+    reason: "Folded into the single `loop` tool, which takes the verb as an `action` field. Six verbs describing one capability spend the per-session tool-list budget six times over to say `itemId` and `loopId` again; a caller reaching for any of them has already decided it is working on loops. The folded tool dispatches to this operation, so its refusals, its guard ids and its fields reach the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "loop_delete",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_project",
+    reason: "Folded into the single `create_work` tool, which takes the kind as a required `type` field. The three share seventeen fields of one common shape and differ by a single parent pointer, so three near-identical schemas spend the per-session tool-list budget three times to describe one decision. This is not `create_item`'s inference returning: `type` is stated by the caller and never derived, and a type the supplied parent cannot produce is refused by name. The folded tool dispatches to this operation, so every depth check and every refusal here reaches the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_project",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_task",
+    reason: "Folded into the single `create_work` tool, which takes the kind as a required `type` field. The three share seventeen fields of one common shape and differ by a single parent pointer, so three near-identical schemas spend the per-session tool-list budget three times to describe one decision. This is not `create_item`'s inference returning: `type` is stated by the caller and never derived, and a type the supplied parent cannot produce is refused by name. The folded tool dispatches to this operation, so every depth check and every refusal here reaches the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_task",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "create_subtask",
+    reason: "Folded into the single `create_work` tool, which takes the kind as a required `type` field. The three share seventeen fields of one common shape and differ by a single parent pointer, so three near-identical schemas spend the per-session tool-list budget three times to describe one decision. This is not `create_item`'s inference returning: `type` is stated by the caller and never derived, and a type the supplied parent cannot produce is refused by name. The folded tool dispatches to this operation, so every depth check and every refusal here reaches the caller unchanged, and it stays exposed on HTTP and the command line. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "create_subtask",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "progress_report",
+    reason: "A fixed rendering of rows `my_work` already returns for the same input, and a rendering is the one thing a caller can reproduce for itself from data it holds. Every tool costs the per-session tool-list budget whether or not it is called, and this one buys a report shape rather than a capability: no state is reachable through it that is not reachable through `my_work`. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP or the command line, which is where a scheduled report is generated from anyway."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "progress_report",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "poll",
+    reason: "Its caller is a long-poll loop, not a reasoning agent: it blocks until work appears or a timeout elapses, which is a shape a session cannot use \u2014 an agent holding a turn open waiting for a change is an agent doing nothing with a context window. The same class as the hook and scheduler operations already waived here, and for the same reason: the consumer is a process that reaches the service over its own HTTP route. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach it over HTTP."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "poll",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  },
+  {
+    adapter: "mcp_http",
+    operation: "service_info",
+    reason: "Most of what it returns is a catalogue of every operation, which every MCP client is already sent on connect \u2014 so on this surface, and only on this surface, the bulk of the answer is a duplicate of something the caller already holds. What it carried that nothing else did \u2014 the build, the limits and the settings revision \u2014 now lives on `describe_tool`, which is authenticated and is the one remaining MCP read whose subject is the contract rather than the data; call it with no `tool` to get them. That home landed before this waiver, deliberately, so the information was never unreachable in between. It runs no state transition, so no registered guard can reject it and \xA722's bound on waivers is satisfied. Reach the catalogue itself over the command line."
+  },
+  {
+    adapter: "mcp_stdio",
+    operation: "service_info",
+    reason: "Same as mcp_http \u2014 one MCP surface, two transports, and the per-session tool-list cost is identical on both."
+  }
+]);
+function isWaived(adapter, operation) {
+  return ADAPTER_WAIVERS.some(
+    (waiver) => waiver.adapter === adapter && waiver.operation === operation
+  );
+}
+function waiverFor(adapter, operation) {
+  return ADAPTER_WAIVERS.find(
+    (waiver) => waiver.adapter === adapter && waiver.operation === operation
+  );
+}
+function exposedOperations(adapter, operations) {
+  return operations.filter((operation) => !isWaived(adapter, operation.name));
+}
+
+// src/lib/mcp/result.ts
+function bigintSafe(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Date) return value;
+  if (Array.isArray(value)) return value.map(bigintSafe);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, bigintSafe(entry)])
+    );
+  }
+  return value;
+}
+function toolSuccess(value) {
+  const safe = bigintSafe(value);
+  const text = safe === void 0 ? "null" : JSON.stringify(safe);
+  const structuredContent = isPlainRecord(safe) ? safe : { result: safe ?? null };
+  return {
+    content: [{ type: "text", text }],
+    structuredContent
+  };
+}
+function toolRejection(error) {
+  const serviceError = toServiceError(error);
+  const rejection = {
+    ...serviceError.toRejection(),
+    message: serviceError.message
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(rejection) }],
+    structuredContent: { ...rejection, fields: [...rejection.fields] },
+    isError: true
+  };
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/mcp/tools.ts
+function advertisedSchema(schema) {
+  const permissive = schema.catch((ctx) => ctx.input);
+  const shape = shapeOf(schema);
+  if (shape !== void 0) {
+    Object.defineProperty(permissive, "shape", {
+      get: () => shape,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  return permissive;
+}
+function shapeOf(schema) {
+  const direct = schema.shape;
+  if (direct !== void 0) return direct;
+  const inner = schema._def?.schema;
+  return inner ? shapeOf(inner) : void 0;
+}
+function toolsFromOperations(operations) {
+  return operations.map((operation) => ({
+    name: operation.name,
+    description: operation.summary,
+    inputSchema: operation.input,
+    readOnly: operation.kind === "read"
+  }));
+}
+
+// src/lib/mcp/server.ts
+var MCP_SERVER_INFO = { name: "agent-standup", version: "0.1.0" };
+function createMcpServer({
+  call,
+  transport,
+  adapter,
+  identity,
+  operations = exposedOperations(adapter, listOperations()),
+  serverInfo = MCP_SERVER_INFO
+}) {
+  const server = new McpServer({ name: serverInfo.name, version: serverInfo.version });
+  for (const tool of toolsFromOperations(operations)) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        // The operation's own schema, wrapped so the SDK advertises it but
+        // never rejects with it — see `advertisedSchema`'s comment. The
+        // rejection has to come from the service layer, or MCP's refusal
+        // of a bad input would not match the web API's for the same call.
+        inputSchema: advertisedSchema(tool.inputSchema),
+        annotations: { readOnlyHint: tool.readOnly }
+      },
+      async (args) => callTool(call, transport, tool.name, args, identity)
+    );
+  }
+  return server;
+}
+async function callTool(call, transport, name, args, identity = {}, adapter, served) {
+  const requestId = newRequestId();
+  if (adapter !== void 0) {
+    const withheld = served !== void 0 && served.has(name) ? void 0 : withheldToolRejection(adapter, name);
+    if (withheld !== void 0) {
+      log.debug("A withheld tool was called by name.", {
+        requestId,
+        transport,
+        tool: name,
+        code: "not_found"
+      });
+      return withheld;
+    }
+  }
+  try {
+    return toolSuccess(
+      await call(name, args, {
+        // Spread conditionally rather than assigned unconditionally: an
+        // explicit `sessionId: undefined` is a different value from an
+        // absent key to anything reading the object with `in` or
+        // `Object.keys`, and the whole point of an unidentified call is
+        // that it carries no claim about who made it.
+        caller: {
+          transport,
+          requestId,
+          ...identity.sessionId === void 0 ? {} : { sessionId: identity.sessionId },
+          ...identity.actor === void 0 ? {} : { actor: identity.actor },
+          ...identity.machine === void 0 ? {} : { machine: identity.machine }
+        }
+      })
+    );
+  } catch (error) {
+    const serviceError = toServiceError(error);
+    if (serviceError.fault === "server") {
+      log.error("MCP tool call failed unexpectedly.", {
+        requestId,
+        transport,
+        tool: name,
+        ...faultContext(serviceError),
+        err: serviceError
+      });
+    } else {
+      log.debug("MCP tool call refused.", {
+        requestId,
+        transport,
+        tool: name,
+        code: serviceError.code,
+        ...faultContext(serviceError),
+        ...serviceError.guard === void 0 ? {} : { guard: serviceError.guard }
+      });
+    }
+    return toolRejection(serviceError);
+  }
+}
+function withheldToolRejection(adapter, name) {
+  const waiver = waiverFor(adapter, name);
+  if (waiver === void 0) return void 0;
+  return toolRejection(
+    new NotFoundError(
+      `The tool ${name} is not served by this adapter. It was withheld deliberately, not dropped, and no arguments will make this call succeed \u2014 do not retry it. Why: ${waiver.reason}`,
+      // No `details`: `Rejection` — the shape every adapter rebuilds from a
+      // wire body — carries only what conformance compares, and widening it
+      // for one adapter would make two adapters disagree about an identical
+      // refusal. Everything a caller needs is in the message.
+      {}
+    )
+  );
+}
+
+// src/lib/mcp/stdio.ts
+var MCP_STDIO_TRANSPORT = "mcp-stdio";
+function serveMcpStdio(call, options = {}) {
+  const input = options.input ?? process.stdin;
+  const server = createMcpServer({ call, transport: MCP_STDIO_TRANSPORT, adapter: "mcp_stdio" });
+  const transport = new StdioServerTransport(input, options.output ?? process.stdout);
+  return new Promise((resolve, reject) => {
+    transport.onclose = () => resolve();
+    input.once("end", () => {
+      server.close().catch(reject);
+    });
+    server.connect(transport).catch(reject);
+  });
+}
+
+// src/lib/cli/mcp.ts
+async function runMcpStdio(options = {}) {
+  const resolution = resolveConfig({
+    flags: { direct: true },
+    env: options.env,
+    file: options.file
+  });
+  if (!resolution.ok) {
+    return { envelope: resolution.envelope, exitCode: resolution.exitCode };
+  }
+  const loadService = options.loadService ?? (async () => (await import("../live-R6WH7ER7.js")).service);
+  const service = await loadService();
+  await serveMcpStdio((name, input, callOptions) => service.call(name, input, callOptions), {
+    input: options.input,
+    output: options.output
+  });
+  return { envelope: ok({ transport: "mcp-stdio" }), exitCode: EXIT.OK };
+}
+
+// src/lib/cli/run.ts
+async function runCommand(argv, binding) {
+  const parsed = parseArgs(argv);
+  if (!parsed.ok) return refuse(parsed.envelope);
+  const found = lookupCommand(parsed.parsed.words);
+  if (!found.ok) return refuse(found.envelope);
+  const built = found.match.command.buildInput(found.match.rest, parsed.parsed.flags);
+  if (!built.ok) return refuse(built.envelope);
+  const result = await binding.invoke(found.match.command.operation, built.input);
+  if (result.ok) {
+    const envelope2 = ok(result.data);
+    return { envelope: envelope2, exitCode: exitCodeFor(envelope2), binding: binding.name };
+  }
+  const envelope = rejected(result.rejection, result.message);
+  return { envelope, exitCode: exitCodeFor(envelope), binding: binding.name };
+}
+function refuse(envelope) {
+  return { envelope, exitCode: exitCodeFor(envelope) };
+}
+async function runCliHook(rest, options) {
+  const verb = rest[0];
+  if (!isHookVerb(verb)) {
+    return refuse(
+      malformed(
+        `standup hook needs one of: ${HOOK_VERBS.join(", ")}${verb === void 0 ? "" : ` (got "${verb}")`}`,
+        ["verb"]
+      )
+    );
+  }
+  const edges = options.hook;
+  if (edges === void 0) {
+    return refuse(malformed("standup hook is not available on this entry point", ["hook"]));
+  }
+  const outcome = await runHookCommand({
+    verb,
+    spool: edges.spool,
+    now: edges.now,
+    ...edges.stdin === void 0 ? {} : { stdin: edges.stdin },
+    ...edges.hook === void 0 ? {} : { hook: edges.hook },
+    ...edges.send === void 0 ? {} : { send: edges.send },
+    ...edges.batchSize === void 0 ? {} : { batchSize: edges.batchSize },
+    ...edges.maxRecords === void 0 ? {} : { maxRecords: edges.maxRecords }
+  });
+  if (outcome.kind === "hook-response") {
+    return {
+      envelope: ok({ transport: "hook" }),
+      exitCode: outcome.response.exitCode,
+      hookResponse: outcome.response
+    };
+  }
+  return { envelope: outcome.envelope, exitCode: outcome.exitCode };
+}
+async function runCli(argv, options = {}) {
+  const parsed = parseArgs(argv);
+  if (!parsed.ok) return refuse(parsed.envelope);
+  const { words, flags } = parsed.parsed;
+  const help = booleanFlag(flags, "help");
+  if (!help.ok) return refuse(help.envelope);
+  if (help.value || words.length === 0) {
+    return { envelope: ok(helpText()), exitCode: EXIT.OK };
+  }
+  const direct = booleanFlag(flags, "direct");
+  if (!direct.ok) return refuse(direct.envelope);
+  const identity = identityFlags(flags);
+  if (!identity.ok) return refuse(identity.envelope);
+  const resolution = resolveConfig({
+    flags: { ...identity, direct: direct.value },
+    env: options.env,
+    file: options.file
+  });
+  if (words[0] === "doctor") {
+    const report = doctorReport({
+      flags: { ...identity, direct: direct.value },
+      env: options.env,
+      file: options.file
+    });
+    return { envelope: ok(report), exitCode: report.configured ? EXIT.OK : EXIT.UNCONFIGURED };
+  }
+  if (words[0] === "init") {
+    return runInitCommand({ flags, env: options.env, file: options.file });
+  }
+  if (words[0] === "mcp") {
+    return runMcpStdio({ env: options.env, file: options.file });
+  }
+  if (words[0] === "hook") {
+    return await runCliHook(words.slice(1), options);
+  }
+  if (!resolution.ok) {
+    return { envelope: resolution.envelope, exitCode: resolution.exitCode };
+  }
+  const binding = await buildBinding(resolution.config, options);
+  return runCommand(argv, binding);
+}
+async function buildBinding(config, options) {
+  const identity = {
+    ...config.sessionId === void 0 ? {} : { sessionId: config.sessionId },
+    ...config.actor === void 0 ? {} : { actor: config.actor }
+  };
+  if (config.binding === "http") {
+    return createHttpBinding({
+      // Non-null by construction: `resolveConfig` returns `http` only when
+      // it resolved a URL, and the two are set in the same branch.
+      baseUrl: config.standupUrl,
+      ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+      ...identity,
+      ...config.token === void 0 ? {} : { token: config.token }
+    });
+  }
+  const loadService = options.loadService ?? (async () => (await import("../live-R6WH7ER7.js")).service);
+  return createDirectBinding({ service: await loadService(), ...identity });
+}
+function helpText() {
+  return {
+    usage: "standup <noun> <verb> [--json] [--direct] [--as <person>] [--session <id>]",
+    nouns: nouns(),
+    commands: COMMANDS.map((command) => `${command.noun} ${command.verb} \u2014 ${command.summary}`)
+  };
+}
+
+// src/lib/cli/render.ts
+function render(outcome, streams, json) {
+  if (outcome.hookResponse !== void 0) {
+    if (outcome.hookResponse.stdout !== "") streams.out(outcome.hookResponse.stdout);
+    if (outcome.hookResponse.stderr !== "") streams.err(outcome.hookResponse.stderr);
+    return;
+  }
+  if (json) {
+    streams.out(`${JSON.stringify(outcome.envelope)}
+`);
+    return;
+  }
+  streams.err(`${humanText(outcome.envelope)}
+`);
+}
+function humanText(envelope) {
+  if (envelope.ok) {
+    return typeof envelope.data === "string" ? envelope.data : JSON.stringify(envelope.data, null, 2);
+  }
+  const { code, message, fields, guard } = envelope.error;
+  const parts = [`${code}: ${message}`];
+  if (guard !== void 0) parts.push(`  rule: ${guard}`);
+  if (fields.length > 0) parts.push(`  fields: ${fields.join(", ")}`);
+  return parts.join("\n");
+}
+
+// src/lib/cli/main.ts
+async function main(argv, { streams, ...options }) {
+  const parsed = parseArgs(argv);
+  const jsonFlag2 = parsed.ok ? booleanFlag(parsed.parsed.flags, "json") : void 0;
+  const json = jsonFlag2?.ok === true && jsonFlag2.value;
+  let outcome;
+  try {
+    outcome = await runCli(argv, options);
+  } catch (cause) {
+    log.fatal("The command failed outside the binding boundary.", {
+      transport: "cli",
+      err: cause
+    });
+    const envelope = {
+      ok: false,
+      error: {
+        code: "internal",
+        message: `The command failed unexpectedly (${cause instanceof Error ? cause.name : "unknown error"}).`,
+        fields: []
+      }
+    };
+    render({ envelope, exitCode: EXIT.FAILURE }, streams, json);
+    return exitCodeFor(envelope);
+  }
+  render(outcome, streams, json);
+  return outcome.exitCode;
+}
+
+// src/bin/standup.ts
+var file = readConfigFile();
+var baseUrl = process.env.STANDUP_URL?.trim();
+var exitCode = await main(process.argv.slice(2), {
+  env: process.env,
+  file,
+  hook: {
+    spool: fileSpool(spoolPath(process.env)),
+    now: Date.now(),
+    ...baseUrl === void 0 || baseUrl === "" ? {} : { send: createHttpFlush({ baseUrl, fetch: globalThis.fetch }) }
+  },
+  streams: {
+    out: (text) => process.stdout.write(text),
+    err: (text) => process.stderr.write(text)
+  }
+});
+process.exitCode = exitCode;