pi-durable-subagents 1.0.24 → 1.0.25

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.0.25
+
+- `restart` refusals show what a fence would cut short: each lease a running
+  call holds, with its mode, how long it has been held, its command and note.
+  Leases held outside those executions (a shell, a `systemd-run` unit) are
+  listed apart, since a restart leaves them held.
+- The waiting/moving check period is configured as `k.waitCheckMs` (was
+  `k.r7Ms` in 1.0.24; the old key is not accepted).
+- README: deduplicate events by `id`, not cursor; a call with no next
+  execution has no `fenced`; an open question keeps the orchestrator from its
+  idle exit (compact the event log now with a non-force `restart`); leases
+  outside calls survive restarts; why a restart cannot hand running
+  executions to the new orchestrator.
+
 ## 1.0.24
 
 - `events --all [--since <cursor>] [--limit <n>]`: one durable log of
@@ -13,7 +27,7 @@
   prune whose events cannot be logged first is rejected (`event-log: …`).
 - `run --labels <json>` (tool: `labels`): caller labels, part of the spec
   digest, returned by `describe` and echoed on every event of the run.
-- Why a call does not move (R7): `describe` adds `reason`, `detail` and
+- Why a call does not move: `describe` adds `reason`, `detail` and
   `since` to each waiting call, and the event log gets `waiting`/`moving`
   when the reason changes: `unconfirmed-stop`, `provider-exhausted`,
   `writer-lock`, `lease`, `slot`, `silent`.

package/README.md

@@ -368,7 +368,8 @@ after recovery, before it waits for a slot) and only when the fence
 interrupted work, exactly as `describe`'s `lastFence`: a turn that had ended,
 a hibernated question, an answer's resume or a seal are no `fenced`. A `once`
 call cut off in a tool is never resumed: it gets `sealed` with status
