@sleds/cli 0.1.51 → 0.1.52

package/dist/sleds.mjs

@@ -5689,11 +5689,20 @@ var init_copy = __esm(() => {
 });
 
 // ../../packages/shared/src/slack/agent.ts
+var REPLY_RULES;
 var init_agent = __esm(() => {
   init_intake();
   init_brief();
   init_copy();
   init_mention();
+  REPLY_RULES = [
+    "How to answer this reply:",
+    '- If it answers nothing and changes nothing — thanks, "noted", "copy", "will do", or people talking to each other — set quiet to true and post nothing.',
+    "- Never ask a question the thread already asked. If it is still open, say only what is still needed, once, in a few words.",
+    "- If someone in the thread already gave the cause or a fix, do not ask the poster for details it makes moot. Say in one line what is left, or set quiet.",
+    "- Keep it to what changed and what is next. No recap of the ask."
+  ].join(`
+`);
 });
 
 // ../../packages/shared/src/slack/channel.ts
@@ -8545,7 +8554,13 @@ function parseParked(v) {
         ...typeof a.effort === "string" ? { effort: a.effort } : {}
       };
   }
-  return { question: v.question, at: v.at, ...answerer ? { answerer } : {} };
+  return {
+    question: v.question,
+    at: v.at,
+    ...typeof v.screen === "string" ? { screen: v.screen } : {},
+    ...v.still === true ? { still: true } : {},
+    ...answerer ? { answerer } : {}
+  };
 }
 function parseRun(v) {
   if (!isObject8(v))
@@ -8585,7 +8600,10 @@ function parseRun(v) {
         decisionId: v.permission.decisionId,
         options: Array.isArray(v.permission.options) ? v.permission.options.filter((x) => typeof x === "string") : [],
         at: v.permission.at,
-        ...v.permission.onScreen === true ? { onScreen: true } : {}
+        ...v.permission.onScreen === true ? { onScreen: true } : {},
+        ...typeof v.permission.pressedAt === "number" ? { pressedAt: v.permission.pressedAt } : {},
+        ...typeof v.permission.presses === "number" ? { presses: v.permission.presses } : {},
+        ...v.permission.gaveUp === true ? { gaveUp: true } : {}
       }
     } : {},
     ...isObject8(v.provider) && typeof v.provider.why === "string" && typeof v.provider.since === "number" && typeof v.provider.tries === "number" ? { provider: { why: v.provider.why, since: v.provider.since, tries: v.provider.tries } } : {},
@@ -11243,6 +11261,8 @@ var orcaLauncher = (o) => `#!/bin/sh
 ${execLine(agentShellCommand(o))}
 `;
 var orcaCommand = (launcher) => `sh ${shq2(launcher)}; exit`;
+var orcaRequestId = (env, text) => str8(obj(obj(env?.error)?.data)?.orchestrationRequestId) ?? text.match(/--retry-request ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i)?.[1] ?? null;
+var ESC = "\x1B";
 var GONE = /exit|clos|gone|dead|stopp|kill/i;
 var orcaTerminalLive = (status, stdout) => {
   const env = parseOrcaJson(stdout);
@@ -11327,6 +11347,7 @@ function orcaRunner(exec, deps = {}) {
     }
     return env;
   };
