@sleds/cli 0.1.44 → 0.1.46

package/dist/sleds.mjs

@@ -802,6 +802,13 @@ var init_verbs = __esm(() => {
       app: "Work › the item › click a field",
       how: "The filer, an approver or an admin changes an item from chat or by clicking the field in the app; every change says who and through what (via Claude · Cowork, via ChatGPT, in the app) and the record keeps before and after. A change to the ask, done or smallest marks the band stale with a Re-size at hand — never re-sized silently. Worth is the person's word in their words ('high · Acme renewal', '$5k–20k'; null clears it); on an epic, `carry: true` puts it on each child that has none, each child's record signed the same way. A mirrored ticket is the tracker's word and is not changed here."
     },
+    {
+      id: "reopen",
+      group: "meter",
+      want: "Put back an item that landed by mistake",
+      mcp: "reopen {project, reason}",
+      how: "SL-1819. For an item a skipped node or a wrong actual landed. It goes back on the sled it was on — or to ready on no sled, when that sled is gone from the org — the false actual is cleared and the band stands. A reopen always says why; the why goes on the item's record. The filer, an approver or an admin. Only a landed item reopens."
+    },
     {
       id: "archive",
       group: "meter",
@@ -2079,7 +2086,7 @@ ${state}`)}, fillcolor="${fill}", color="${border}"${style}];`);
 `)}
 `;
 }
