@sleds/cli 0.1.34 → 0.1.35

package/dist/sleds.mjs

@@ -3285,6 +3285,12 @@ ${draft ? str5(draft.pack) ?? "" : ""}`,
     }
   };
 }
+function forPersonOf(v) {
+  const rel = isObject4(v) && isObject4(v.relation) ? v.relation : null;
+  const key = str5(rel?.key)?.trim();
+  const how = str5(rel?.how);
+  return key && how && RELATION_HOWS.includes(how) ? { forPerson: { relation: { key, how } } } : {};
+}
 async function runTool(ctx, args) {
   if (!ctx.client)
     return NOT_SET_UP;
@@ -3316,7 +3322,8 @@ async function runTool(ctx, args) {
     why: str5(e.why),
     ...str5(e.suggested) ? { suggested: str5(e.suggested) } : {},
     ...strList(e.cites) ? { cites: strList(e.cites) } : {},
-    ...typeof e.irreversible === "boolean" ? { irreversible: e.irreversible } : {}
+    ...typeof e.irreversible === "boolean" ? { irreversible: e.irreversible } : {},
+    ...forPersonOf(e.forPerson)
   } : null;
   const res = await postSaying(ctx, "/proxy/run", {
     runId,
@@ -4242,7 +4249,7 @@ async function handleLine(line, ctx) {
       return isNotification ? null : errorResponse(id, -32601, `method not found: ${method}`);
   }
 }
-var PROTOCOL_VERSION = "2025-06-18", SERVER_INFO, SERVER_INSTRUCTIONS, MCP_TIMEOUT_MS = 5000, sourceSchema, specSchema, TOOLS, VIEW_TOOLS, NOT_SET_UP, UNREACHABLE, isObject4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v), num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined, str5 = (v) => typeof v === "string" ? v : undefined, errorMessage = (j) => isObject4(j?.error) ? str5(j.error.message) : str5(j?.error), proposalText = (t) => (t ?? "").replace(/\n*Nothing runs until a person says yes:[^\n]*$/, ""), PROPOSED_NEXT = (key) => `Nothing runs until a person approves it: Approve in the SLEDS app or on the item page, or \`sleds route approve ${key}\`. If you are a drafting session, stop here.`, strList = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : undefined, UI_RESOURCES, response = (id, result) => JSON.stringify({ jsonrpc: "2.0", id, result }), errorResponse = (id, code, message) => JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+var PROTOCOL_VERSION = "2025-06-18", SERVER_INFO, SERVER_INSTRUCTIONS, MCP_TIMEOUT_MS = 5000, sourceSchema, specSchema, TOOLS, VIEW_TOOLS, NOT_SET_UP, UNREACHABLE, isObject4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v), num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined, str5 = (v) => typeof v === "string" ? v : undefined, errorMessage = (j) => isObject4(j?.error) ? str5(j.error.message) : str5(j?.error), proposalText = (t) => (t ?? "").replace(/\n*Nothing runs until a person says yes:[^\n]*$/, ""), PROPOSED_NEXT = (key) => `Nothing runs until a person approves it: Approve in the SLEDS app or on the item page, or \`sleds route approve ${key}\`. If you are a drafting session, stop here.`, strList = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : undefined, RELATION_HOWS, UI_RESOURCES, response = (id, result) => JSON.stringify({ jsonrpc: "2.0", id, result }), errorResponse = (id, code, message) => JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
 var init_server = __esm(() => {
   init_worth();
   init_intake();
@@ -4609,7 +4616,7 @@ var init_server = __esm(() => {
     },
     {
       name: "run",
-      description: "An engine's word on a run it holds (spec 26): with nothing but `runId`, a heartbeat that renews the lease (every few minutes while the session runs; a lapsed lease returns the node to ready). `park: {question}` when the session needs a person — the node parks with the question, the seat is free, the engine takes the next node. `fail: {log}` when the session exited without a PR — back to ready once, parked the second time. `watch` updates where to watch it. On a decider's (answerer's) run: `answer: {md, cites}` when the record settles the question, `release: {why, waitsOn, cites}` when the record says the node must wait on other items (its session stops, the node goes back to ready without a seat, and it is not taken again until those land), `escalate: {why, suggested?}` when it does not — SLEDS may refuse an answer and escalate it, and says why. When the PR opens: `actual` (or `land`) with `node` and state `pr`; the merge lands the node from the PR body's `SLEDS-Node:` line.",
+      description: "An engine's word on a run it holds (spec 26): with nothing but `runId`, a heartbeat that renews the lease (every few minutes while the session runs; a lapsed lease returns the node to ready). `park: {question}` when the session needs a person — the node parks with the question, the seat is free, the engine takes the next node. `fail: {log}` when the session exited without a PR — back to ready once, parked the second time. `watch` updates where to watch it. On a decider's (answerer's) run: `answer: {md, cites}` when the record settles the question, `release: {why, waitsOn, cites}` when the record says the node must wait on other items (its session stops, the node goes back to ready without a seat, and it is not taken again until those land), `escalate: {why, suggested?, forPerson?}` when it does not — `forPerson: {relation: {key, how}}` when the fix is a relation only a person can set (`blockedBy SL-1474`), which the person's card then sets in one press — SLEDS may refuse an answer and escalate it, and says why. When the PR opens: `actual` (or `land`) with `node` and state `pr`; the merge lands the node from the PR body's `SLEDS-Node:` line.",
       inputSchema: {
         type: "object",
         properties: {
@@ -4669,7 +4676,26 @@ var init_server = __esm(() => {
               why: { type: "string", description: "One line for the person." },
               suggested: { type: "string", description: "Your best answer, when you have one." },
               cites: { type: "array", items: { type: "string" } },
-              irreversible: { type: "boolean" }
+              irreversible: { type: "boolean" },
+              forPerson: {
+                type: "object",
+                description: "SL-1499: what only a person can set, for their card's one press — a relation on the item. Put it here, not in `suggested`: the session cannot set it.",
+                properties: {
+                  relation: {
+                    type: "object",
+                    properties: {
+                      key: { type: "string", description: "The other item's key (SL-1474)." },
+                      how: {
+                        type: "string",
+                        enum: ["blockedBy", "blocks", "relates", "duplicates"],
+                        description: "How this item stands to it: blockedBy when it waits on it."
+                      }
+                    },
+                    required: ["key", "how"]
+                  }
+                },
+                required: ["relation"]
+              }
             },
             required: ["why"]
           },
@@ -5176,6 +5202,7 @@ var init_server = __esm(() => {
     text: "Control plane unreachable. Nothing was recorded → try again in a moment.",
     isError: true
   };
+  RELATION_HOWS = ["blockedBy", "blocks", "relates", "duplicates"];
   UI_RESOURCES = [
     {
       uri: INTAKE_VIEW_URI,
@@ -10300,7 +10327,7 @@ function beatBody(state, flags, host = {}) {
     name: flags.name,
     os: host.os ?? process.platform,
     runner: flags.runner,
-    version: host.version ?? "0.1.34" ?? "dev",
+    version: host.version ?? "0.1.35" ?? "dev",
     running: live.length,
     items: live.slice(0, BEAT_ITEMS).map((r) => `${r.item}/${r.node}`)
   };
@@ -11147,6 +11174,7 @@ function answerPrompt(o) {
     `- Settled by the record: the SLEDS \`${run}\` tool with \`{runId: "${c.runId}", answer: {md, cites}}\` — \`md\` is the answer as you would tell the session, \`cites\` the list of pointers.`,
     `- The record says node ${c.node} must wait for another item to land ("build nothing until #123 merges") and that item is on the board: \`${run}\` with \`{runId: "${c.runId}", release: {why, waitsOn, cites}}\` — \`waitsOn\` the keys of the items it waits on (\`SL-123\`). It frees the seat: node ${c.node}'s session is closed, and the node is retaken fresh once they land. Release rather than answer "stay parked", which only parks it again.`,
     `- Not settled, irreversible, or unsure: \`${run}\` with \`{runId: "${c.runId}", escalate: {why, suggested?, cites?, irreversible?}}\` — \`why\` in one line for the person (with any action only a person can take), \`suggested\` your best answer as the session would be told it, when you have one. Mark \`irreversible: true\` when it is, even if the session did not.`,
+    `- When the fix is a relation on the item only a person can set (node ${c.node} looks like it waits on SL-1474, but the record does not settle it, so it is not a release), escalate with \`forPerson: {relation: {key, how}}\` — \`{key: "SL-1474", how: "blockedBy"}\` — so the person's card sets it in one press. Never tell the session to set it: a session cannot set relations.`,
     ...VERDICT_SHAPE,
     "- Read what the tool answers: an answer can come back `escalated` with `refused` (irreversible, no cites, or the autonomy is ask). That is SLEDS's call, not a failure; do not post again.",
     "- Once the verdict is posted, stop. The engine ends this session; the node's session picks up from the answer."
@@ -21285,13 +21313,13 @@ init_src();
 import { readFileSync as readFileSync24 } 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 | --overrule --stdin   |   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 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   |   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]";
 var REDRAFT_USAGE = "usage: sleds route redraft <key> [--json]";
 var SINGLE_USAGE = "usage: sleds route single <key> [--json]";
-var DECISION_USAGE = "usage: sleds route decision <key> <id> --seen   |   sleds route decision <key> <id> (--answer | --overrule) (<answer…> | --stdin)   |   sleds route decision <key> <id> [--answer (<answer…> | --stdin)] --route accept|keep|redraft   |   sleds route decision <key> <id> --keep-route   [--json]";
+var DECISION_USAGE = "usage: sleds route decision <key> <id> --seen   |   sleds route decision <key> <id> (--answer | --overrule) (<answer…> | --stdin)   |   sleds route decision <key> <id> [--answer (<answer…> | --stdin)] --route accept|keep|redraft   |   sleds route decision <key> <id> --keep-route   |   sleds route decision <key> <id> --apply [--answer (<answer…> | --stdin)]   [--json]";
 var ROUTE_VERDICTS = ["accept", "keep", "redraft"];
 function nodesFromJson(text) {
   let parsed;
@@ -21611,6 +21639,14 @@ function answeredLine(key, route, held) {
     return `${key}: route kept as filed — what it held is released`;
   return `${key}: answered — what it held is released`;
 }
+function appliedLine(key, applied) {
+  const a = applied && typeof applied === "object" ? applied : {};
+  const rel = a.relation && typeof a.relation === "object" ? a.relation : {};
+  const what = typeof rel.how === "string" && typeof rel.key === "string" ? `${rel.how} ${rel.key}` : "";
+  if (!what)
+    return `${key}: set and answered`;
+  return a.changed === false ? `${key}: ${what} was already set — answered` : `${key}: set ${what} — answered`;
+}
 async function decisionCmd(o, argv) {
   const log = o.log ?? console.log;
   const error = o.error ?? console.error;
@@ -21620,6 +21656,7 @@ async function decisionCmd(o, argv) {
   const answer = argv.includes("--answer");
   const fromStdin = argv.includes("--stdin");
   const keepRoute = argv.includes("--keep-route");
+  const apply = argv.includes("--apply");
   const at = argv.indexOf("--route");
   const routeArg = at >= 0 ? argv[at + 1] : undefined;
   const words = argv.filter((a, i) => ![
@@ -21629,14 +21666,15 @@ async function decisionCmd(o, argv) {
     "--answer",
     "--stdin",
     "--keep-route",
+    "--apply",
     "--route"
   ].includes(a) && !(at >= 0 && i === at + 1));
   const [key, id, ...rest] = words;
   const badRoute = at >= 0 && !ROUTE_VERDICTS.includes(routeArg) || at >= 0 && keepRoute;
   const route = keepRoute ? "keep" : at >= 0 ? routeArg : undefined;
   const verbs = [seen, overrule, answer].filter(Boolean).length;
-  const routeAlone = Boolean(route) && verbs === 0;
-  if (!key || !id || badRoute || route && (seen || overrule) || !routeAlone && verbs !== 1 || (seen || routeAlone) && (fromStdin || rest.length > 0)) {
+  const routeAlone = (Boolean(route) || apply) && verbs === 0;
+  if (!key || !id || badRoute || (route || apply) && (seen || overrule) || route && apply || !routeAlone && verbs !== 1 || (seen || routeAlone) && (fromStdin || rest.length > 0)) {
     error(DECISION_USAGE);
     return 2;
   }
@@ -21654,13 +21692,14 @@ async function decisionCmd(o, argv) {
     project: key,
     id,
     ...seen ? { seen: true } : answer ? { answer: md } : overrule ? { overrule: md } : {},
-    ...route ? { route } : {}
+    ...route ? { route } : {},
+    ...apply ? { apply: true } : {}
   });
   if (!r) {
     error(`${key}: SLEDS unreachable — nothing marked`);
     return 1;
   }
-  return said(o, key, json, r, () => log(seen ? `${key}: marked seen` : overrule ? `${key}: overruled — your answer stands in the log` : answeredLine(key, r.json?.route ?? route, r.json?.held)));
+  return said(o, key, json, r, () => log(seen ? `${key}: marked seen` : overrule ? `${key}: overruled — your answer stands in the log` : apply ? appliedLine(key, r.json?.applied) : answeredLine(key, r.json?.route ?? route, r.json?.held)));
 }
 var DECISIONS_USAGE = "usage: sleds route decisions [<key>] [--flagged] [--json]";
 function decisionsLines(raw) {
@@ -24108,7 +24147,7 @@ ${renderHelpText(argv[1])}`);
     case "version":
     case "--version":
     case "-v":
-      console.log("sleds 0.1.34");
+      console.log("sleds 0.1.35");
       return 0;
     default:
       console.error(`unknown command: ${cmd}

package/package.json

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