+  const retries = new Map;
   return {
     name: "orca",
     makesWorktree: true,
@@ -11378,10 +11399,51 @@ function orcaRunner(exec, deps = {}) {
       return r.status === 0 ? r.stdout : "";
     },
     send(h, text) {
-      const r = exec("orca", ["terminal", "send", "--terminal", h.id, "--text", text, "--enter"]);
-      if (r.status !== 0) {
-        throw new Error(`orca terminal send ${h.id} failed: ${r.stderr.trim() || `exit ${r.status}`}`);
+      const key = `${h.id}
+${text}`;
+      const attempt = (retry) => {
+        const r = exec("orca", [
+          "terminal",
+          "send",
+          "--terminal",
+          h.id,
+          "--text",
+          text,
+          "--enter",
+          ...retry ? ["--retry-request", retry] : [],
+          "--json"
+        ]);
+        const env = parseOrcaJson(r.stdout);
+        const ok = r.status === 0 && env?.ok !== false;
+        return { r, env, ok, id: ok ? null : orcaRequestId(env, `${r.stderr}
+${r.stdout}`) };
+      };
+      const prior = retries.get(key);
+      let a = attempt(prior);
+      if (!a.ok && a.id && a.id !== prior)
+        a = attempt(a.id);
+      if (a.ok) {
+        retries.delete(key);
+        return;
       }
+      if (a.id)
+        retries.set(key, a.id);
+      else
+        retries.delete(key);
+      const why = orcaError(a.env) ?? (a.r.stderr.trim() || `exit ${a.r.status}`);
+      throw new Error(`orca terminal send ${h.id} failed: ${why}`);
+    },
+    sendKey(h, key) {
+      if (!isRunnerKey(key))
+        throw new Error(`orca terminal send ${h.id}: no key ${JSON.stringify(key)}`);
+      const what = `orca terminal send ${h.id} (key ${key})`;
+      const send = (args) => orca(["terminal", "send", "--terminal", h.id, ...args, "--json"], what);
+      if (key === "esc") {
+        send(["--text", ESC]);
+        return;
+      }
+      send(["--text", key]);
+      send(["--enter"]);
     },
     stop(h) {
       exec("orca", ["terminal", "close", "--terminal", h.id]);
@@ -11449,7 +11511,7 @@ function beatBody(state, flags, host = {}, cap = {}) {
     name: flags.name,
     os: host.os ?? process.platform,
     runner: flags.runner,
-    version: host.version ?? "0.1.51" ?? "dev",
+    version: host.version ?? "0.1.52" ?? "dev",
     running: live.length,
     items: live.slice(0, BEAT_ITEMS).map((r) => `${r.item}/${r.node}`),
     ...cap.atOnce !== undefined ? { atOnce: cap.atOnce } : {},
@@ -12454,6 +12516,10 @@ function permissionsOf(s) {
   const p = s;
   return p && typeof p.openPermission === "function" && typeof p.clearPermission === "function" && typeof p.decisionOf === "function" ? s : null;
 }
+function resumesOf(s) {
+  const r = s;
+  return r && typeof r.resumeParked === "function" ? s : null;
+}
 var FAIL_LOG_MAX = 2000;
 var UNREACHABLE3 = "SLEDS unreachable";
 function keysIn(states, state) {
@@ -12638,6 +12704,9 @@ function profileOf(r) {
   const atOnce = num5(p.atOnce);
   if (atOnce !== undefined && atOnce >= 1)
     out.atOnce = Math.round(atOnce);
+  const seatAtOnce = num5(r.seatAtOnce);
+  if (seatAtOnce !== undefined && Number.isInteger(seatAtOnce) && seatAtOnce >= 1)
+    out.seatAtOnce = seatAtOnce;
   if (typeof p.mcpStrict === "boolean")
     out.mcpStrict = p.mcpStrict;
   const holdCpu = num5(p.holdCpu);
@@ -13100,6 +13169,18 @@ function sledsSource(client, o) {
         throw new Error(serverMessage(r));
       return r.json.cleared === true;
     },
+    async resumeParked(runId, why, engine, leaseMin) {
+      const r = await client.postFull("/proxy/run", { runId, engine, leaseMin, resumed: { why } });
+      if (!r)
+        throw new Error(`${UNREACHABLE3} — the resume not recorded`);
+      if (r.status >= 300 || !r.json || r.json.ok === false)
+        throw new Error(serverMessage(r));
+      const leaseUntil = typeof r.json.leaseUntil === "number" ? r.json.leaseUntil : undefined;
+      return {
+        resumed: r.json.resumed === true,
+        ...leaseUntil !== undefined ? { leaseUntil } : {}
+      };
+    },
     async decisionOf(item, decisionId) {
       const route = await routeOf(item);
       const decisions = Array.isArray(route?.decisions) ? route.decisions.filter(isObject8) : [];
@@ -13692,6 +13773,7 @@ async function tick(deps) {
       deps.providerHold = d.providerHold;
       deps.draining = d.draining;
       deps.atOnce = d.atOnce;
+      deps.seatAtOnceNoted = d.seatAtOnceNoted;
       deps.runner = d.runner;
       deps.runnerRefused = d.runnerRefused;
     }
@@ -13763,6 +13845,10 @@ async function tickOnce(d) {
       try {
         open = runner.status(run.handle) === "running";
       } catch {}
+      if (open && await answeredInSession(d, runner, run)) {
+        keep.push(run);
+        continue;
+      }
       if (open || liveAnswerer(run))
         keep.push(run);
       else
@@ -14287,7 +14373,20 @@ async function settlePermission(d, runner, run, shown) {
   const dialog = runner.readsSession ? permissionDialog(shown) : null;
   const p = run.permission;
   if (p) {
-    const gone = runner.readsSession && (p.onScreen ? !dialog : (run.seenAt ?? 0) > p.at);
+    const gone = runner.readsSession && (p.onScreen ? !dialog : (run.seenAt ?? 0) > (p.pressedAt ?? p.at));
+    const answered = () => {
+      run.permission = undefined;
+      run.answeredAt = d.now();
+      if (markFile)
+        clearPermissionMark(markFile);
+    };
+    if (p.gaveUp) {
+      if (!gone)
+        return true;
+      d.log(`${at}: the permission dialog was answered in the terminal`);
+      answered();
+      return false;
+    }
     let now;
     try {
       now = await perms.decisionOf(run.item, p.decisionId);
@@ -14296,14 +14395,42 @@ async function settlePermission(d, runner, run, shown) {
       return true;
     }
     if (now?.state === "answered" && now.answer) {
-      if (gone)
-        d.log(`${at}: the permission was answered after its dialog closed — not pressed`);
-      else if (!pressAnswer(d, runner, run, p.options, now.answer))
+      if (p.pressedAt === undefined) {
+        if (gone)
+          d.log(`${at}: the permission was answered after its dialog closed — not pressed`);
+        else {
+          const pressed = pressAnswer(d, runner, run, p.options, now.answer);
+          if (!pressed)
+            return true;
+          if (pressed === "key") {
+            run.permission = { ...p, pressedAt: d.now(), presses: 1 };
+            return true;
+          }
+        }
+        answered();
         return true;
-      run.permission = undefined;
-      run.answeredAt = d.now();
-      if (markFile)
-        clearPermissionMark(markFile);
+      }
+      const key = permissionKey(now.answer) ?? now.answer;
+      if (gone) {
+        d.log(`${at}: the permission is answered — pressed ${key}; the session goes on`);
+        answered();
+        return false;
+      }
+      const presses = p.presses ?? 1;
+      if (presses >= PRESS_TRIES) {
+        const why = `pressed ${key} ${presses} times; the dialog stayed — answer it in the terminal`;
+        try {
+          await perms.clearPermission(run.runId, why, d.engine);
+        } catch (e) {
+          d.log(`${at}: could not clear the permission, trying next tick: ${message(e)}`);
+          return true;
+        }
+        d.log(`${at}: ${why}`);
+        run.permission = { ...p, gaveUp: true };
+        return true;
+      }
+      if (pressAnswer(d, runner, run, p.options, now.answer) === "key")
+        run.permission = { ...p, pressedAt: d.now(), presses: presses + 1 };
       return true;
     }
     if (now?.state !== "open" && now?.state !== "escalated") {
@@ -14353,6 +14480,7 @@ async function settlePermission(d, runner, run, shown) {
   d.log(`${at}: stopped at a permission dialog — it waits for a person (${runner.watchHint(run.handle)})`);
   return true;
 }
+var PRESS_TRIES = 3;
 function pressAnswer(d, runner, run, options, answer) {
   const at = ref(run);
   const key = permissionKey(answer);
@@ -14363,13 +14491,15 @@ function pressAnswer(d, runner, run, options, answer) {
         runner.sendKey(run.handle, key);
       else
         runner.send(run.handle, key);
+      if (runner.readsSession)
+        return "key";
       d.log(`${at}: the permission is answered — pressed ${key}; the session goes on`);
     } else {
       runner.sendKey?.(run.handle, "esc");
       const note = runner.send(run.handle, answer);
       d.log(`${at}: the permission is answered in words — Esc, then typed in${note ? ` (${note})` : ""}`);
     }
-    return true;
+    return "done";
   } catch (e) {
     d.log(`${at}: could not press the permission's answer, trying next tick: ${message(e)}`);
     return false;
@@ -14538,10 +14668,25 @@ async function rereadAtOnce(d) {
   try {
     next = await d.rereadAtOnce(profileOf2(d));
   } catch {}
-  if (next === null || next === d.atOnce)
+  if (next !== null && next !== d.atOnce) {
+    d.atOnce = next;
+    d.log(`at once now ${next}, from your engine profile`);
+  }
+  await sayAtOnceDisagrees(d);
+}
+async function sayAtOnceDisagrees(d) {
+  const seat = (await profileOf2(d)())?.seatAtOnce;
+  if (seat === undefined)
+    return;
+  if (seat === d.atOnce) {
+    d.seatAtOnceNoted = undefined;
     return;
-  d.atOnce = next;
-  d.log(`at once now ${next}, from your engine profile`);
+  }
+  const pair = `${d.atOnce}/${seat}`;
+  if (d.seatAtOnceNoted === pair)
+    return;
+  d.seatAtOnceNoted = pair;
+  d.log(seat < d.atOnce ? `at once ${d.atOnce} on the engine, but this seat allows ${seat} — the server refuses a claim past ${seat} on it; set it in Settings` : `at once ${d.atOnce} on the engine, but this seat allows ${seat} — the engine takes only ${d.atOnce}; set it in Settings`);
 }
 async function rereadRunner(d) {
   if (!d.rereadRunner)
@@ -14595,10 +14740,53 @@ function stopOpen(d, run, runner) {
   }
 }
 function holdParked(d, runner, run, question) {
-  run.parked = { question, at: d.now() };
+  run.parked = { question, at: d.now(), ...run.seen ? { screen: run.seen } : {} };
   run.leaseUntil = undefined;
   setLane(d, runner, run.handle, "parked");
 }
+async function answeredInSession(d, runner, run) {
+  const parked = run.parked;
+  const resumes = resumesOf(d.source);
+  if (!resumes || !runner.readsSession || !run.runId)
+    return false;
+  let print;
+  try {
+    print = fingerprint(runner.read(run.handle));
+  } catch {
+    return false;
+  }
+  if (print === parked.screen) {
+    parked.still = true;
+    return false;
+  }
+  const moved = parked.still === true;
+  parked.screen = print;
+  parked.still = false;
+  if (!moved)
+    return false;
+  let r;
+  try {
+    r = await resumes.resumeParked(run.runId, "answered in the session", d.engine, d.leaseMin);
+  } catch (e) {
+    d.log(`${ref(run)}: the parked session moved on, but SLEDS did not hear it: ${message(e)}`);
+    return false;
+  }
+  if (!r.resumed) {
+    d.log(`${ref(run)}: the parked session moved on, but the node is no longer parked on its run`);
+    return false;
+  }
+  stopAnswerer(d, run);
+  const now = d.now();
+  run.parked = undefined;
+  run.seen = print;
+  run.seenAt = now;
+  run.seenTicks = 0;
+  run.answeredAt = now;
+  run.leaseUntil = r.leaseUntil ?? now + d.leaseMin * 60000;
+  setLane(d, runner, run.handle, "working");
+  d.log(`${ref(run)}: answered in the session — out of Needs you, running again`);
+  return true;
+}
 function setLane(d, runner, h, lane) {
   try {
     runner.lane?.(h, lane);
@@ -17174,7 +17362,7 @@ async function fetchVersion(o) {
   const platform = o.platform ?? process.platform;
   const arch = o.arch ?? process.arch;
   const publicKey = o.publicKey ?? RELEASE_PUBLIC_KEY;
-  const running = o.running ?? "0.1.51";
+  const running = o.running ?? "0.1.52";
   if (!publicKey)
     return { ok: false, why: "no release key yet" };
   if (!VERSION_RE2.test(o.version))
@@ -18758,7 +18946,7 @@ function engineClient(o, org) {
     return fetchClient({
       ...src,
       timeoutMs: ENGINE_TIMEOUT_MS,
-      version: "0.1.51"
+      version: "0.1.52"
     });
   const asked = org?.trim() || env.SLEDS_ORG?.trim();
   if (asked && !selectOrg(readConfig(o.home), org, env).seat)
@@ -19049,7 +19237,7 @@ async function driveEngine(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.51"
+    cliVersion: "0.1.52"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -20906,7 +21094,7 @@ function engineClient2(o, org) {
     return fetchClient({
       ...src,
       timeoutMs: ENGINE_TIMEOUT_MS2,
-      version: "0.1.51"
+      version: "0.1.52"
     });
   const asked = org?.trim() || env.SLEDS_ORG?.trim();
   if (asked && !selectOrg(readConfig(o.home), org, env).seat)
@@ -21232,7 +21420,7 @@ async function driveEngine2(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.51"
+    cliVersion: "0.1.52"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -23320,7 +23508,7 @@ function contextFor(deps) {
     ...src,
     fetchFn: deps.fetchFn,
     timeoutMs: deps.timeoutMs,
-    version: "0.1.51"
+    version: "0.1.52"
   }), deps.home, now) : null;
   return {
     channel: "code",
@@ -25834,14 +26022,16 @@ function routeReader(o, org) {
     read: (k) => readOrSay(client, `/proxy/route?q=${encodeURIComponent(k)}`, k)
   };
 }
-var SLED_USAGE = "usage: sleds sled --json | sleds sled top <KEY> | sleds sled order <KEY>…";
+var SLED_USAGE = "usage: sleds sled --json | sleds sled top <KEY> | sleds sled order <KEY>… | sleds sled off <KEY> [--json]";
 async function sledCmd(o) {
   const log = o.log ?? console.log;
   const error = o.error ?? console.error;
   const top = o.argv[0] === "top" && o.argv.length === 2 && !o.argv[1]?.startsWith("-");
   const keys = o.argv.slice(1);
   const order = o.argv[0] === "order" && keys.length > 0 && keys.every((k) => k.trim() && !k.startsWith("-"));
-  if (!top && !order && (o.argv.length !== 1 || o.argv[0] !== "--json")) {
+  const offArgs = o.argv.slice(1).filter((a) => a !== "--json");
+  const off = o.argv[0] === "off" && offArgs.length === 1 && o.argv.length <= 3 && !!offArgs[0]?.trim() && !offArgs[0].startsWith("-");
+  if (!top && !order && !off && (o.argv.length !== 1 || o.argv[0] !== "--json")) {
     error(SLED_USAGE);
     return 2;
   }
@@ -25854,6 +26044,8 @@ async function sledCmd(o) {
     return sledTop(client, o.argv[1], log, error);
   if (order)
     return sledOrder(client, keys, log, error);
+  if (off)
+    return sledOff(client, offArgs[0], o.argv.includes("--json"), log, error);
   try {
     log(JSON.stringify(await readOrSay(client, "/proxy/sled", "the sled")));
     return 0;
@@ -25888,6 +26080,31 @@ async function sledOrder(client, keys, log, error) {
   log(`${typeof r.json?.ordered === "number" ? r.json.ordered : keys.length} ordered on your sled`);
   return 0;
 }
+async function sledOff(client, key, json, log, error) {
+  const r = await client.postFull("/proxy/sled/off", { project: key });
+  if (!r) {
+    error(`${key}: SLEDS unreachable — the sled is unchanged`);
+    return 1;
+  }
+  if (r.status >= 300 || r.json?.ok === false) {
+    error(typeof r.json?.error === "string" ? r.json.error : `${key}: HTTP ${r.status}`);
+    return 1;
+  }
+  if (json) {
+    log(JSON.stringify(r.json));
+    return 0;
+  }
+  const k = typeof r.json?.key === "string" ? r.json.key : key;
+  if (r.json?.changed === false) {
+    log(`${k} was not on a sled`);
+    return 0;
+  }
+  log(`${k} is off your sled — back in the pool`);
+  const running = typeof r.json?.running === "number" ? r.json.running : 0;
+  if (running > 0)
+    log(`${running} running node${running === 1 ? "" : "s"} stopped`);
+  return 0;
+}
 
 // src/commands/run.ts
 init_config();
@@ -27406,7 +27623,7 @@ var realPidAlive4 = (pid) => {
 };
 function machineClient(home, env) {
   const src = meterSource(home, undefined, { env });
-  return src ? fetchClient({ ...src, version: "0.1.51" }) : null;
+  return src ? fetchClient({ ...src, version: "0.1.52" }) : null;
 }
 async function noteAnswer2(home, a, now) {
   try {
@@ -28026,6 +28243,7 @@ commands:
   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
               sleds sled order KEY\u2026  those items in this order, in the places they hold; the rest stay
+              sleds sled off KEY     take KEY off your sled, back in the pool; its running nodes stop
   route <key> Print an item's route: its nodes, what each waits on, what is ready, where each
               run can be watched.
               --dot                  Graphviz instead: \`sleds route QW-142 --dot | dot -Tpng -o route.png\`
@@ -28251,7 +28469,7 @@ var main = async (argv) => {
     now: Date.now(),
     stderr: (line) => console.error(line),
     isTTY: !!process.stderr.isTTY,
-    version: "0.1.51"
+    version: "0.1.52"
   });
   switch (cmd) {
     case "update":
@@ -28484,7 +28702,7 @@ ${renderHelpText(argv[1])}`);
     case "version":
     case "--version":
     case "-v":
-      console.log("sleds 0.1.51");
+      console.log("sleds 0.1.52");
       return 0;
     default:
       console.error(`unknown command: ${cmd}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleds/cli",
-  "version": "0.1.51",
+  "version": "0.1.52",
   "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",