-var ROUTE_APPROACH_MAX = 2000, PLAN_APPROACH_MAX = 1200, PLAN_LIST_MAX = 8, PLAN_LINE_MAX = 240, CONTROL, MAX_NODES = 24, DEPTH_WARN = 4, norm2 = (s) => s.trim().toUpperCase(), AREA_ROOTS, NOT_AREAS, sameRepo = (a, b) => a.length === 0 || b.length === 0 || a.some((r) => b.includes(r)), DOT_COLORS, ROUTE_DRAFT_RULE = "Draft the route: PR-sized nodes, file-disjoint where they run in parallel, each with a title, the files or areas it touches, the repo, and the nodes it waits on (by key: A, B, C…). Prefer wide waves over chains deeper than four. Make the tough calls once, so each node's session follows them: an `approach` paragraph for the whole route, and on each node a `plan` — its approach, what it `provides` that later nodes rely on (names, shapes, files), what it `expects` from the nodes it waits on, and the `doneChecks` that say it landed. Show the graph and the plans as text and ask for a yes; file nothing before it. Then `route {q, approach, nodes: [{key, title, touches, repos, blockedBy, plan: {approach, provides, expects, doneChecks}}], confirm: true}`.";
+var ROUTE_APPROACH_MAX = 2000, PLAN_APPROACH_MAX = 1200, PLAN_LIST_MAX = 8, PLAN_LINE_MAX = 240, CONTROL, MAX_NODES = 24, DEPTH_WARN = 4, norm2 = (s) => s.trim().toUpperCase(), AREA_ROOTS, NOT_AREAS, sameRepo = (a, b) => a.length === 0 || b.length === 0 || a.some((r) => b.includes(r)), DOT_COLORS, ROUTE_DRAFT_RULE = "Draft the route: PR-sized nodes, file-disjoint where they run in parallel, each with a title, the files or areas it touches, the repo, and the nodes it waits on (by key: A, B, C…). Prefer wide waves over chains deeper than four. Make the tough calls once, so each node's session follows them: an `approach` paragraph for the whole route, and on each node a `plan` — its approach, what it `provides` that later nodes rely on (names, shapes, files), what it `expects` from the nodes it waits on, and the `doneChecks` that say it landed. Show the graph and the plans as text and ask for a yes; file nothing before it. An item with children takes no nodes: its children are the work, and their order lives in their blockedBy. Then `route {q, approach, nodes: [{key, title, touches, repos, blockedBy, plan: {approach, provides, expects, doneChecks}}], confirm: true}`.";
 var init_route = __esm(() => {
   CONTROL = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
   AREA_ROOTS = new Set(["apps", "packages", "services", "libs", "crates", "modules"]);
@@ -2151,6 +2158,7 @@ var init_annotations = __esm(() => {
     finish: add("Land the work"),
     buddy: add("Pair with a buddy"),
     pickup: add("Pick up a hand-off"),
+    reopen: add("Reopen an item", true),
     update: change("Change an item", true),
     archive: change("Archive an item", true),
     withdraw: change("Withdraw a hand-off", true)
@@ -3223,6 +3231,27 @@ async function updateTool(ctx, args) {
     text: `${key} updated: ${changed.join(", ")}.${carried}${stale ? " The band was sized before this change — say so, and offer to re-size (estimate with the same source)." : ""}`
   };
 }
+async function reopenTool(ctx, args) {
+  if (!ctx.client)
+    return NOT_SET_UP;
+  const project = str5(args.project)?.trim();
+  if (!project)
+    return { text: "Which item? Pass project: its key (QW-142).", isError: true };
+  const reason = str5(args.reason)?.trim();
+  if (!reason)
+    return {
+      text: "Say why it is reopened — pass reason, one line. It goes on the item's record.",
+      isError: true
+    };
+  const res = await postSaying(ctx, "/proxy/reopen", { project, reason }, "Could not reopen the item.");
+  if ("fail" in res)
+    return res.fail;
+  const key = str5(res.json.key) ?? project;
+  const sled = str5(res.json.sled);
+  return {
+    text: `Reopened ${key} — ${sled ? `back on ${sled}'s sled` : "back to ready, on no sled"}. The false actual is cleared; the band stands.`
+  };
+}
 function carriedLine(c) {
   if (!isObject4(c))
     return "";
@@ -3531,9 +3560,21 @@ async function itemTool(ctx, args) {
       text: `Nothing on the sled answers to "${q}". Try the key (QW-142) or a word from the title with status.`,
       isError: true
     };
-  const md = str5(r.markdown) ?? "";
   if (asFile)
-    return { text: md, structured: { key: str5(r.key) ?? q, export: true } };
+    return { text: str5(r.markdown) ?? "", structured: { key: str5(r.key) ?? q, export: true } };
+  const envs = isObject4(r.whereLive) && Array.isArray(r.whereLive.envs) ? r.whereLive.envs : [];
+  const live = envs.filter(isObject4).filter((e) => {
+    const s = isObject4(e.state) ? e.state : null;
+    return !(s && (s.kind === "no_code" || s.state === "no_code"));
+  }).map((e) => `- ${str5(e.name) ?? str5(e.slug) ?? "?"}: ${str5(e.words) ?? ""}`);
+  const body = str5(r.markdown) ?? "";
+  const section = live.length ? `## Where it's live
+${live.join(`
+`)}
+
+` : "";
+  const title = body.match(/^# [^\n]*\n+/)?.[0] ?? "";
+  const md = `${title}${section}${body.slice(title.length)}`;
   const readiness = isObject4(r.readiness) ? r.readiness : null;
   const line = readiness ? str5(readiness.line) : undefined;
   const state = readiness ? str5(readiness.state) : undefined;
@@ -4274,6 +4315,8 @@ async function callTool(name, args, ctx) {
       return attachTool(ctx, args);
     case "update":
       return updateTool(ctx, args);
+    case "reopen":
+      return reopenTool(ctx, args);
     case "archive":
       return archiveTool(ctx, args);
     case "comment":
@@ -4679,7 +4722,7 @@ var init_server = __esm(() => {
     },
     {
       name: "route",
-      description: "The route — an item's internal order as PR-sized nodes with blockers (spec 26). With only `q`: the route as filed (each node's state, what it waits on, the ready set, where each run can be watched), or, when none is filed, the pack and the drafting rule so you draft one. Drafting: PR-sized nodes, file-disjoint where they run in parallel, each with a title, the files or areas it touches, the repo, and the nodes it waits on by key (A, B, C…); prefer wide waves over chains deeper than four. Make the tough calls once: an `approach` for the route and a `plan` on each node (its approach, what it provides to later nodes, what it expects from the nodes it waits on, its done-checks), so each node's session follows them instead of re-planning. Show the graph and the plans as text and ask for a yes; file nothing before it. Then call again with `nodes` and `confirm: true`. Re-drafting shows what changed; a node with a run or a PR is never removed. Ready is computed from landed blockers, never set. With nobody to ask (a drafting session an engine started, spec 26 §5.1): call with `nodes` and `propose: true` instead — the route is held on the item for a person's yes and nothing is filed; then stop. A read of an item with a proposal shows it as drafted, not filed.",
+      description: "The route — an item's internal order as PR-sized nodes with blockers (spec 26). With only `q`: the route as filed (each node's state, what it waits on, the ready set, where each run can be watched), or, when none is filed, the pack and the drafting rule so you draft one. Drafting: PR-sized nodes, file-disjoint where they run in parallel, each with a title, the files or areas it touches, the repo, and the nodes it waits on by key (A, B, C…); prefer wide waves over chains deeper than four. Make the tough calls once: an `approach` for the route and a `plan` on each node (its approach, what it provides to later nodes, what it expects from the nodes it waits on, its done-checks), so each node's session follows them instead of re-planning. Show the graph and the plans as text and ask for a yes; file nothing before it. Then call again with `nodes` and `confirm: true`. An item with children is refused nodes — its children are the work: set their order with blockedBy on them. The item lands only when every child has landed. Re-drafting shows what changed; a node with a run or a PR is never removed. Ready is computed from landed blockers, never set. With nobody to ask (a drafting session an engine started, spec 26 §5.1): call with `nodes` and `propose: true` instead — the route is held on the item for a person's yes and nothing is filed; then stop. A read of an item with a proposal shows it as drafted, not filed.",
       inputSchema: {
         type: "object",
         properties: {
@@ -4967,6 +5010,21 @@ var init_server = __esm(() => {
         required: ["project"]
       }
     },
+    {
+      name: "reopen",
+      description: "Put back an item that landed by mistake — a skipped node closed its route, or an actual was sent against the wrong item. It goes back on the sled it was on (or to ready, when that sled is gone), the false actual is cleared and the band stands. Pass the item's key and why: a reopen always says why, and the why goes on the item's record. The filer, an approver or an admin may. Only a landed item can be reopened.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project: { type: "string", description: "The item's key — QW-142 — or its project key." },
+          reason: {
+            type: "string",
+            description: "Why it is reopened, one line — e.g. 'a skipped node landed it; six children are open'."
+          }
+        },
+        required: ["project", "reason"]
+      }
+    },
     {
       name: "item",
       description: "Read one item whole, as one markdown document — the pack: everything an engineer or an agent needs to finish the work from this document alone. Eight parts: the ask, where the code is, how to run it (the repo's setup profile), how to know it is done (the gate), how to ship it (the playbook), what the org expects, what is known already (the Field Book — notes from earlier runs on this item, its feature and what landed beside it, the questions, the thread), and the rules of the road. Carries its readiness and whether it is packable. Pass the item's key (QW-142) or its title. Call this before building from an item, and before `check`.",
@@ -6416,7 +6474,54 @@ var init_pack2 = __esm(() => {
 });
 
 // ../../packages/shared/src/deploys/deploys.ts
-var init_deploys = () => {};
+function parseDeployBody(json) {
+  if (!json || typeof json !== "object" || Array.isArray(json))
+    return bad("body must be a JSON object");
+  const j = json;
+  const repo = typeof j.repo === "string" ? j.repo.trim().toLowerCase() : "";
+  if (!REPO_RE.test(repo))
+    return bad("repo must be owner/name");
+  const sha = typeof j.sha === "string" ? j.sha.trim().toLowerCase() : "";
+  if (!SHA_RE.test(sha))
+    return bad("sha must be 7–40 hex characters");
+  const environment = typeof j.environment === "string" ? j.environment.trim() : "";
+  if (!ENV_SLUG_RE.test(environment))
+    return bad("environment must be a slug: lower-case letters, digits, - and _");
+  const body = { repo, sha, environment };
+  if (j.service !== undefined && j.service !== null) {
+    const service = typeof j.service === "string" ? j.service.trim() : "";
+    if (!SERVICE_RE.test(service))
+      return bad("service must be a short name");
+    body.service = service;
+  }
+  if (j.at !== undefined && j.at !== null) {
+    const at = typeof j.at === "string" ? Date.parse(j.at) : typeof j.at === "number" ? j.at : Number.NaN;
+    if (!Number.isFinite(at))
+      return bad("at must be an ISO time");
+    body.at = at;
+  }
+  if (j.url !== undefined && j.url !== null) {
+    let ok = false;
+    if (typeof j.url === "string") {
+      try {
+        ok = new URL(j.url).protocol === "https:";
+      } catch {
+        ok = false;
+      }
+    }
+    if (!ok)
+      return bad("url must be an https link");
+    body.url = j.url;
+  }
+  return { ok: true, body };
+}
+var REPO_RE, SHA_RE, ENV_SLUG_RE, SERVICE_RE, bad = (error) => ({ ok: false, error });
+var init_deploys = __esm(() => {
+  REPO_RE = /^[a-z0-9_.-]+\/[a-z0-9_.-]+$/;
+  SHA_RE = /^[0-9a-f]{7,40}$/;
+  ENV_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,39}$/;
+  SERVICE_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,39}$/;
+});
 
 // ../../packages/shared/src/newrelic/newrelic.ts
 var init_newrelic = () => {};
@@ -6817,7 +6922,7 @@ function nodePrompt(o) {
     ...claim.pack.includes(PR_HEADER_OPEN) ? [
       `- The PR body starts with the pack's PR header block (\`${PR_HEADER_OPEN}\` … \`${PR_HEADER_CLOSE}\`, in its part 5), above everything else. The pack wrote it before your work existed: when you make a mock (a screenshot or an artifact) or write a doc, put its link on that part's line in place of \`None\` — not only lower in the body (SL-1746). When you edit the body later, keep it on top.`
     ] : [],
-    "- Run the repo's own gate before you push. Never merge: a person (or the musher, when the attachment says so) does.",
+    o.gate ? `- Run the repo's gate before you push: exactly \`${o.gate}\`, as given. Never wrap it — no \`$?\`, \`$(...)\`, \`bash -c\` or \`; echo\` around it — or it stops at a permission dialog; read its result from the exit and the output. Never merge: a person (or the musher, when the attachment says so) does.` : "- Run the repo's own gate before you push. Never merge: a person (or the musher, when the attachment says so) does.",
     "- Stay inside this node's scope. Work another node needs goes in the PR description, not in this branch.",
     `- End every comment and reply you post on the PR with the line \`${ENGINE_MARK}\`, so the engine knows it is yours and not a reviewer's.`,
     "- The approved brief and this route are the go-ahead: a person said yes to them before this session started. Build, commit, push and open the PR; a park is for a question the record does not settle, not for a go-ahead to build or push.",
@@ -9693,9 +9798,127 @@ var defer = async (o) => {
   return 0;
 };
 
+// src/commands/deploy.ts
+init_src();
+import { execFileSync as execFileSync2 } from "node:child_process";
+var DEPLOYS_URL = "https://hooks.sleds.ai/deploys";
+var USAGE = "usage: sleds deploy --env <slug> [--service <name>] [--sha <sha>] [--repo <owner/name>]";
+var FLAGS = ["env", "service", "sha", "repo"];
+var set = (x) => x?.trim() ? x.trim() : undefined;
+function repoFromRemote(remote) {
+  const m = /^(?:[a-z+]+:\/\/)?(?:[^@/]+@)?[^/:]+[:/](.+?)(?:\.git)?\/?$/i.exec(remote.trim());
+  const parts = m?.[1]?.split("/").filter(Boolean) ?? [];
+  if (parts.length < 2)
+    return null;
+  return `${parts[parts.length - 2]}/${parts[parts.length - 1]}`.toLowerCase();
+}
+function resolveDeploy(argv, env, git) {
+  const flags = {};
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i] ?? "";
+    const m = /^--([a-z]+)(?:=(.*))?$/.exec(a);
+    const name = m?.[1];
+    if (!m || !name || !FLAGS.includes(name))
+      return { ok: false, error: `unknown argument ${a}` };
+    const value = m[2] ?? argv[++i];
+    if (!set(value))
+      return { ok: false, error: `--${name} needs a value` };
+    flags[name] = value?.trim();
+  }
+  if (!flags.env)
+    return { ok: false, error: "--env <slug> is required" };
+  const vercelRepo = set(env.VERCEL_GIT_REPO_OWNER) && set(env.VERCEL_GIT_REPO_SLUG) ? `${set(env.VERCEL_GIT_REPO_OWNER)}/${set(env.VERCEL_GIT_REPO_SLUG)}` : undefined;
+  const remote = () => {
+    const url = git(["remote", "get-url", "origin"]);
+    return url && repoFromRemote(url) || undefined;
+  };
+  const repo = flags.repo ?? set(env.GITHUB_REPOSITORY) ?? vercelRepo ?? remote();
+  if (!repo)
+    return { ok: false, error: "no repo: pass --repo owner/name (no origin remote)" };
+  const sha = flags.sha ?? set(env.SOURCE_VERSION) ?? set(env.HEROKU_SLUG_COMMIT) ?? set(env.VERCEL_GIT_COMMIT_SHA) ?? set(env.GITHUB_SHA) ?? set(git(["rev-parse", "HEAD"]) ?? undefined);
+  if (!sha)
+    return { ok: false, error: "no sha: pass --sha (not a git checkout)" };
+  return parseDeployBody({
+    repo,
+    sha,
+    environment: flags.env,
+    ...flags.service ? { service: flags.service } : {}
+  });
+}
+var defaultGit = (args) => {
+  try {
+    return execFileSync2("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    return null;
+  }
+};
+var defaultPost = async (url, token, body) => {
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15000)
+    });
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {}
+    return { status: res.status, json };
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+};
+function deployLine(body, json) {
+  const where = `${body.repo}${body.service ? ` (${body.service})` : ""} → ${body.environment}`;
+  if (typeof json.ignored === "string")
+    return `ignored: ${json.ignored}`;
+  if (json.duplicate)
+    return `${where}: already at ${body.sha.slice(0, 7)}`;
+  const prs = Array.isArray(json.newlyDeployed) ? json.newlyDeployed : [];
+  const list = prs.map((p) => `#${p.number}`).join(", ");
+  if (json.rollback)
+    return `${where}: rollback to ${body.sha.slice(0, 7)}${list ? ` (carries ${list} again)` : ""}`;
+  return prs.length ? `${where}: newly deployed ${list}` : `${where}: ${body.sha.slice(0, 7)} recorded, no newly deployed PRs`;
+}
+var deployCmd = async (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  const env = o.env ?? process.env;
+  const token = set(env.SLEDS_DEPLOY_TOKEN);
+  if (!token) {
+    error("SLEDS_DEPLOY_TOKEN is not set — mint one in Settings › Deploys");
+    return 2;
+  }
+  const resolved = resolveDeploy(o.argv, env, o.git ?? defaultGit);
+  if (!resolved.ok) {
+    error(resolved.error);
+    error(USAGE);
+    return 2;
+  }
+  const body = resolved.body;
+  const url = set(env.SLEDS_DEPLOYS_URL) ?? DEPLOYS_URL;
+  const r = await (o.post ?? defaultPost)(url, token, body);
+  if ("error" in r) {
+    error(`warning: SLEDS unreachable, deploy not recorded — ${r.error}`);
+    return 0;
+  }
+  if (r.status === 200 && r.json) {
+    log(deployLine(body, r.json));
+    return 0;
+  }
+  const why = typeof r.json?.error === "string" ? r.json.error : `HTTP ${r.status}`;
+  if (r.status >= 400 && r.status < 500) {
+    error(r.status === 401 ? `SLEDS refused the deploy token (${why})` : why);
+    return 1;
+  }
+  error(`warning: SLEDS answered ${why}, deploy not recorded`);
+  return 0;
+};
+
 // src/commands/doctor.ts
 init_src();
-import { execFileSync as execFileSync3, spawnSync as spawnSync5 } from "node:child_process";
+import { execFileSync as execFileSync4, spawnSync as spawnSync5 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import {
   existsSync as existsSync17,
@@ -9710,7 +9933,7 @@ import { tmpdir } from "node:os";
 import { join as join20, resolve as resolve9 } from "node:path";
 
 // src/agentMcp.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
 import { dirname as dirname8, join as join10, resolve as resolve6 } from "node:path";
 init_settings();
@@ -9778,7 +10001,7 @@ function applyCodexMcp2(toml, home, env = process.env) {
 `;
 }
 var defaultRunClaude2 = (args) => {
-  execFileSync2("claude", args, { stdio: ["ignore", "ignore", "pipe"], timeout: 20000 });
+  execFileSync3("claude", args, { stdio: ["ignore", "ignore", "pipe"], timeout: 20000 });
 };
 async function offerMcp2(o) {
   const env = o.env ?? process.env;
@@ -10233,6 +10456,7 @@ var agentShellCommand = (o) => {
   const effort = o.effort ? ` --effort ${shq2(o.effort)}` : "";
   return `${sandboxedAgent("claude", o.sandbox, o.mainCheckout)}${hookSettingsFlag(o)}${mcpConfigFlag(o)} --permission-mode ${shq2(o.permissionMode)}${model}${effort} ${prompt}`;
 };
+var execLine = (cmd) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(cmd) ? `exec env ${cmd}` : `exec ${cmd}`;
 var sandboxedAgent = (agent, sandbox, mainCheckout) => {
   const kind = sandboxAgentKind(agent);
   const line = kind === "claude" ? `${agent}${claudeAddDirFlag(mainCheckout)}` : agent;
@@ -10705,7 +10929,7 @@ var parseOrcaTerminal = (env) => {
 };
 var orcaLauncher = (o) => `#!/bin/sh
 # sleds engine: ${o.name}
-exec ${agentShellCommand(o)}
+${execLine(agentShellCommand(o))}
 `;
 var orcaCommand = (launcher) => `sh ${shq2(launcher)}; exit`;
 var GONE = /exit|clos|gone|dead|stopp|kill/i;
@@ -10907,7 +11131,7 @@ function beatBody(state, flags, host = {}, cap = {}) {
     name: flags.name,
     os: host.os ?? process.platform,
     runner: flags.runner,
-    version: host.version ?? "0.1.44" ?? "dev",
+    version: host.version ?? "0.1.46" ?? "dev",
     running: live.length,
     items: live.slice(0, BEAT_ITEMS).map((r) => `${r.item}/${r.node}`),
     ...cap.atOnce !== undefined ? { atOnce: cap.atOnce } : {},
@@ -11900,7 +12124,7 @@ function keysIn(states, state) {
 }
 function statesLanded(states) {
   const all = Object.values(states);
-  return all.length > 0 && all.every((s) => s === "landed" || s === "skipped");
+  return all.length > 0 && all.every((s) => s === "landed" || s === "skipped") && all.some((s) => s === "landed");
 }
 function armedTerms(armed) {
   if (!isObject8(armed))
@@ -12098,21 +12322,17 @@ async function readProfile(client) {
 }
 function nextPickup(r, o) {
   const mine = Array.isArray(r.mine) ? r.mine.filter(isObject8) : [];
-  let running = 0;
   for (const row of mine) {
     const route = row.route;
-    if (isObject8(route) && route.drafting === true)
-      running++;
-    if (!isObject8(route) || !isObject8(route.armed))
+    if (!isObject8(route) || !armedFor(route.armed, o.engine))
       continue;
     const states = isObject8(route.states) ? route.states : {};
-    running += keysIn(states, "running").length;
-    if (!armedFor(route.armed, o.engine) || statesLanded(states))
+    if (statesLanded(states))
       continue;
     if (strings(route.ready).length > 0)
       return null;
   }
-  if (running >= o.atOnce)
+  if (sledRunning(mine) >= o.atOnce)
     return null;
   for (const row of mine) {
     const route = row.route;
@@ -12128,6 +12348,33 @@ function nextPickup(r, o) {
   }
   return null;
 }
+function sledRunning(r) {
+  const mine = Array.isArray(r) ? r : Array.isArray(r.mine) ? r.mine.filter(isObject8) : [];
+  let running = 0;
+  for (const row of mine) {
+    const route = row.route;
+    if (isObject8(route) && route.drafting === true)
+      running++;
+    if (!isObject8(route) || !isObject8(route.armed))
+      continue;
+    running += keysIn(isObject8(route.states) ? route.states : {}, "running").length;
+  }
+  return running;
+}
+function armedDrafts(r, engine) {
+  const mine = Array.isArray(r.mine) ? r.mine.filter(isObject8) : [];
+  return mine.filter((row) => {
+    const route = row.route;
+    if (!isObject8(route) || !armedFor(route.armed, engine) || route.implicit !== true)
+      return false;
+    if (route.drafting === true || route.proposed === true || route.draftParked)
+      return false;
+    if (strings(route.needsRoute).length === 0 || isPrMirror(row.source))
+      return false;
+    const states = isObject8(route.states) ? route.states : {};
+    return !statesLanded(states) && keysIn(states, "running").length === 0;
+  });
+}
 function redraftDue(route) {
   return isObject8(route) && isObject8(route.redraft) && route.drafting !== true && route.proposed !== true;
 }
@@ -12141,14 +12388,15 @@ function routeText(route, states) {
 }
 function sledsSource(client, o) {
   const routeOf = (q) => client.get(`/proxy/route?q=${encodeURIComponent(q)}`);
-  async function pickup(sled) {
+  async function pickup(sled, drafted) {
     const engine = o.engine;
     const profile = await readProfile(client);
     if (profile?.pickup !== "auto")
       return null;
     if (profile.engine && !sameEngine(profile.engine, engine))
       return null;
-    const row = nextPickup(sled, { atOnce: o.atOnce ?? profile.atOnce ?? 1, engine });
+    const atOnce = (o.atOnce ?? profile.atOnce ?? 1) - drafted;
+    const row = nextPickup(sled, { atOnce, engine });
     if (!row)
       return null;
     const item = str6(row.key) ?? String(row.project);
@@ -12176,7 +12424,7 @@ function sledsSource(client, o) {
       ...armedTerms(armed)
     };
   }
-  async function draft(row, item, why) {
+  async function draft(row, item, why, started = false) {
     const project = str6(row.project) ?? item;
     const pending = isObject8(row.route) && isObject8(row.route.redraft) ? row.route.redraft : null;
     const runner = typeof o.runner === "function" ? o.runner() : o.runner;
@@ -12188,7 +12436,7 @@ function sledsSource(client, o) {
       ...o.leaseMin !== undefined ? { leaseMin: o.leaseMin } : {}
     });
     if (!r || r.status >= 300 || !r.json || r.json.ok === false) {
-      o.log?.(`${pending ? `${item}: could not claim the re-draft` : `Pickup: Auto could not claim ${item} for drafting`} — ${r ? serverMessage(r) : UNREACHABLE2}`);
+      o.log?.(`${pending ? `${item}: could not claim the re-draft` : started ? `${item}: Start could not claim it for drafting` : `Pickup: Auto could not claim ${item} for drafting`} — ${r ? serverMessage(r) : UNREACHABLE2}`);
       return null;
     }
     const j = r.json;
@@ -12210,7 +12458,7 @@ function sledsSource(client, o) {
         route: routeText(brief, isObject8(row.route) ? row.route.states : null)
       };
     }
-    o.log?.(redraft ? `${item}: re-drafting the route from ${redraft.by}'s answer — it waits for a yes` : `Pickup: Auto is drafting ${item}'s route first (${why.join(", ")}) — it waits for a yes`);
+    o.log?.(redraft ? `${item}: re-drafting the route from ${redraft.by}'s answer — it waits for a yes` : `${started ? `${item}: Start` : "Pickup: Auto"} is drafting ${started ? "its" : `${item}'s`} route first (${why.join(", ")}) — it waits for a yes`);
     const leaseUntil = num5(j.leaseUntil);
     const claim = {
       item,
@@ -12250,7 +12498,28 @@ function sledsSource(client, o) {
           if (claimed?.draft && it)
             it.draft = claimed.draft;
         }
-        const picked = await pickup(r);
+        const waiting = armedDrafts(r, o.engine);
+        let drafted = 0;
+        if (waiting.length > 0) {
+          const cap = o.atOnce ?? (await readProfile(client))?.atOnce ?? 1;
+          let room = cap - sledRunning(r);
+          for (const row of waiting) {
+            const item = str6(row.key) ?? String(row.project);
+            const it = items.find((x) => x.item === item);
+            if (it)
+              it.ready = [];
+            if (room <= 0)
+              continue;
+            const route = isObject8(row.route) ? row.route : {};
+            const claimed = await draft(row, item, strings(route.needsRoute), true);
+            if (claimed?.draft && it) {
+              it.draft = claimed.draft;
+              drafted++;
+              room--;
+            }
+          }
+        }
+        const picked = await pickup(r, drafted);
         if (picked)
           items.push(picked);
       }
@@ -12865,6 +13134,37 @@ function packInstallOf(pack, repo) {
   }
   return first;
 }
+function packGateOf(pack, repo) {
+  let inDone = false;
+  let first;
+  const want = repo?.trim().toLowerCase();
+  for (const line of pack.split(`
+`)) {
+    if (/^##\s/.test(line)) {
+      inDone = /^##\s+4\./.test(line);
+      continue;
+    }
+    if (!inDone)
+      continue;
+    const m = line.match(/^\s*-\s*([^:`]+?):\s*`(.+)`\s*$/);
+    if (!m?.[1] || !m[2])
+      continue;
+    const name = m[1].trim().toLowerCase();
+    if (name === "done means" || name.startsWith("try it"))
+      continue;
+    if (want && name === want)
+      return m[2];
+    first ??= m[2];
+  }
+  return first;
+}
+function gateAllowRules(gate) {
+  const whole = gate?.trim();
+  if (!whole)
+    return [];
+  const parts = whole.split(/&&|\|\||;/).map((p) => p.trim()).filter(Boolean);
+  return [...new Set([whole, ...parts])].map((c) => `Bash(${c})`);
+}
 function ensureInstalled(exec, path, fs, o = {}) {
   if (!fs.exists(join15(path, "package.json")) || fs.exists(join15(path, "node_modules")))
     return null;
@@ -12957,17 +13257,17 @@ function fingerprint(text) {
   }
   return (h >>> 0).toString(16);
 }
-function sandboxFor(d, name, cwd) {
+function sandboxFor(d, name, cwd, allow) {
   if (!d.sandbox)
     return {};
   if (!d.writeSandboxSettings)
     throw new Error("sessions are sandboxed, but nothing writes their settings — not started");
-  return { sandbox: d.writeSandboxSettings(name, cwd) };
+  return { sandbox: d.writeSandboxSettings(name, cwd, allow) };
 }
-function hooksFor(d, name) {
+function hooksFor(d, name, allow) {
   if (d.sandbox || !d.writeHookSettings)
     return {};
-  return { settingsFile: d.writeHookSettings(name) };
+  return { settingsFile: d.writeHookSettings(name, allow) };
 }
 function mainCheckoutFor(d, cwd) {
   const main = d.mainCheckoutOf?.(cwd);
@@ -13425,6 +13725,8 @@ async function tickOnce(d) {
       const worktree = d.runner.makesWorktree ? repoPath : d.ensureWorktree(d.exec, repoPath, branch, worktreePath(repoPath, name), base, packInstallOf(claim.pack, claim.repos[0])) ?? worktreePath(repoPath, name);
       const prTitle = d.prTitleOf?.(claim);
       mcpConfig = engineMcpConfigFor(d, name, claim.runToken, at, worktree);
+      const gate = packGateOf(claim.pack, claim.repos[0]);
+      const allow = gateAllowRules(gate);
       const prompt = nodePrompt({
         claim,
         branch,
@@ -13433,6 +13735,7 @@ async function tickOnce(d) {
         sledsTools: d.source.name === "sleds",
         engineMcp: Boolean(mcpConfig),
         ...prTitle ? { prTitle } : {},
+        ...gate ? { gate } : {},
         ...nodePlanContext(await briefsOf(claim.item), claim.node)
       });
       const promptFile = d.writePrompt(name, prompt);
@@ -13449,8 +13752,8 @@ async function tickOnce(d) {
         ...launch.effort && !launch.agent ? { effort: launch.effort } : {},
         ...launch.agent ? { agent: launch.agent } : {},
         ...mcpConfig ? { mcpConfig, ...d.strictMcp ? { strictMcp: true } : {} } : {},
-        ...sandboxFor(d, name, worktree),
-        ...hooksFor(d, name),
+        ...sandboxFor(d, name, worktree, allow),
+        ...hooksFor(d, name, allow),
         ...mainCheckoutFor(d, worktree),
         ...claim.group ? { group: claim.group } : {}
       };
@@ -13708,6 +14011,24 @@ function pressAnswer(d, runner, run, options, answer) {
     return false;
   }
 }
+function readFollowed(d, runner, run) {
+  if (!runner.readsSession)
+    return "";
+  let shown = "";
+  try {
+    shown = runner.read(run.handle);
+  } catch {
+    shown = "";
+  }
+  const print = fingerprint(shown);
+  if (run.seen !== print) {
+    run.seen = print;
+    run.seenAt = d.now();
+    run.seenTicks = 0;
+  } else
+    run.seenTicks = (run.seenTicks ?? 0) + 1;
+  return shown;
+}
 async function dropPermission(d, run, why) {
   const perms = permissionsOf(d.source);
   if (!run.permission || !perms || !run.runId)
@@ -14532,11 +14853,13 @@ async function follow(d, state, run, claim, runner, finished, attention, changes
     return true;
   await judgeLook(d, run, view);
   if (view.state === "MERGED") {
+    await dropPermission(d, run, "the PR merged");
     const landed = await ripple(d, state, run, claim, runner, pr.url, finished, decided, view.head, view.mergeCommit);
     return !landed;
   }
   if (view.state === "CLOSED") {
     d.log(`${ref(run)}: ${pr.url} was closed without a merge — let go, its session stopped`);
+    await dropPermission(d, run, "the PR closed without a merge");
     stopOpen(d, run, runner);
     return false;
   }
@@ -14556,6 +14879,8 @@ async function follow(d, state, run, claim, runner, finished, attention, changes
       kind: "review",
       what: `${view.feedback - pr.feedback} new comment${view.feedback - pr.feedback === 1 ? "" : "s"}`
     });
+  if (await settlePermission(d, runner, run, readFollowed(d, runner, run)))
+    return true;
   const tell = (text, what) => {
     let alive = false;
     try {
@@ -15650,7 +15975,7 @@ var headlessScript = (o, log) => {
     ...o.model ? [`--model ${shq2(o.model)}`] : [],
     ...o.effort ? [`--effort ${shq2(o.effort)}`] : []
   ].join(" ");
-  return `exec ${cmd} > ${shq2(log)} 2>&1`;
+  return `${execLine(cmd)} > ${shq2(log)} 2>&1`;
 };
 var transcriptTail = (log) => {
   const lines = log.trimEnd().split(`
@@ -16567,7 +16892,7 @@ function engineDeps(o, flags, source, runner, stateName) {
     ...flags.strictMcp ? { strictMcp: true } : {},
     ...flags.sandbox ? {
       sandbox: true,
-      writeSandboxSettings: o.writeSandboxSettings ?? ((name, cwd) => {
+      writeSandboxSettings: o.writeSandboxSettings ?? ((name, cwd, allow) => {
         const gitCommonDir = gitCommonDirOf(exec, cwd);
         const dir = join16(stateDir, "sandbox");
         mkdirSync12(dir, { recursive: true, mode: 448 });
@@ -16576,6 +16901,9 @@ function engineDeps(o, flags, source, runner, stateName) {
           ...SANDBOX_DEFAULT_ALLOW,
           ...flags.sandboxAllow ?? []
         ]);
+        walls.permissions.allow = [
+          ...new Set([...walls.permissions.allow, ...allow ?? []])
+        ];
         const settings = withHook(name, { ...walls });
         writeFileSync13(p, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
@@ -16583,10 +16911,11 @@ function engineDeps(o, flags, source, runner, stateName) {
         return { settingsFile: p, gitCommonDir };
       })
     } : {},
-    writeHookSettings: (name) => {
+    writeHookSettings: (name, allow) => {
       mkdirSync12(hooksDir, { recursive: true, mode: 448 });
       const p = join16(hooksDir, `${name}.json`);
-      writeFileSync13(p, `${JSON.stringify(withHook(name, {}), null, 2)}
+      const base = allow?.length ? { permissions: { allow: [...allow] } } : {};
+      writeFileSync13(p, `${JSON.stringify(withHook(name, base), null, 2)}
 `, { mode: 384 });
       chmodSync4(p, 384);
       return p;
@@ -16717,7 +17046,7 @@ async function driveEngine(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.44"
+    cliVersion: "0.1.46"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -17619,7 +17948,7 @@ function formatDoctor(checks) {
 }
 function defaultWhich2(cmd) {
   try {
-    return execFileSync3("which", ["-a", cmd], {
+    return execFileSync4("which", ["-a", cmd], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).split(`
@@ -18156,7 +18485,7 @@ function parsePmset(text) {
 }
 var defaultPmset = () => {
   try {
-    return parsePmset(execFileSync3("pmset", ["-g", "custom"], { encoding: "utf8", timeout: 2000 }));
+    return parsePmset(execFileSync4("pmset", ["-g", "custom"], { encoding: "utf8", timeout: 2000 }));
   } catch {
     return null;
   }
@@ -18691,7 +19020,7 @@ function engineDeps2(o, flags, source, runner, stateName) {
     ...flags.strictMcp ? { strictMcp: true } : {},
     ...flags.sandbox ? {
       sandbox: true,
-      writeSandboxSettings: o.writeSandboxSettings ?? ((name, cwd) => {
+      writeSandboxSettings: o.writeSandboxSettings ?? ((name, cwd, allow) => {
         const gitCommonDir = gitCommonDirOf2(exec, cwd);
         const dir = join21(stateDir, "sandbox");
         mkdirSync16(dir, { recursive: true, mode: 448 });
@@ -18700,6 +19029,9 @@ function engineDeps2(o, flags, source, runner, stateName) {
           ...SANDBOX_DEFAULT_ALLOW,
           ...flags.sandboxAllow ?? []
         ]);
+        walls.permissions.allow = [
+          ...new Set([...walls.permissions.allow, ...allow ?? []])
+        ];
         const settings = withHook(name, { ...walls });
         writeFileSync18(p, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
@@ -18707,10 +19039,11 @@ function engineDeps2(o, flags, source, runner, stateName) {
         return { settingsFile: p, gitCommonDir };
       })
     } : {},
-    writeHookSettings: (name) => {
+    writeHookSettings: (name, allow) => {
       mkdirSync16(hooksDir, { recursive: true, mode: 448 });
       const p = join21(hooksDir, `${name}.json`);
-      writeFileSync18(p, `${JSON.stringify(withHook(name, {}), null, 2)}
+      const base = allow?.length ? { permissions: { allow: [...allow] } } : {};
+      writeFileSync18(p, `${JSON.stringify(withHook(name, base), null, 2)}
 `, { mode: 384 });
       chmodSync5(p, 384);
       return p;
@@ -18850,7 +19183,7 @@ async function driveEngine2(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.44"
+    cliVersion: "0.1.46"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -22498,12 +22831,81 @@ var promptEvent = async (o) => {
   return code;
 };
 
+// src/commands/reopen.ts
+var REOPEN_USAGE = 'usage: sleds reopen <key> --reason "<why it is reopened>" [--json]';
+function parseReopenArgs(argv) {
+  let key;
+  let reason = "";
+  let json = false;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json")
+      json = true;
+    else if (a === "--reason") {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith("--"))
+        return { error: "--reason needs a value" };
+      reason = value;
+      i++;
+    } else if (a.startsWith("--"))
+      return { error: `unknown flag ${a}` };
+    else if (key === undefined)
+      key = a;
+    else
+      return { error: `one item at a time — "${a}" is extra` };
+  }
+  if (!key)
+    return { error: "which item?" };
+  return { key, reason: reason.trim(), json };
+}
+function reopenedLine(key, j) {
+  const shown = typeof j.key === "string" ? j.key : key;
+  return typeof j.sled === "string" && j.sled ? `${shown} reopened — back on ${j.sled}'s sled` : `${shown} reopened — back to ready, on no sled`;
+}
+async function reopenCmd(o) {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  const a = parseReopenArgs(o.argv);
+  if ("error" in a) {
+    error(a.error);
+    error(REOPEN_USAGE);
+    return 2;
+  }
+  if (!a.reason) {
+    error(`${a.key}: say why it is reopened — it goes on the item's thread`);
+    error(REOPEN_USAGE);
+    return 1;
+  }
+  const client = engineClient({ home: o.home, ...o.client ? { client: o.client } : {} });
+  if ("error" in client) {
+    error(client.error);
+    return 1;
+  }
+  const r = await client.postFull("/proxy/reopen", { project: a.key, reason: a.reason });
+  if (!r) {
+    error(`${a.key}: SLEDS unreachable — nothing reopened`);
+    return 1;
+  }
+  const ok = r.status < 300 && r.json?.ok !== false;
+  if (a.json)
+    log(JSON.stringify(r.json ?? { ok: false, error: `HTTP ${r.status}` }));
+  if (!ok) {
+    const why = typeof r.json?.error === "string" ? r.json.error : `HTTP ${r.status}`;
+    if (!a.json)
+      error(r.status === 404 && !r.json ? `${a.key}: SLEDS does not know this seat — run \`sleds init\`` : `${a.key}: ${why}`);
+    return 1;
+  }
+  if (!a.json)
+    log(reopenedLine(a.key, r.json ?? {}));
+  return 0;
+}
+
 // src/commands/route.ts
 init_src();
 import { readFileSync as readFileSync27 } from "node:fs";
 import { hostname as hostname12 } from "node:os";
 var ARM_USAGE = "usage: sleds route arm <key> [--off] [--json] [--name <engine>] [--at-once <n>] [--runner tmux|headless|command|orca|cmux] [--runner-cmd '<launcher>'] [--agent '<command>'] [--mode <permission-mode>] [--model <id>] [--effort <e>] [--branch '<template>'] [--pr-title '<template>'] [--repos-dir <dir>]";
-var USAGE = "usage: sleds route <key> [--long | --dot | --json]   |   sleds route arm <key> [--off] [--json]   |   sleds route answer <key>/<node> --stdin   |   sleds route propose <key> --file <nodes.json>   |   sleds route approve <key>   |   sleds route redraft <key>   |   sleds route single <key>   |   sleds route decisions [<key>] [--flagged]   |   sleds route decision <key> <id> --seen | --answer --stdin [--route accept|keep|redraft] | --keep-route | --apply [--answer --stdin] | --overrule --stdin | --ready   |   sleds route run <key> [--at-once <n>] [--runner tmux|headless|command|orca|cmux] [--runner-cmd '<launcher>'] [--agent '<command>'] [--interval <s>] [--lease <min>] [--idle <min>] [--repo <path>] [--repos-dir <dir>] [--mode <permission-mode>] [--model <id>] [--branch '<template>'] [--pr-title '<template>'] [--once]";
+var USAGE2 = "usage: sleds route <key> [--long | --dot | --json]   |   sleds route arm <key> [--off] [--json]   |   sleds route answer <key>/<node> --stdin   |   sleds route propose <key> --file <nodes.json>   |   sleds route approve <key>   |   sleds route redraft <key>   |   sleds route single <key>   |   sleds route decisions [<key>] [--flagged]   |   sleds route decision <key> <id> --seen | --answer --stdin [--route accept|keep|redraft] | --keep-route | --apply [--answer --stdin] | --overrule --stdin | --ready   |   sleds route run <key> [--at-once <n>] [--runner tmux|headless|command|orca|cmux] [--runner-cmd '<launcher>'] [--agent '<command>'] [--interval <s>] [--lease <min>] [--idle <min>] [--repo <path>] [--repos-dir <dir>] [--mode <permission-mode>] [--model <id>] [--branch '<template>'] [--pr-title '<template>'] [--once]";
 var ANSWER_USAGE = "usage: sleds route answer <key>/<node> <answer…>   |   sleds route answer <key>/<node> --stdin   [--json]";
 var PROPOSE_USAGE = "usage: sleds route propose <key> (--file <nodes.json> | --stdin) [--name <engine>] [--json]";
 var APPROVE_USAGE = "usage: sleds route approve <key> [--file <nodes.json>] [--json]";
@@ -23058,14 +23460,14 @@ var routeCmd = async (o) => {
   const parsed = parseEngineArgs(o.argv.filter((a) => a !== "--dot" && a !== "--long" && a !== "--json"), o.host ?? hostname12());
   if ("error" in parsed) {
     error(parsed.error);
-    error(USAGE);
+    error(USAGE2);
     return 2;
   }
   const { positional } = parsed;
   const isRun = positional[0] === "run";
   const key = isRun ? positional[1] : positional[0];
   if (!key) {
-    error(USAGE);
+    error(USAGE2);
     return 2;
   }
   if (asJson) {
@@ -23321,7 +23723,7 @@ var seatEvent = async (o) => {
 };
 
 // src/commands/seatSync.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 import { existsSync as existsSync26, mkdirSync as mkdirSync22, readFileSync as readFileSync28, readdirSync as readdirSync5, rmSync as rmSync16, writeFileSync as writeFileSync25 } from "node:fs";
 import { platform as platform2 } from "node:os";
 import { dirname as dirname17, join as join26 } from "node:path";
@@ -23689,7 +24091,7 @@ async function readCookieRowsBun(home, source) {
 }
 function keychainKey(service) {
   try {
-    return execFileSync4("security", ["find-generic-password", "-w", "-s", service], {
+    return execFileSync5("security", ["find-generic-password", "-w", "-s", service], {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -23701,7 +24103,7 @@ function decryptJar(rows, safeStoragePw) {
 }
 var curlUsage = (org, cookie) => {
   try {
-    const out = execFileSync4("curl", usageCurlArgs(), {
+    const out = execFileSync5("curl", usageCurlArgs(), {
       input: usageCurlConfig(org, cookie),
       encoding: "utf8",
       maxBuffer: 8000000
@@ -23766,16 +24168,16 @@ function install(home, argv, source, log) {
   }
   writeFileSync25(path, launchAgentPlist(bun, script, home, source), { mode: 384 });
   try {
-    execFileSync4("launchctl", ["unload", path], { stdio: "ignore" });
+    execFileSync5("launchctl", ["unload", path], { stdio: "ignore" });
   } catch {}
-  execFileSync4("launchctl", ["load", "-w", path]);
+  execFileSync5("launchctl", ["load", "-w", path]);
   log(`seat-sync timer installed (every ${SYNC_INTERVAL_S / 60} min) → ${path}`);
   return 0;
 }
 function uninstall(home, source, log) {
   const path = plistPath2(home, source);
   try {
-    execFileSync4("launchctl", ["unload", "-w", path], { stdio: "ignore" });
+    execFileSync5("launchctl", ["unload", "-w", path], { stdio: "ignore" });
   } catch {}
   rmSync16(seatTokenPath(home, source), { force: true });
   log(existsSync26(path) ? `seat-sync timer removed (${path} can be deleted)` : "no seat-sync timer");
@@ -24647,7 +25049,7 @@ var verify = async (o) => {
 };
 
 // src/commands/webhooks.ts
-var USAGE2 = "usage: sleds webhooks [--json]   |   sleds webhooks deliveries <id or name> [--json]";
+var USAGE3 = "usage: sleds webhooks [--json]   |   sleds webhooks deliveries <id or name> [--json]";
 var str14 = (x) => typeof x === "string" ? x : "";
 function ago3(at, now) {
   const m = Math.max(0, Math.floor((now - at) / 60000));
@@ -24698,7 +25100,7 @@ var webhooksCmd = async (o) => {
   const now = (o.now ?? Date.now)();
   const sub = words[0];
   if (sub && (sub !== "deliveries" || words.length !== 2)) {
-    error(USAGE2);
+    error(USAGE3);
     return 2;
   }
   const path = sub === "deliveries" ? `/proxy/webhooks/deliveries?hook=${encodeURIComponent(words[1] ?? "")}` : "/proxy/webhooks";
@@ -24958,7 +25360,7 @@ var isSledsStopHook2 = isSledsHookFor2("stop-event");
 var isSledsPermissionHook2 = isSledsHookFor2("permission-event");
 
 // src/index.ts
-var USAGE3 = `usage: sleds <command> [options]
+var USAGE4 = `usage: sleds <command> [options]
 
 commands:
   init        Sign in through the browser, make this machine a seat, install the /sled skill
@@ -25013,6 +25415,10 @@ commands:
               --run                  start Claude Code with the pack as the first prompt
   webhooks    The org's outbound webhooks (admins); deliveries <id or name> lists one hook's
               last hundred deliveries. Registering and Redeliver stay in the app.
+  deploy      A release step's one line: tell SLEDS this commit is now running in an environment.
+              --env <slug>           the environment (required); --service <name> for a monorepo
+              --sha / --repo         else the CI's own variables, then git
+              Token from SLEDS_DEPLOY_TOKEN (Settings \u203A Deploys). SLEDS down never fails a release.
   sled --json What is on your sled (mine with each route, proposed, sent), for a front end.
               sleds sled top KEY     put KEY first on your sled; the engine picks it next
   route <key> Print an item's route: its nodes, what each waits on, what is ready, where each
@@ -25040,6 +25446,9 @@ commands:
               --mode <permission-mode>  Claude Code's (default auto; acceptEdits stops an unattended
                                      session at git push; an account without auto passes acceptEdits)
               --model <id>           Claude Code's model
+  reopen <key> Put back an item that landed by mistake (a skipped node closed its route): its
+              landing is cleared and it goes back on the sled it came off, or to ready.
+              --reason "<text>"      why \u2014 required; it goes on the item's thread (--json)
   engine      The long-running loop over the routes Run armed on your sled: takes each ready
               node, starts a session on its own branch, follows its PR to the merge (CI failures
               and review feedback go back to the session; a merge lands the node, closes the
@@ -25161,11 +25570,11 @@ var wantsHelp = (argv) => {
   return false;
 };
 var commandUsage = (cmd) => {
-  const lines = USAGE3.split(`
+  const lines = USAGE4.split(`
 `);
   const start = lines.findIndex((l) => l === `  ${cmd}` || l.startsWith(`  ${cmd} `));
   if (start === -1)
-    return USAGE3;
+    return USAGE4;
   const section = [lines[start]];
   for (const l of lines.slice(start + 1)) {
     if (!/^ {3,}\S/.test(l))
@@ -25221,8 +25630,12 @@ var main = async (argv) => {
       return packCmd({ home, argv: argv.slice(1) });
     case "webhooks":
       return webhooksCmd({ home, argv: argv.slice(1) });
+    case "deploy":
+      return deployCmd({ argv: argv.slice(1) });
     case "sled":
       return sledCmd({ home, argv: argv.slice(1) });
+    case "reopen":
+      return reopenCmd({ home, argv: argv.slice(1) });
     case "engine":
     case "route": {
       if (cmd === "engine" && argv[1] === "status")
@@ -25415,19 +25828,19 @@ var main = async (argv) => {
     case "help":
     case "--help":
     case "-h":
-      console.log(USAGE3);
+      console.log(USAGE4);
       console.log(`
 ${renderHelpText(argv[1])}`);
       return 0;
     case "version":
     case "--version":
     case "-v":
-      console.log("sleds 0.1.44");
+      console.log("sleds 0.1.46");
       return 0;
     default:
       console.error(`unknown command: ${cmd}
 `);
-      console.error(USAGE3);
+      console.error(USAGE4);
       return 1;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleds/cli",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "SLEDS CLI — the cost and limits of AI agent work, decided at the wall. Point Claude Code at a SLEDS proxy; estimate before you run; hold, switch model, or run overnight when you hit a limit.",
   "license": "UNLICENSED",
   "type": "module",