-`unknown` and no `fenced`.
+`unknown` and no `fenced`. A call with no next execution has no `fenced`; its
+`sealed` carries the outcome (`describe`'s `lastFence` still names the fence).
 
 Cursors are `<epoch>:<seq>`; `--since c` returns the events after `c` in log
 order, at most `--limit` (default and maximum 1000), then
@@ -384,14 +385,16 @@ exists it never starts anything.
 
 Delivery is at least once, without gaps: after a crash the orchestrator
 derives again from its last durable watermark, and an event derived again has
-the same `id` (a new cursor). Deduplicate by `id`, and persist your cursor
-only after you applied the events of a page.
+the same `id` (a new cursor). Deduplicate by `id`, not by cursor (keeping
+ids for the retention window is enough), and persist your cursor only after
+you applied the events of a page.
 
 Retention: an event is dropped only when it was logged more than 7 days ago
-(`"k": { "eventRetentionMs": … }` in `config.json`) and its workflow is
+(`"k": { "eventRetentionMs": … }` in `$DSA_HOME/config.json`) and its workflow is
 finished in its current revision (done, failed or stopped — not parked) with
 no open question and no unsealed call, or was pruned. The log is compacted at
-orchestrator start and at most hourly. A cursor of another epoch (the log was
+orchestrator start and at most hourly; to compact now while a question is open
+(which keeps the orchestrator from idle exit), run `restart` without `--force`. A cursor of another epoch (the log was
 replaced: a corrupt log is kept aside as `events.jsonl.corrupt-<ms>` and a new
 one starts), below the highest dropped seq, or beyond the head gets exit 4
 and one line `{"error":"cursor-expired","head":"…","oldest":"…"}` (`oldest`
@@ -419,7 +422,7 @@ When an unsealed call does not move, its `waiting` in `describe` adds
 probe 1/1`) and `since` (ms: when that cause started). The event log has the
 same: `waiting {reason, detail, since}` when the reason appears or changes,
 `moving {after}` when it clears (also when the call ends), checked every
-`k.r7Ms` (default 5 s; read when the orchestrator starts, unlike the other
+`k.waitCheckMs` (default 5 s; read when the orchestrator starts, unlike the other
 `k` settings a `config.json` change does not apply it until a restart); a
 change of detail alone is no event. The first reason
 that applies wins:
@@ -461,7 +464,7 @@ command:
 ```sh
 pi-durable-subagents hold machine -- make bench          # exclusive
 pi-durable-subagents hold machine --shared -- npm test   # with other shared holders, never with an exclusive one
-pi-durable-subagents hold machine --max-wait 600 --note "frame phase" -- ./measure.sh
+pi-durable-subagents hold machine --max-wait 600 --note "profile" -- ./measure.sh
 ```
 
 - The lease covers one command, not a whole call: a subagent that thinks
@@ -482,6 +485,10 @@ pi-durable-subagents hold machine --max-wait 600 --note "frame phase" -- ./measu
   ended). State is one small file per request under
   `$DSA_HOME/leases/<resource>/`; no orchestrator is needed, and the user's
   own shell can take part.
+- A lease taken outside any call (your shell, a `systemd-run --user` unit)
+  does not depend on the orchestrator: a restart, forced or not, leaves it
+  held, and it is released when its `hold` and command end. A lease taken
+  inside a call ends with that call's processes when the call is fenced.
 - Subagents find the command on their `PATH` (the orchestrator puts a shim
   in `$DSA_HOME/bin`), and their leases are tagged with their call:
   `status` shows `lease: machine held by <wid>/<key> …; waiting: …` and
@@ -565,8 +572,11 @@ On load, it checks the pi exports and API methods it uses.
 Running work stays on the version it started with until you restart the
 orchestrator. When the orchestrator runs another version than the one a pi
 session loaded, that pi says so once, and `status` shows the running version
-with a note. The orchestrator exits about 10 s after all work ends, and the
-next start runs the new version. To switch sooner:
+with a note. The orchestrator exits about 10 s (`k.idleExitMs`) after all
+work ends: every workflow is finished in its current revision (done, failed,
+stopped or parked) or held by `drain`. A workflow with an open question is not
+finished, so a call hibernated on its question keeps the orchestrator running
+(it holds no slot and costs little). The next start runs the new version. To switch sooner:
 
 ```sh
 pi-durable-subagents restart          # or the subagents tool: action "restart"
@@ -574,7 +584,9 @@ pi-durable-subagents restart          # or the subagents tool: action "restart"
 
 The orchestrator refuses while any execution runs (a subagent process, or a
 gate before a call's seal). The refusal groups executions by session with ages,
-lease annotations and a token for that exact set; no new execution starts while
+the leases each one holds (mode, how long, command, note: what a fence would cut
+short) and a token for that exact set. Leases held outside those executions are
+listed apart, since the restart leaves them held; no new execution starts while
 it decides, so nothing slips in between. Calls waiting
 for your answer (hibernated), waiting for a provider slot, or held by a drain
 do not block it. Otherwise it exits and its successor starts at once from the
@@ -600,6 +612,14 @@ boundary — a subagent runs as the same OS user and could signal the
 orchestrator anyway. Force fences running
 executions; they resume on the new version from their sessions, like after a
 crash, so a tool call that was running is repeated or reported as interrupted.
+A running execution cannot be handed over to the new orchestrator: each
+subagent is a pi process the orchestrator drives over its stdin and stdout, and
+those pipes end with the old process. A crash is no different: the successor
+fences every execution that still runs (an execution that had already ended is
+not counted as interrupted). Work that must survive a forced restart, such as a
+long measurement, belongs outside the subagent's processes (for example
+`systemd-run --user … pi-durable-subagents hold machine -- …`), with the
+subagent only watching it.
 The restart ledger records the reason and initiator; after the next start,
 `status` shows who forced it and why for 24 hours.
 

package/dist/agent/main/tool.js

@@ -21,7 +21,7 @@ function call(value, cwd, where) {
     return spec;
 }
 /** v12 §2: Reject unknown explicit call agents before starter or outbox publication; scripts remain call-local. Shared by
- *  the tool and the CLI `run --request` (R2). */
+ *  the tool and the CLI `run --request`. */
 export function checkAgents(body, available) {
     const names = [...(body.call ? [body.call] : []), ...(body.tasks ?? []), ...(body.chain ?? [])].map(call => call.agent);
     if (!names.length)
@@ -85,7 +85,7 @@ export function request(args, cwd) {
             body.args = inputs;
         if (name !== undefined)
             body.name = string(args, "name");
-        // R6: part of the spec digest; an empty object is the same as none.
+        // Part of the spec digest; an empty object is the same as none.
         if (labels !== undefined && Object.keys(checkLabels(labels)).length)
             body.labels = labels;
         // P31a, P36, P11: workflow-level limits and declared input files (absolute paths, pinned at admission).

package/dist/agent/main.js

@@ -297,7 +297,7 @@ export function registerMain(pi, ui) {
         if (args.action === "resume" && args.wid === undefined)
             args = { ...args, origin: sender };
         const normalized = request(args, cwd);
-        // R1: a caller-chosen request id names a run, send or stop; a retry with the same content gets the first outcome.
+        // A caller-chosen request id names a run, send or stop; a retry with the same content gets the first outcome.
         if (args.request !== undefined && (typeof args.request !== "string" || !["run", "send", "stop"].includes(normalized.kind) || normalized.replaces?.length))
             throw new Error(REQUEST_USE);
         const rid = typeof args.request === "string" ? requestRid(args.request) : undefined;

package/dist/cli/control.js

@@ -104,7 +104,7 @@ export async function submit(home, command, target, env = process.env, options =
         return requests;
     });
 }
-/** R1: Submit a request named by a caller-chosen id through the CLI sender: a retry with the same content republishes
+/** Submit a request named by a caller-chosen id through the CLI sender: a retry with the same content republishes
  *  (or reuses) the recorded envelope, other content is a conflict and publishes nothing. Starts the orchestrator
  *  unless the request conflicts. */
 export async function submitIdentified(home, rid, kind, body, cond, env = process.env, starter = startOrchestrator) {

package/dist/cli/main.js

@@ -194,12 +194,12 @@ export async function main(args = process.argv.slice(2), options = {}) {
     }
     if (args[0] === "chaos")
         return (await import("./chaos/index.js")).chaos(args.slice(1), options.env ?? process.env, options.write);
-    // R2: the cross-workflow event log (strict flags of its own); `events <wid>` stays below.
+    // The cross-workflow event log (strict flags of its own); `events <wid>` stays below.
     if (args[0] === "events" && args.includes("--all")) {
         const env = options.env ?? process.env;
         return (await import("../events/cli.js")).eventsAll(args.slice(1), { home: dsaHome(env), env, write: options.write ?? ((line) => console.log(line)), starter: options.starter ?? startOrchestrator, waitMs: options.waitMs });
     }
-    // R1–R3: program-facing commands named by request ids (strict flags of their own).
+    // Program-facing commands named by request ids (strict flags of their own).
     if (["run", "send", "describe"].includes(args[0]) || (args[0] === "stop" && args.includes("--request"))) {
         const env = options.env ?? process.env, requests = await import("./requests.js");
         const ctx = { home: dsaHome(env), env, write: options.write ?? ((line) => console.log(line)), starter: options.starter, waitMs: options.waitMs, cwd: options.cwd, stdin: options.stdin };

package/dist/cli/requests.js

@@ -1,4 +1,4 @@
-// R1–R4: Program-facing commands named by caller-chosen request ids — `run|send|stop --request <id>` and `describe`.
+// Program-facing commands named by caller-chosen request ids — `run|send|stop --request <id>` and `describe`.
 // Exit codes: 0 decided (applied/created), 1 rejected or invalid, 3 request-conflict (the id names other content),
 // 75 not decided within --wait-ms (retry with the same id and content: safe).
 import { existsSync, readFileSync } from "node:fs";
@@ -16,7 +16,7 @@ import { JT } from "../types.js";
 import { startOrchestrator, submitIdentified } from "./control.js";
 import { endedExecs, fenceReason } from "../events/fence.js";
 import { parseLabels } from "../events/labels.js";
-import { foldWaits, leaseWaits, waitsOf } from "../events/r7.js";
+import { foldWaits, leaseWaits, waitsOf } from "../events/waiting.js";
 import { emptyLedger, foldLedger } from "../orchestrator/ledger.js";
 export const EXIT = { ok: 0, rejected: 1, conflict: 3, pending: 75 };
 /** Strict `--name value` / `--flag` parsing; unknown or repeated options are errors. */
@@ -57,7 +57,7 @@ function decision(entries, rid) {
 const createdBy = (entries, rid) => entries.find(e => e.type === JT.created && e.rid === rid);
 async function stdin() { const chunks = []; for await (const chunk of process.stdin)
     chunks.push(chunk); return Buffer.concat(chunks).toString("utf8"); }
-/** R3: The state of a request id (`{request}`) or a workflow (`{wid}`), with full texts (no clipping). */
+/** The state of a request id (`{request}`) or a workflow (`{wid}`), with full texts (no clipping). */
 export async function describe(home, key, now = Date.now()) {
     const entries = ledger(home);
     if ("wid" in key)
@@ -76,7 +76,7 @@ export async function describe(home, key, now = Date.now()) {
         return { state: "applied", ...head };
     return { state: "pending", ...head };
 }
-/** R6: `{labels}` of a run request that has any. */
+/** `{labels}` of a run request that has any. */
 function labelsOf(request) {
     const labels = request?.kind === "run" ? request.body?.labels : undefined;
     return labels && typeof labels === "object" && Object.keys(labels).length ? { labels } : {};
@@ -86,7 +86,7 @@ function runOf(entries, wid) {
     const created = entries.find(e => e.type === JT.created && e.wid === wid);
     return { created, run: created ? entries.find(e => e.type === "request" && e.request.rid === created.rid)?.request : undefined };
 }
-/** The pinned agents of a workflow revision, read once on demand (R7: the model of a call that names none). */
+/** The pinned agents of a workflow revision, read once on demand (the waiting check needs the model of a call that names none). */
 function pinnedAgentModel(home, wid, rev) {
     let agents;
     return name => {
@@ -108,7 +108,7 @@ function describeWorkflow(home, wid, entries, now) {
             ...(typeof pruned.request === "string" ? { request: pruned.request } : {}), ...(typeof pruned.spec_digest === "string" ? { spec_digest: pruned.spec_digest } : {}), ...labelsOf(runOf(entries, wid).run) };
     if (!/^[^/\\\0]+$/.test(wid) || wid === "." || wid === ".." || !existsSync(journalPath(home, wid)))
         return { state: "absent", wid };
-    // The snapshot and the journal the R7 fold reads must be the same bytes (a writer-wait appended between the two reads
+    // The snapshot and the journal the wait fold reads must be the same bytes (a writer-wait appended between the two reads
     // would give a reason without its writerWait): read again until the journal did not move around the snapshot.
     let journal = readJournalSnapshot(journalPath(home, wid)), wf = workflowSnapshot(home, wid);
     for (let i = 0, again = readJournalSnapshot(journalPath(home, wid)); again !== journal && i < 5; i++, again = readJournalSnapshot(journalPath(home, wid))) {
@@ -118,7 +118,7 @@ function describeWorkflow(home, wid, entries, now) {
     const { created, run } = runOf(entries, wid), id = created ? requestId(String(created.rid)) : undefined;
     const admitted = id ? run : undefined;
     const lstate = leaseState(home), slots = slotsView(home, now), leases = leaseCalls(lstate, now);
-    // R7: the same fold and decision the orchestrator's collector uses, from the disk snapshots.
+    // The same fold and decision the orchestrator's collector uses, from the disk snapshots.
     const waits = waitsOf(foldWaits(wid, journal), { now, ledger: foldLedger(emptyLedger(), entries), leases: leaseWaits(lstate, now) }, pinnedAgentModel(home, wid, wf.rev));
     const line = (lines, model) => { const provider = model?.split("/")[0]; return provider ? lines?.find(l => l.startsWith(`${provider} `)) : undefined; };
     const latest = [...new Map(wf.calls.map(c => [c.key, c])).values()];
@@ -140,7 +140,7 @@ function describeWorkflow(home, wid, entries, now) {
     return { state, wid, ...(id ? { request: id } : {}), ...(admitted ? { spec_digest: specDigest(admitted) } : {}), ...labelsOf(run), status: wf.status, ...(wf.error ? { error: wf.error } : {}),
         calls, ...(questions.length ? { questions } : {}), ...(attention.length ? { attention } : {}), ...(fence ? { lastFence: fence } : {}) };
 }
-/** R3, best effort: why the latest fence that interrupted work happened. The per-execution classification and the
+/** Best effort: why the latest fence that interrupted work happened. The per-execution classification and the
  *  reason are shared with the event log's `fenced` events (src/events/fence.ts). */
 export function lastFence(journal, orch) {
     const ended = endedExecs(journal);
@@ -210,7 +210,7 @@ function pending(ctx, id, json, why = "") {
 }
 /** Submit, then wait; a decision whose admitted envelope has other content (another sender won the id) is a conflict. */
 async function submitAndWait(ctx, seen, id, kind, body, cond, wait, json) {
-    // R2: `created` is false only when the id was already decided before this invocation submitted (decisions are
+    // `created` is false only when the id was already decided before this invocation submitted (decisions are
     // monotonic); racing first attempts may all report created — the wid is what identifies the run.
     const rid = requestRid(id), earlier = Boolean(await outcome(ctx.home, rid, kind === "run", 0));
     let sent;
@@ -236,7 +236,7 @@ async function submitAndWait(ctx, seen, id, kind, body, cond, wait, json) {
         return { code: await conflict(ctx, id, specDigest(admitted), json) };
     return { sent, outcome: result, earlier };
 }
-/** R2: a failure once this invocation submitted, or once the id is found recorded with this content, is "not decided
+/** A failure once this invocation submitted, or once the id is found recorded with this content, is "not decided
  *  yet" (75), never a refusal. Otherwise, with --json, a request refused before submission (a usage error, an invalid
  *  spec, an unknown agent, no open question) answers `{request, applied:false, reason, spec_digest?}` with exit 1;
  *  spec_digest is present once the content was complete enough to hash. This invocation submitted nothing. */
@@ -259,7 +259,7 @@ async function refusable(args, ctx, run) {
 }
 const forks = (spec) => [spec, ...["tasks", "chain"].flatMap(k => Array.isArray(spec[k]) ? spec[k] : [])]
     .some(s => s && typeof s === "object" && s.context === "fork");
-/** R2: `run --request <id> --spec <file|-> [--cwd <dir>] [--json] [--wait-ms <n>]`. The spec is the `subagents` run
+/** `run --request <id> --spec <file|-> [--cwd <dir>] [--json] [--wait-ms <n>]`. The spec is the `subagents` run
  *  form ({agent,task,…} or {tasks|chain:[…],…}); it is validated by the tool's own normalizer and agent check. */
 export const runCommand = (args, ctx) => refusable(args, ctx, runRequest);
 async function runRequest(args, ctx, seen) {
@@ -320,7 +320,7 @@ async function widOf(home, head) {
     const found = await findRequest(home, rid);
     return found?.request.kind === "run" && decision(ledger(home), rid)?.type !== "rejected" ? { pending: true } : { wid: head };
 }
-/** R2: `--to <run-id>[/<key>] | <wid>/<key>` (+ `--call <key>`) → `<wid>/<key>`; a run of one call implies its key. */
+/** `--to <run-id>[/<key>] | <wid>/<key>` (+ `--call <key>`) → `<wid>/<key>`; a run of one call implies its key. */
 async function target(home, to, call, prior) {
     const cut = to.indexOf("/"), head = cut < 0 ? to : to.slice(0, cut), key = cut < 0 ? call : to.slice(cut + 1);
     if (cut >= 0 && call !== undefined)
@@ -341,7 +341,7 @@ async function target(home, to, call, prior) {
         return { to: `${resolved.wid}/${keys[0]}` };
     throw new Error(`${to} has ${keys.length ? `calls ${keys.join(", ")}` : "no calls yet"}; name one with --call <key> or --to <wid>/<key>`);
 }
-/** R2: `send --request <id> --to <…> --kind follow-up|answer|steer|model [--qid <qid> --rev <n>] --message <text|@file> [--model <m>]`. */
+/** `send --request <id> --to <…> --kind follow-up|answer|steer|model [--qid <qid> --rev <n>] --message <text|@file> [--model <m>]`. */
 export const sendCommand = (args, ctx) => refusable(args, ctx, sendRequest);
 async function sendRequest(args, ctx, seen) {
     const { values, positionals } = flags(args, { request: "value", to: "value", call: "value", kind: "value", qid: "value", rev: "value", message: "value", model: "value", json: "flag", "wait-ms": "value" });
@@ -378,7 +378,7 @@ async function sendRequest(args, ctx, seen) {
         return done.code;
     return decided(ctx, id, done, json);
 }
-/** R2: `stop --request <id> <run-id|wid|wid/key|callId>`. */
+/** `stop --request <id> <run-id|wid|wid/key|callId>`. */
 export const stopCommand = (args, ctx) => refusable(args, ctx, stopRequest);
 async function stopRequest(args, ctx, seen) {
     const { values, positionals } = flags(args, { request: "value", json: "flag", "wait-ms": "value" });

package/dist/events/cli.js

@@ -1,4 +1,4 @@
-// R2: `events --all [--since <cursor>] [--limit <n>] [--json] [--wait-ms <n>]` — read the cross-workflow event log.
+// `events --all [--since <cursor>] [--limit <n>] [--json] [--wait-ms <n>]` — read the cross-workflow event log.
 // Output is JSON lines (with or without --json). Without --since: `{"head","more":false}`. With --since: the events
 // after the cursor (at most --limit, default and max EVENTS_PAGE_MAX), then `{"head","more"}`: more:true → head is the
 // cursor of the last event printed; more:false → the log head. Exit 0; 4 cursor-expired (other epoch, seq below

package/dist/events/derive.js

@@ -1,4 +1,4 @@
-// R2: journal → event drafts. Pure functions of durable sources: the entry at journal index i (seq i+1) is derived from
+// Journal → event drafts. Pure functions of durable sources: the entry at journal index i (seq i+1) is derived from
 // that journal's entries up to it and from orchestrator-ledger entries durable before it, so a re-derivation after a
 // crash gives the same events with the same ids (`<wid>:<journal seq>:<type>`, `<wid>:submitted`).
 import { createHash } from "node:crypto";
@@ -14,7 +14,7 @@ export function callParts(call) {
 const echo = (id) => ({ ...(id.request !== undefined ? { request: id.request } : {}), ...(id.labels ? { labels: id.labels } : {}) });
 const onCall = (call) => { const p = callParts(call); return p ? { key: p.key, gen: p.gen, call } : { call }; };
 /** The labels of a run body: a non-empty plain object of strings (anything else, and `{}`, is not echoed — as describe
- *  and the R7 collector treat them). */
+ *  and the wait collector treat them). */
 export function labelsOf(body) {
     const labels = body?.labels;
     if (!labels || typeof labels !== "object" || Array.isArray(labels))

package/dist/events/fence.js

@@ -1,8 +1,8 @@
-// R2/R3: which fences interrupted work, shared by `describe` (lastFence) and the event deriver (`fenced`). Read-only over
+// Which fences interrupted work, shared by `describe` (lastFence) and the event deriver (`fenced`). Read-only over
 // committed journal entries; `limit` restricts the view to the first `limit` entries (the deriver may read only entries
 // before the one it derives, so a re-derivation after a crash sees the same history).
 import { JT } from "../types.js";
-/** R3: Executions whose fence did NOT interrupt work: every execution ends with a fence; one interrupted work only when
+/** Executions whose fence did NOT interrupt work: every execution ends with a fence; one interrupted work only when
  *  the execution neither settled (its turn ended) before it nor hibernated (it waits for an answer), and was not sealed
  *  on purpose: a seal ends an execution on purpose unless its outcome is `unknown` (a `once` call cut off in a tool) or
  *  the execution was recorded as lost (the loss bound sealed it), which are interruptions themselves. A seal for an
@@ -31,7 +31,7 @@ export function endedExecs(journal, limit = journal.length) {
     }
     return ended;
 }
-/** R3, best effort: why `fence` (a `fenced` entry that interrupted work) happened. restart-force: a forced restart listed
+/** Best effort: why `fence` (a `fenced` entry that interrupted work) happened. restart-force: a forced restart listed
  *  the execution as live; orchestrator-crash: the execution was launched before an orchestrator start that is not
  *  preceded by a clean exit and fenced after it (startup recovery); otherwise process-died (the child or its host went
  *  away, or a drain fenced it). */
@@ -49,7 +49,7 @@ export function fenceReason(journal, orch, fence) {
     }
     return "process-died";
 }
-/** R2: the fence of `exec` among the first `limit` entries when it interrupted work, else undefined. */
+/** The fence of `exec` among the first `limit` entries when it interrupted work, else undefined. */
 export function interruptingFence(journal, exec, limit = journal.length) {
     let fence;
     for (let i = limit - 1; i >= 0 && !fence; i--) {

package/dist/events/labels.js

@@ -1,4 +1,4 @@
-// R6 (owed requirements §20.2): caller labels of a run — `run --labels <json>`, the tool's `labels`, and the
+// Caller labels of a run — `run --labels <json>`, the tool's `labels`, and the
 // orchestrator's admission all validate with this one function. Labels are part of RunBody, so they are part of the
 // request's spec_digest (the same request id with other labels is a request-conflict) and are echoed by `describe` and
 // on every event of the workflow.

package/dist/events/log.js

@@ -1,4 +1,4 @@
-// R2: the cross-workflow event log, `<home>/events.jsonl`. Single writer: the orchestrator (under its OS lock). Each line
+// The cross-workflow event log, `<home>/events.jsonl`. Single writer: the orchestrator (under its OS lock). Each line
 // is CRC-framed like the journals (`<crc32 hex 8> <json>\n`, kernel/journal.ts); a reader ignores a torn final line, a
 // bad line before the last one is corruption. Records (`k`):
 //   log  {v, epoch, dropped}   first line, written when the file is created or compacted. `epoch` (16 hex chars, random)
@@ -120,7 +120,7 @@ function scanFile(fd, size) {
         throw new LogCorrupt("event log has no header");
     return { epoch: header.epoch, dropped: header.dropped, head: Math.max(head, header.dropped), marks, end: bad ?? end, records, events };
 }
-/** R2: The writer. Appends, compaction and close are serialized; an append resolves only after fsync. */
+/** The writer. Appends, compaction and close are serialized; an append resolves only after fsync. */
 export class EventLog {
     path;
     epoch;

package/dist/events/pump.js

@@ -1,7 +1,7 @@
-// R2: the orchestrator's event pump. Derives events from the durable sources (workflow journals, the orchestrator
+// The orchestrator's event pump. Derives events from the durable sources (workflow journals, the orchestrator
 // ledger's `created`) after their appends and writes them to the event log with the watermarks of the sources derived
 // (same fsync), so a restart re-derives only after them (at least once). It is also the EventSink other producers
-// (R7 waiting/moving) emit through. One chain serializes passes, emits, compaction and close. A pass that cannot log
+// (waiting/moving) emit through. One chain serializes passes, emits, compaction and close. A pass that cannot log
 // what it derived retries in the background, and `flush` (prune) rejects; a broken log (a failure after a compaction's
 // rename) is reopened by the next pass or emit.
 // Memory: per unpruned workflow one watermark and one cached identity; reads the journals' committed arrays from their
@@ -123,7 +123,7 @@ export class EventPump {
     async emit(drafts) {
         await this.ready;
         return this.serial(async () => {
-            // After close (the orchestrator exits) nothing is logged: R7 state is derived again by the next orchestrator.
+            // After close (the orchestrator exits) nothing is logged: waiting state is derived again by the next orchestrator.
             if (!this.log || this.closed || !drafts.length)
                 return;
             const log = await this.writer();
@@ -209,7 +209,7 @@ export class EventPump {
     }
     /** The writer; a broken one (a failure after a compaction's rename) is reopened first: the open applies the start
      *  skip. A log it had to create anew (corrupt or gone) is backfilled from everything on disk: the caller's drafts
-     *  were derived for the old one, so this throws (a pass retries from the cleared watermarks, R7 on its next tick). */
+     *  were derived for the old one, so this throws (a pass retries from the cleared watermarks, waiting/moving on its next tick). */
     async writer() {
         const log = this.log;
         if (!log.broken)

package/dist/events/types.js

@@ -1,10 +1,9 @@
-// R2/R6/R7 (owed requirements §18.2, §20.2): the public shape of the cross-workflow event log. Pinned by the parent for
-// batch 2; both leaves build on it. Changing a field here changes the public contract: do it only with the parent.
+// The public shape of the cross-workflow event log. Changing a field here changes the public contract.
 //
 // One durable sequence, single writer (the orchestrator). Each record is one event; `seq` grows strictly (gaps allowed:
 // retention drops records and every orchestrator start skips ahead, see EVENT_SEQ_SKIP). The public cursor is
 // `<epoch>:<seq>`; `--since c` returns events with a larger seq of the same epoch.
-/** R7 reasons, one per waiting call, in this precedence when several apply (first wins). */
+/** Wait reasons, one per waiting call, in this precedence when several apply (first wins). */
 export const WAIT_REASONS = ["unconfirmed-stop", "provider-exhausted", "writer-lock", "lease", "slot", "silent"];
 /** `data` of a `sealed` event is inlined up to this many bytes of JSON; larger → `data_omitted`. */
 export const EVENT_DATA_INLINE_MAX = 16 * 1024;

package/dist/events/{r7.js → waiting.js}

@@ -1,7 +1,7 @@
-// R7 (owed requirements §4 R7, §18.2, §20.2): why a call is not moving. One pure decision (`whyWaiting`) from one
+// Why a call is not moving. One pure decision (`whyWaiting`) from one
 // unsealed call's observable state; `describe` (CLI, from disk snapshots) and the orchestrator's collector (from its
 // in-memory journals) both build that state with the same fold (`foldWaits`) and the same inputs (`waitsOf`), so they
-// agree. The tracker turns the per-tick waits into `waiting`/`moving` event drafts for the log's EventSink; `startR7`
+// agree. The tracker turns the per-tick waits into `waiting`/`moving` event drafts for the log's EventSink; `startWaiting`
 // runs it on a timer. No durable state of its own: the log holds what was emitted, and seeds the tracker after a start.
 //
 // Sources, per reason (precedence WAIT_REASONS, first wins):
@@ -31,7 +31,7 @@ import { leaseCalls, leaseState } from "../platform/lease.js";
 import { requestId } from "../requests.js";
 /** A queued call whose providers have a free slot (or are unknown) counts as waiting for a slot only after this long. */
 export const SLOT_GRACE_MS = 3000;
-/** R7: why the call does not move, or undefined when it moves (or is asking or sealed). Pure. */
+/** Why the call does not move, or undefined when it moves (or is asking or sealed). Pure. */
 export function whyWaiting(c, now) {
     if (c.sealed || c.asking)
         return undefined;
@@ -246,7 +246,7 @@ export function waitInput(f, c, env, agentModel) {
 export function liveWaitCalls(f) {
     return [...f.calls.values()].filter(c => !f.done || c.generation);
 }
-/** R7: the waits of a folded workflow's live calls (calls that move are absent). */
+/** The waits of a folded workflow's live calls (calls that move are absent). */
 export function waitsOf(f, env, agentModel) {
     const out = new Map();
     if (!f.calls.size)
@@ -263,8 +263,8 @@ const base = (m) => ({ wid: m.wid, ...(m.request ? { request: m.request } : {}),
  *  (also when the call seals or disappears while waiting); a change of detail or age alone emits nothing. Ids carry the
  *  observing tick: the same cause can recur with the same `since` (a used-up provider whose probe is refused again keeps
  *  its first `since`), and a reader deduplicating on the id must still see it. A draft that failed to log is retried with
- *  its id (startR7), and the seed keeps a restarted tracker from repeating a logged transition. */
-export class R7Tracker {
+ *  its id (startWaiting), and the seed keeps a restarted tracker from repeating a logged transition. */
+export class WaitTracker {
     last = new Map();
     /** Start from the latest `waiting`/`moving` per call id (the log's view at an orchestrator start). */
     seed(latest) {
@@ -299,11 +299,11 @@ export class R7Tracker {
         return out;
     }
 }
-/** Every `intervalMs` (k.r7Ms, default 5000): collect, diff, emit. Never overlaps itself; an emit failure is logged and
+/** Every `intervalMs` (k.waitCheckMs, default 5000): collect, diff, emit. Never overlaps itself; an emit failure is logged and
  *  its drafts are emitted first on the next tick (in order, same ids), so no transition is lost. `tick()` runs one now
  *  (or joins the one running). */
-export function startR7(options) {
-    const tracker = options.tracker ?? new R7Tracker(), now = options.now ?? Date.now, log = options.log ?? (line => console.error(line));
+export function startWaiting(options) {
+    const tracker = options.tracker ?? new WaitTracker(), now = options.now ?? Date.now, log = options.log ?? (line => console.error(line));
     let pending = [], running, stopped = false, timer, epoch = options.epoch?.();
     const once = async () => {
         try {
@@ -315,7 +315,7 @@ export function startR7(options) {
             pending.push(...tracker.diff(at, current, meta));
         }
         catch (error) {
-            log(`durable-subagents: R7 collection failed: ${String(error)}`);
+            log(`durable-subagents: wait collection failed: ${String(error)}`);
         }
         while (pending.length) {
             const batch = pending.slice(0, EVENT_SEQ_SKIP);
@@ -324,7 +324,7 @@ export function startR7(options) {
                 pending = pending.slice(batch.length);
             }
             catch (error) {
-                log(`durable-subagents: ${pending.length} R7 event(s) not logged, retried next tick: ${String(error)}`);
+                log(`durable-subagents: ${pending.length} waiting/moving event(s) not logged, retried next tick: ${String(error)}`);
                 return;
             }
         }
@@ -339,13 +339,13 @@ export function startR7(options) {
     schedule();
     return { tick, async stop() { stopped = true; clearTimeout(timer); await running; } };
 }
-/** The waits of the orchestrator's live calls, for `startR7`'s `collect`:
- *    const collect = r7Collector({ home, workflows: () => engine.store.workflows.values(), orch: ledgers.orch, config: ledgers.config });
- *    startR7({ collect: () => collect(), sink, intervalMs: config.k?.r7Ms, tracker });
+/** The waits of the orchestrator's live calls, for `startWaiting`'s `collect`:
+ *    const collect = waitCollector({ home, workflows: () => engine.store.workflows.values(), orch: ledgers.orch, config: ledgers.config });
+ *    startWaiting({ collect: () => collect(), sink, intervalMs: config.k?.waitCheckMs, tracker });
  *  Per tick: one `entries()` per workflow (a cached view unless it was appended to), each changed journal folded only
  *  past what was folded before; a workflow without unsealed calls costs a map lookup. The ledger is folded the same way
  *  (slots, used-up providers, settings, and each workflow's request id and labels). Call it from one place at a time. */
-export function r7Collector(src) {
+export function waitCollector(src) {
     const folds = new Map();
     const ledger = emptyLedger();
     // Run requests not yet created (rid → labels) and the request id and labels of each workflow: bounded by the

package/dist/kernel/lifecycle.js

@@ -35,7 +35,7 @@ export function planDecisions(records, candidates, decide) {
         if (bound) {
             if (bound.hash === hash)
                 envelopes.set(req.rid, req);
-            // A1, R1: a conflicting duplicate of a resolved rid is only dropped (its file still goes); it never records a decision.
+            // A1: a conflicting duplicate of a resolved rid is only dropped (its file still goes); it never records a decision.
             else if (!view.resolved.has(req.rid) && !conflicts.has(req.rid)) {
                 conflicts.add(req.rid);
                 emit({ type: 'rejected', rid: req.rid, reason: 'identity-conflict' });

package/dist/orchestrator/config.js

@@ -3,14 +3,14 @@
 // Orchestrator ledger entries: config{hash,config} — the settings in effect from then on (at start, or after a change);
 // config-rejected{hash,error} — a changed file that was not applied; the settings before it stay in effect.
 // A reload changes the shared config object in place: every later read sees it (the next slot acquisition, model
-// resolution or check). Slots already held are kept when a limit drops; timers of running executions keep their period, and the R7 check
-// period (k.r7Ms) is read once at orchestrator start.
+// resolution or check). Slots already held are kept when a limit drops; timers of running executions keep their period, and the waiting check
+// period (k.waitCheckMs) is read once at orchestrator start.
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { contentHash } from "../kernel/ids.js";
 /** The keys the orchestrator reads; config.json also holds pi-side settings (ui, onQuit) that it ignores. */
 const KEYS = ["defaultModel", "pools", "providers", "memory", "writerLock", "k"];
-const K = ["lossBound", "checkpointMs", "stallMs", "progressMs", "switchTimeoutMs", "idleExitMs", "trackerMs", "hibernateMs", "spawnBudget", "probeMs", "eventRetentionMs", "r7Ms"];
+const K = ["lossBound", "checkpointMs", "stallMs", "progressMs", "switchTimeoutMs", "idleExitMs", "trackerMs", "hibernateMs", "spawnBudget", "probeMs", "eventRetentionMs", "waitCheckMs"];
 export const configPath = (home) => join(home, "config.json");
 /** The orchestrator's part of a parsed config.json. */
 export function orchestratorSettings(raw) {

package/dist/orchestrator/engine.js

@@ -9,7 +9,7 @@
 // stop-requested {rid,call?} marks a call or workflow stop as taking effect, so its replay is applied, not already-sealed.
 // Orch entry pruned {rid,wid,endedAt,bytes,status,request?,spec_digest?} is the decisive record of a prune: appended before
 // the journal handle is closed and w/<wid> and its staging dirs are removed (bytes = footprint measured just before;
-// status = the final workflow status; request/spec_digest when the workflow was created by a request id, R1 tombstone).
+// status = the final workflow status; request/spec_digest when the workflow was created by a request id, request-id tombstone).
 // Nothing is rewritten (A1): the admitted request and created entries stay, so a retried id still resolves to this wid.
 import { watch } from 'node:fs';
 import { mkdir, readdir, unlink } from 'node:fs/promises';
@@ -28,7 +28,7 @@ import { formatUsage, holdOf, refusedResult, snapshotFromEntries } from "./snaps
 import { validateCallSpec } from "../compat/spec.js";
 import { EventPump } from "../events/pump.js";
 import { labelsProblem } from "../events/labels.js";
-import { R7Tracker, r7Collector, startR7 } from "../events/r7.js";
+import { WaitTracker, waitCollector, startWaiting } from "../events/waiting.js";
 import { readPage } from "../events/log.js";
 import { eventsLog } from "../paths.js";
 import { parseModel } from "../compat/model.js";
@@ -97,9 +97,9 @@ export function finishedText(wid, entries, call) {
 /** A1, P2, P10, P11: Serialize decisions while executions run independently. */
 export class Engine {
     store;
-    /** R2: the cross-workflow event log's writer (derives milestones from the journals; R7 emits through it). */
+    /** The cross-workflow event log's writer (derives milestones from the journals; waiting/moving emits through it). */
     events;
-    r7;
+    waiting;
     ledgers;
     executor;
     evaluator;
@@ -152,7 +152,7 @@ export class Engine {
     /** A2, P10: Recover executor authority before replaying each unfinished workflow. */
     async recover() {
         await this.store.recover();
-        // R2: before any recovery append, so every journal entry from here on is derived promptly (and a new log derives
+        // Before any recovery append, so every journal entry from here on is derived promptly (and a new log derives
         // everything still on disk).
         await this.events.open();
         for (const wf of this.store.workflows.values()) {
@@ -186,14 +186,14 @@ export class Engine {
                 this.dispatchGeneration(wf, entry);
         }
         await this.intake();
-        this.startR7();
+        this.startWaiting();
     }
-    /** R7: every k.r7Ms (read here, at orchestrator start), why each live call does not move, as `waiting`/`moving`
+    /** Every k.waitCheckMs (read here, at orchestrator start), why each live call does not move, as `waiting`/`moving`
      *  events through the pump. The tracker starts from the log's latest transition per call, so a restart repeats none
      *  (and a call that ended or started moving meanwhile gets its `moving`). The seed reads from seq 0: retention keeps
-     *  events below `dropped`. A seed that cannot be read is logged and R7 starts empty (recovery never fails on it). */
-    startR7() {
-        if (this.closed || this.r7)
+     *  events below `dropped`. A seed that cannot be read is logged and the tracker starts empty (recovery never fails on it). */
+    startWaiting() {
+        if (this.closed || this.waiting)
             return;
         const latest = new Map(), head = this.events.head;
         try {
@@ -211,13 +211,13 @@ export class Engine {
                 }
         }
         catch (error) {
-            console.error(`durable-subagents: R7 seed from the event log failed, starting without it: ${String(error)}`);
+            console.error(`durable-subagents: waiting seed from the event log failed, starting without it: ${String(error)}`);
             latest.clear();
         }
-        const tracker = new R7Tracker();
+        const tracker = new WaitTracker();
         tracker.seed(latest);
-        const collect = r7Collector({ home: this.ledgers.home, workflows: () => this.store.workflows.values(), orch: this.ledgers.orch, config: this.ledgers.config });
-        this.r7 = startR7({ collect: () => collect(), sink: this.events, intervalMs: this.ledgers.config.k?.r7Ms, tracker, epoch: () => this.events.head?.epoch });
+        const collect = waitCollector({ home: this.ledgers.home, workflows: () => this.store.workflows.values(), orch: this.ledgers.orch, config: this.ledgers.config });
+        this.waiting = startWaiting({ collect: () => collect(), sink: this.events, intervalMs: this.ledgers.config.k?.waitCheckMs, tracker, epoch: () => this.events.head?.epoch });
     }
     async startHost() {
         await this.evaluator.start(message => this.background(() => this.message(message)), () => this.background(async () => {
@@ -342,7 +342,7 @@ export class Engine {
         }
         if (req.kind === 'run') {
             const created = this.ledgers.orch.entries().find(e => e.type === JT.created && e.rid === req.rid);
-            // R6: senders validate labels; a hand-written request must not bypass that.
+            // Senders validate labels; a hand-written request must not bypass that.
             const labels = req.body?.labels, invalid = !created && labels !== undefined ? labelsProblem(labels) : undefined;
             if (invalid)
                 return { action: 'reject', reason: `invalid-labels: ${invalid}` };
@@ -590,7 +590,7 @@ export class Engine {
         const createdBy = String(entries.find(e => e.type === JT.created && e.wid === wf.wid)?.rid ?? '');
         const admitted = requestId(createdBy) !== undefined ? entries.find(e => e.type === 'request' && e.request.rid === createdBy)?.request : undefined;
         const identity = admitted ? { request: requestId(createdBy), spec_digest: specDigest(admitted) } : {};
-        // R2: its events are derived and logged before the journal can go (recovery removes it once `pruned` is committed);
+        // Its events are derived and logged before the journal can go (recovery removes it once `pruned` is committed);
         // when they cannot be, the prune is rejected and the caller retries later.
         try {
             await this.events.flush();
@@ -857,7 +857,7 @@ export class Engine {
         this.closed = true;
         this.watcher?.close();
         clearInterval(this.poll);
-        await this.r7?.stop();
+        await this.waiting?.stop();
         await this.queue;
         await this.evaluator.close();
         await this.executor.shutdown();

package/dist/orchestrator/restart.js

@@ -1,7 +1,7 @@
 // Restart guards shared by the orchestrator and the legacy client. The caller owns the launch gate;
 // these checks never change durable state. A1: only an accepted restart is appended to the ledger.
 import { contentHash } from "../kernel/ids.js";
-import { leaseCalls, leaseState } from "../platform/lease.js";
+import { holdDetail, leaseState, who } from "../platform/lease.js";
 export const subagentRestartError = "a subagent cannot force a restart: it would fence itself and other sessions' work; ask the user";
 export const restartToken = (live) => contentHash(live.map(l => l.exec).sort()).slice(0, 12);
 /** Old senders' boolean force is read only to refuse it when executions are live. */
@@ -27,7 +27,17 @@ export function restartRefusal(home, live, body, tool = false, now = Date.now())
     const token = restartToken(live);
     if (body.token === token)
         return undefined;
-    const leases = leaseCalls(leaseState(home).map(r => ({ ...r, waiters: [] })), now);
+    // What a fence would cut short: each lease a listed call holds, with its age and command. Holders outside these
+    // executions (a shell, a systemd unit, another call) keep their lease across the restart; they are listed so the
+    // machine is not mistaken for free.
+    const leases = new Map(), others = [], calls = new Set(live.map(l => l.callId));
+    for (const { resource, holders } of leaseState(home))
+        for (const t of holders) {
+            if (t.call && calls.has(t.call))
+                leases.set(t.call, [leases.get(t.call), `holds lease ${resource} (${holdDetail(t, now)})`].filter(Boolean).join(", "));
+            else
+                others.push(`  ${resource} held by ${who(t)} (${holdDetail(t, now)})`);
+        }
     const groups = new Map();
     for (const l of live) {
         const origin = l.origin ?? "unknown";
@@ -40,6 +50,7 @@ export function restartRefusal(home, live, body, tool = false, now = Date.now())
         ...[...groups].sort(([a], [b]) => a.localeCompare(b)).flatMap(([origin, executions]) => [
             `${origin}:`, ...executions.map(l => `  ${l.wid}/${l.key} ${age(now - l.since)}${l.phase === "gate" ? " gate" : ""}${leases.has(l.callId) ? ` ${leases.get(l.callId)}` : ""}`),
         ]),
+        ...(others.length ? ["not fenced (a restart leaves these leases held):", ...others] : []),
         `token: ${token}`,
         tool ? `to fence exactly these: subagents {action:"restart", force:"${token}", reason:"<why>"}` : `to fence exactly these: pi-durable-subagents restart --force ${token} --reason "<why>"`,
     ].join("\n");

package/dist/orchestrator/snapshot.js

@@ -543,7 +543,7 @@ export function runningOrchestrator(home) {
     ledgerStates.set(path, state);
     return orchestratorView(state);
 }
-/** One `exhausted` line of the status views (R7 `provider-exhausted` uses it as its detail). */
+/** One `exhausted` line of the status views (the `provider-exhausted` wait uses it as its detail). */
 export function exhaustedLine(provider, x, now) {
     return `${provider} exhausted since ${age(now - x.since)} ago (${clip(x.error, 80)}), ` +
         (x.probe ? `probing with ${x.probe.split("#")[0]}` : x.nextTry > now ? `next try in ${age(x.nextTry - now)}` : "next call probes it");

package/dist/orchestrator/store.js

@@ -180,7 +180,7 @@ export async function diskUsage(path) {
 /** A1, P11: Own shared workflow handles and reconcile create intents after a crash. */
 export class Store {
     workflows = new Map();
-    /** R2: called after each append to a workflow journal (the event pump derives from it). */
+    /** Called after each append to a workflow journal (the event pump derives from it). */
     appended;
     ledgers;
     constructor(ledgers) { this.ledgers = ledgers; }

package/dist/paths.js

@@ -6,7 +6,7 @@ import { ENV } from "./types.js";
 export const dsaHome = (env = process.env) => env[ENV.home] || path.join(os.homedir(), ".pi", "durable-subagents");
 export const orchLedger = (home) => path.join(home, "orchestrator.jsonl");
 export const orchLock = (home) => path.join(home, "orchestrator.lock");
-/** R2: the cross-workflow event log (single writer: the orchestrator; read by `events --all`). */
+/** The cross-workflow event log (single writer: the orchestrator; read by `events --all`). */
 export const eventsLog = (home) => path.join(home, "events.jsonl");
 /** Executables for subagents: the orchestrator writes a `pi-durable-subagents` shim here and children get it on PATH. */
 export const binDir = (home) => path.join(home, "bin");

package/dist/platform/lease.js

@@ -201,12 +201,13 @@ const clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}…` : s;
 export const callAddress = (call) => { const m = /^([^@/]+)@\d+\/(.+)@\d+$/.exec(call); return m ? `${m[1]}/${m[2]}` : call; };
 /** Who holds or waits: the subagent call when there is one, else the pid and command. */
 export const who = (t) => t.call ? callAddress(t.call) : `pid ${t.wrapper.pid} \`${clip(t.argv.join(" "), 60)}\``;
+/** A granted ticket's mode, how long it has been held, the command (unless `who` already names it) and the note:
+ *  "exclusive, 12m, `make bench`, nightly". */
+export const holdDetail = (t, now = Date.now(), command = !!t.call) => `${t.mode}, ${age(now - (t.grantedAt ?? t.since))}${command ? `, \`${clip(t.argv.join(" "), 60)}\`` : ""}${t.note ? `, ${clip(t.note, 80)}` : ""}`;
 /** One status line per resource: "machine held by <who> (exclusive, 12m, `make bench`); waiting: <who> 3m, …". */
 export function leaseLines(state, now = Date.now()) {
     return state.map(({ resource, holders, waiters }) => {
-        const held = holders.length
-            ? `held by ${holders.map(t => `${who(t)} (${t.mode}, ${age(now - (t.grantedAt ?? t.since))}${t.call ? `, \`${clip(t.argv.join(" "), 60)}\`` : ""}${t.note ? `, ${clip(t.note, 80)}` : ""})`).join(", ")}`
-            : "free";
+        const held = holders.length ? `held by ${holders.map(t => `${who(t)} (${holdDetail(t, now)})`).join(", ")}` : "free";
         return `${resource} ${held}${waiters.length ? `; waiting: ${waiters.map(t => `${who(t)} ${t.mode === "shared" ? "shared " : ""}${age(now - t.since)}`).join(", ")}` : ""}`;
     });
 }

package/dist/requests.js

@@ -1,4 +1,4 @@
-// R1: Caller-chosen request ids. A program names a run/send/stop with `<id>`; its kernel rid is `req:<id>` (fits the
+// Caller-chosen request ids. A program names a run/send/stop with `<id>`; its kernel rid is `req:<id>` (fits the
 // mailbox rid pattern), unique per DSA_HOME across kinds and senders. A retry with the same id and the same content
 // (spec_digest) gets the first outcome; a different content is a request-conflict and is never published.
 // The check-and-send is serialized per home by the OS lock <home>/requests.lock (CLI and tool senders alike); no
@@ -13,15 +13,15 @@ import { OsLock } from "./platform/lock.js";
 import { orchInbox, orchLedger, outboxRoot } from "./paths.js";
 export const REQUEST_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,123}$/;
 const PREFIX = 'req:';
-/** R1: `<id>` → its rid `req:<id>`; ids are 1–124 chars `[A-Za-z0-9][A-Za-z0-9._:-]*`. */
+/** `<id>` → its rid `req:<id>`; ids are 1–124 chars `[A-Za-z0-9][A-Za-z0-9._:-]*`. */
 export function requestRid(id) {
     if (!REQUEST_ID.test(id))
         throw new Error(`invalid request id ${JSON.stringify(id)}: 1-124 characters [A-Za-z0-9][A-Za-z0-9._:-]*`);
     return PREFIX + id;
 }
-/** R1: The request id of a `req:<id>` rid; undefined for any other rid (ULIDs never contain ':'). */
+/** The request id of a `req:<id>` rid; undefined for any other rid (ULIDs never contain ':'). */
 export function requestId(rid) { return rid.startsWith(PREFIX) ? rid.slice(PREFIX.length) : undefined; }
-/** R1: spec_digest = contentHash({kind, body, cond}) (cond omitted when absent). A run's body.origin (the pi session
+/** Spec_digest = contentHash({kind, body, cond}) (cond omitted when absent). A run's body.origin (the pi session
  *  branch offered for context:"fork") is delivery metadata, not spec: it differs on every turn, so it is not hashed. */
 export function specDigest(req) {
     let body = req.body;
@@ -31,7 +31,7 @@ export function specDigest(req) {
     }
     return contentHash({ kind: req.kind, body, cond: req.cond });
 }
-/** R1: The envelope recorded for `rid`: the orchestrator's admitted copy (ledger `request`, kept after prune), else any
+/** The envelope recorded for `rid`: the orchestrator's admitted copy (ledger `request`, kept after prune), else any
  *  sender's outbox `sent` entry (published or about to be). Read-only. */
 export async function findRequest(home, rid) {
     const admitted = readJournalSnapshot(orchLedger(home)).find(e => e.type === 'request' && e.request.rid === rid);
@@ -51,7 +51,7 @@ export async function findRequest(home, rid) {
 export class RequestsBusy extends Error {
     name = 'RequestsBusy';
 }
-/** R1, P5: Check-then-send under the home-wide request-id lock (innermost: taken after a sender's own lock), so no two
+/** P5: Check-then-send under the home-wide request-id lock (innermost: taken after a sender's own lock), so no two
  *  senders publish one rid and no second envelope with an existing rid and other content reaches the inbox (it would
  *  stall its sender's sequence). Same content: the recorded envelope stands (republished when it is this sender's and
  *  pending; `sent` false). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-durable-subagents",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "Subagents for pi that never lose work and never do it twice. Crash-safe workflows, automatic recovery, and a live view just like the main agent.",
   "type": "module",
   "license": "MIT",