pi-durable-subagents 1.0.6 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.0.7
+
+- Changes to `config.json` (`defaultModel`, `pools`, `providers`, `memory`,
+  `k`) apply without restarting the orchestrator: it checks the file about
+  once a second and applies a valid change between slot admissions, so a call
+  still waiting for a slot follows the new model, pool or limit. Slots already
+  held are kept when a limit drops. An invalid change is refused and the
+  settings in effect stay; `status` names the error until the file is valid
+  again.
+- `status` marks an asker whose execution hibernated with `hibernated: true`
+  (CLI: "hibernated, no slot"): it holds no provider slot until it is
+  answered. Both `status` forms list provider slots in use against their
+  limits, and the config in effect.
+
 ## 1.0.6
 
 - A follow-up on a finished workflow shows as running work: in the dock, the

package/README.md

@@ -273,6 +273,11 @@ State lives in `~/.pi/durable-subagents`; set `DSA_HOME` to move it.
   never stopped for memory.
 - **onQuit:** `"pause"` (default) pauses a session's running workflows when
   you quit that pi; `"continue"` lets them run on in the background.
+- **Changes apply without a restart:** the orchestrator re-reads the file
+  when it changes. A new slot limit, pool or default model applies to the next
+  slot acquisition; slots already held are kept when a limit drops. An
+  invalid change is not applied, and `status` reports it next to the settings
+  still in effect (`config: <hash> since …`) and the slots held per provider.
 
 ## Switching back
 

package/dist/agent/main.js

@@ -325,7 +325,7 @@ export function registerMain(pi, ui) {
             "run (action optional for exactly one launch form): agent+task; tasks:[call specs] parallel; chain:[call specs] sequential ({previous}); workflow:'./script.js' or source (runs.run(key,spec), runs.all([...]), emit(value), args, runs.input(name)). Optional name, cwd, usageBudget, maxCalls, inputs. With tasks/chain, top-level model, timeoutMs, budget, isolation, context, tools, skills, once are defaults for every step (a step's own value wins); a workflow/source script sets them per runs.run call. timeoutMs is milliseconds of active time (a number); omit it unless a hard limit is needed. Explicit unknown agents are rejected BEFORE creation, with available names; unknown script agents fail only their call.",
             "agents: list names, descriptions, default models and source for this cwd; use these names for run.",
             "send to:'<wid>/<key>' (bare '<wid>' only for a single-call workflow): steer on a running call delivers at the next safe point (receipt in status/UI); a steer to a call waiting on its question interrupts the question and the subagent usually asks again — use answer to answer it; sealed → finished:<status> — use kind 'follow-up'. follow-up continues a sealed call as generation g+1 or queues after a running turn. answer: give the qid (or just the call, or nothing when one question is open); to and rev are filled in. A question that needs the user's decision goes to the user; if you answer one yourself, tell the user what you chose. model switches at next provider request. Unknown targets list valid addresses. replaces:[rid] supersedes an earlier send.",
-            "stop target:<wid|<wid>/<key>> is terminal stopped (usage and partial edits kept); a sealed call → already-sealed:<status>, a finished workflow → terminal:<status>. drain holds existing workflows reversibly (new runs unaffected); resume [wid] releases held workflows. status: without wid, what runs, asks (with its answer address) or failed, finished workflows one line each; wid: one workflow, outputs clipped; wid+key: one call's full result; full:true: everything. A run's rid from {submitted:{rid}} works wherever a wid is expected. revise wid + workflow/source/args starts a revision.",
+            "stop target:<wid|<wid>/<key>> is terminal stopped (usage and partial edits kept); a sealed call → already-sealed:<status>, a finished workflow → terminal:<status>. drain holds existing workflows reversibly (new runs unaffected); resume [wid] releases held workflows. status: without wid, what runs, asks (with its answer address; hibernated:true holds no slot) or failed, finished workflows one line each, provider slots held/limit and the config in effect; wid: one workflow, outputs clipped; wid+key: one call's full result; full:true: everything. A run's rid from {submitted:{rid}} works wherever a wid is expected. revise wid + workflow/source/args starts a revision.",
             "Control replies are {applied:true,rid} or {applied:false,reason,rid} when decided; otherwise {submitted:{rid}} after 10s.",
             ...(agents ? [`Available agents: ${agents}.`] : []),
             "User sees a summary line above the editor; ↓ on an empty editor (or /subagents) opens the list, Enter watches live OR finished calls (finished transcripts remain on disk) and expands finished workflows. List keys: s steer (paste-capable input), x stop (confirm y), m model, a answer when asked, f follow-up on finished calls; action feedback appears in footer.",

package/dist/cli/main.js

@@ -65,13 +65,16 @@ export function renderStatus(wf) {
 /** P25, T10: Render the compact status projection shared with the `subagents` tool. */
 export function renderView(view) {
     const lines = view.workflows.map(w => [`${w.wid}@${w.rev}${w.name ? ` ${w.name}` : ""}: ${w.status}${w.followUps ? " (follow-up running)" : ""}${w.error ? ` (${clip(w.error, 200)})` : ""} · ${w.done}/${w.planned ?? w.calls.length}${w.planned === undefined && w.status === "running" ? "+" : ""} done${w.usage.input || w.usage.output || w.usage.costUsd ? ` · ${formatUsage(w.usage)}` : ""}`,
-        ...w.calls.map(c => `  ${c.key}@${c.gen} ${c.status ?? c.phase}${c.model ? ` ${c.model}` : ""}${c.tools ? ` tools:${c.tools}` : ""}${c.usage ? ` ${formatUsage(c.usage)}` : ""}${c.lastLine ? ` ${JSON.stringify(c.lastLine)}` : c.error ? ` (${c.error})` : ""}`),
+        ...w.calls.map(c => `  ${c.key}@${c.gen} ${c.status ?? c.phase}${c.hibernated ? " (hibernated, no slot)" : ""}${c.model ? ` ${c.model}` : ""}${c.tools ? ` tools:${c.tools}` : ""}${c.usage ? ` ${formatUsage(c.usage)}` : ""}${c.lastLine ? ` ${JSON.stringify(c.lastLine)}` : c.error ? ` (${c.error})` : ""}`),
         ...w.attention.map(a => `  ${a.kind}: ${JSON.stringify(a.text.split("\n")[0])}`)].join("\n"));
     if (view.paused)
         lines.unshift(`${view.paused} (pi-durable-subagents resume)`);
     if (view.olderFinished)
         lines.push(`(+${view.olderFinished} older finished workflows; status <wid> shows one in detail)`);
-    return lines.join("\n") || "No workflows";
+    const footer = [view.slots?.length ? `slots: ${view.slots.join(", ")}` : "", view.config ? `config: ${view.config}` : "", view.configRejected ? `config.json rejected: ${view.configRejected}` : ""].filter(Boolean);
+    if (!lines.length)
+        lines.push("No workflows");
+    return [...lines, ...footer].join("\n");
 }
 function snapshots(home, wid) {
     if (!wid)

package/dist/orchestrator/config.js

@@ -0,0 +1,147 @@
+// $DSA_HOME/config.json for the orchestrator: read at start and again whenever the file changes, so a new slot limit,
+// pool order or K-parameter needs no orchestrator restart (a restart at the wrong moment used to cost a dispatch).
+// 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.
+import { readFile, stat } 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", "k"];
+const K = ["lossBound", "checkpointMs", "stallMs", "progressMs", "switchTimeoutMs", "idleExitMs", "trackerMs", "hibernateMs", "spawnBudget"];
+export const configPath = (home) => join(home, "config.json");
+/** The orchestrator's part of a parsed config.json. */
+export function orchestratorSettings(raw) {
+    const value = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    return Object.fromEntries(KEYS.filter(k => value[k] !== undefined).map(k => [k, value[k]]));
+}
+export const configHash = (config) => contentHash(orchestratorSettings(config)).slice(0, 12);
+const record = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const count = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+/** What is wrong with a parsed config.json for the orchestrator, or undefined. Unknown keys are allowed. */
+export function configProblem(raw) {
+    if (!record(raw))
+        return "config.json must be a JSON object";
+    const { defaultModel, pools, providers, memory, k } = raw;
+    if (defaultModel !== undefined && typeof defaultModel !== "string")
+        return "defaultModel must be a string";
+    if (pools !== undefined) {
+        if (!record(pools))
+            return "pools must map names to model lists";
+        for (const [name, list] of Object.entries(pools))
+            if (!Array.isArray(list) || !list.length || !list.every(m => typeof m === "string" && m))
+                return `pools.${name} must be a nonempty list of "provider/id[:thinking]"`;
+    }
+    if (providers !== undefined) {
+        if (!record(providers))
+            return "providers must map provider names to { slots }";
+        for (const [name, p] of Object.entries(providers))
+            if (!record(p) || !Number.isSafeInteger(p.slots) || Number(p.slots) < 0)
+                return `providers.${name}.slots must be a nonnegative integer`;
+    }
+    if (memory !== undefined) {
+        if (!record(memory))
+            return "memory must be { reserveMb?, perChildMb? }";
+        for (const key of ["reserveMb", "perChildMb"])
+            if (memory[key] !== undefined && !count(memory[key]))
+                return `memory.${key} must be a nonnegative number`;
+    }
+    if (k !== undefined) {
+        if (!record(k))
+            return "k must map K-parameters to numbers";
+        for (const [key, v] of Object.entries(k)) {
+            if (!K.includes(key))
+                return `k.${key} is not a K-parameter (${K.join(", ")})`;
+            if (!count(v) || (key !== "lossBound" && key !== "spawnBudget" && v === 0))
+                return `k.${key} must be a positive number`;
+        }
+    }
+}
+/** Parse config.json; a missing file is the empty config. A JSON error throws. */
+export async function readConfig(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+/** Record the settings in effect unless the ledger already ends on the same ones (a restart with an unchanged file).
+ *  After a rejection they are recorded again: that confirms the file is back to settings in effect. */
+export async function recordConfig(orch, config) {
+    const hash = configHash(config), last = orch.entries().findLast(e => e.type === "config" || e.type === "config-rejected");
+    if (last?.type !== "config" || last.hash !== hash)
+        await orch.append("config", { hash, config: orchestratorSettings(config) });
+    return hash;
+}
+/** Replace the contents of the shared config object; readers hold the object, not a copy. */
+function applyInPlace(target, next) {
+    const t = target;
+    for (const key of KEYS)
+        delete t[key];
+    Object.assign(t, orchestratorSettings(next));
+}
+/** Identity of the file's current version (taken before a read, so a change during the read is seen next time). */
+export async function configStamp(path) {
+    try {
+        const s = await stat(path);
+        return `${s.ino}:${s.size}:${s.mtimeMs}`;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "missing";
+        throw error;
+    }
+}
+/** Watch config.json from the version `stamp` (read at start) and apply each valid change in place. */
+/** `apply` runs the change where readers cannot observe half of it (the executor's admission section). */
+export function watchConfig(options) {
+    const { path, config, orch } = options;
+    let stamp = options.stamp, running, rejected, stopped = false;
+    const once = async () => {
+        const now = await configStamp(path);
+        if (now === stamp || stopped)
+            return;
+        let raw;
+        try {
+            raw = await readConfig(path);
+        }
+        catch (error) {
+            // A half-written file reads as invalid JSON: retry on the next change of the file, report it once per version.
+            stamp = now;
+            const hash = `invalid:${now}`;
+            if (rejected !== hash) {
+                rejected = hash;
+                await orch.append("config-rejected", { error: `config.json is not valid JSON: ${error.message}` });
+            }
+            return;
+        }
+        stamp = now;
+        // Validate the content first: `[]` or `null` project to no settings and must not pass as "unchanged".
+        const problem = configProblem(raw), next = orchestratorSettings(raw), hash = configHash(next);
+        if (problem) {
+            if (rejected !== hash) {
+                rejected = hash;
+                await orch.append("config-rejected", { hash, error: problem });
+            }
+            return;
+        }
+        rejected = undefined;
+        let changed = false;
+        await (options.apply ?? (change => change()))(async () => {
+            changed = hash !== configHash(config);
+            if (changed)
+                applyInPlace(config, next);
+            await recordConfig(orch, config); // also confirms a return to the settings in effect after a rejection
+        });
+        if (changed)
+            options.onApplied?.();
+    };
+    const check = () => running ??= once().catch(error => console.error(`durable-subagents: config.json check failed: ${String(error)}`)).finally(() => { running = undefined; });
+    const timer = setInterval(check, options.intervalMs ?? 1000);
+    timer.unref();
+    return { stop: async () => { stopped = true; clearInterval(timer); await running; }, check };
+}

package/dist/orchestrator/executor/index.js

@@ -389,13 +389,18 @@ export default function createExecutor(ledgers, options = {}) {
     }
     const stopped = (a) => a.stopped || entriesFor(a.ticket.journal, a.ticket.callId).some(e => e.type === "stop-intent");
     const interrupted = (a) => closed || a.suspended || a.retired || stopped(a);
-    async function acquire(a, exec, models, pool, continuation = false) {
+    /** Wait for a slot. The candidates are decided again on every attempt, inside the serial section that also applies
+     *  config.json changes: a queued call follows a reloaded defaultModel, pool or limit, never a mix of two versions. */
+    async function acquire(a, exec, decide) {
+        let continuation = false;
         for (;;) {
             let signal;
             const changed = new Promise(resolve => { signal = resolve; waiters.add(resolve); });
             const chosen = await serial(async () => {
                 if (interrupted(a) || await workflowReached(a.ticket))
                     return;
+                const decision = await decide(), models = decision.candidates, pool = decision.pool;
+                continuation = decision.continuation;
                 for (const model of models) {
                     if (!continuation && pool && skipped(pool, model))
                         continue;
@@ -434,7 +439,7 @@ export default function createExecutor(ledgers, options = {}) {
             });
             if (chosen || interrupted(a) || reached(totalUsage(a.ticket.journal.entries()), a.ticket.workflowBudget)) {
                 waiters.delete(signal);
-                return chosen;
+                return { model: chosen, continuation };
             }
             const timer = setTimeout(signal, config.k?.trackerMs ?? 1000);
             try {
@@ -599,13 +604,13 @@ export default function createExecutor(ledgers, options = {}) {
             }
             let decision;
             try {
-                decision = await launchModel(t, entries, previous);
+                decision = await acquire(a, exec, () => launchModel(t, entries, previous));
             }
             catch (error) {
                 await fence(journal, exec, { park: a });
                 return finish(journal, t.callId, exec, makeResult("failed", "", String(error)));
             }
-            const model = await acquire(a, exec, decision.candidates, decision.pool, decision.continuation);
+            const model = decision.model;
             if (!model || interrupted(a)) {
                 await fence(journal, exec, { park: a });
                 return finish(journal, t.callId, exec, !interrupted(a) ? makeResult("failed", "", "workflow budget reached") : makeResult("stopped"));
@@ -687,6 +692,7 @@ export default function createExecutor(ledgers, options = {}) {
         await (await outbox).send(envelope.to, envelope.kind, envelope.body, envelope.cond, { rid: String(e.rid2) });
     }
     return {
+        async reconfigure(apply) { await serial(apply); wake(); },
         run(ticket) {
             const existing = completed.get(ticket.callId);
             if (existing)

package/dist/orchestrator/executor/observe.js

@@ -123,7 +123,7 @@ export async function observeExecution(d) {
             }
         });
     });
-    let scanning = false, scanFailures = 0;
+    let scanning = false, failingSince;
     const scan = () => {
         if (scanning)
             return;
@@ -133,12 +133,14 @@ export async function observeExecution(d) {
                 // One failed process-table scan is no evidence, not a reason to fence a live child: on macOS `ps` can miss its
                 // 2 s deadline right after the orchestrator was stopped or the machine slept (seen on CI as a spurious loss and
                 // a rerun). Only a scan that keeps failing for a minute ends the observation.
+                // Measured in elapsed time: the scan period is fixed at start while k.trackerMs can be reloaded.
                 try {
                     clock.scan(await d.track());
-                    scanFailures = 0;
+                    failingSince = undefined;
                 }
                 catch (error) {
-                    if (++scanFailures * (config.k?.trackerMs ?? 1000) >= 60_000)
+                    failingSince ??= performance.now();
+                    if (performance.now() - failingSince >= 60_000)
                         throw error;
                 }
                 const nextSize = (await fileStat(session).catch(() => ({ size: 0 }))).size;

package/dist/orchestrator/main.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { mkdir, readFile } from 'node:fs/promises';
+import { mkdir } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -14,6 +14,7 @@ import { dsaHome, orchLedger, orchLock } from "../paths.js";
 import { openJournal } from "../kernel/journal.js";
 import { OsLock } from "../platform/lock.js";
 import { Engine } from "./engine.js";
+import { configPath, configProblem, configStamp, readConfig, recordConfig, watchConfig } from "./config.js";
 /** P2, C4, K6: Acquire the single authority before opening ledgers, recover, and idle-exit. */
 export async function main(options = {}) {
     const home = options.home ?? dsaHome();
@@ -21,27 +22,34 @@ export async function main(options = {}) {
     const lock = await new OsLock().tryAcquire(orchLock(home));
     if (!lock)
         return;
-    let engine, ledgers;
+    let engine, ledgers, watcher;
     try {
-        let config = options.config;
+        let config = options.config, stamp;
         if (!config) {
-            try {
-                config = JSON.parse(await readFile(join(home, 'config.json'), 'utf8'));
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-                config = {};
-            }
+            // The stamp is taken before the read: a change made while reading is applied by the first check.
+            stamp = await configStamp(configPath(home));
+            const raw = await readConfig(configPath(home));
+            const problem = configProblem(raw);
+            if (problem)
+                console.error(`durable-subagents: config.json: ${problem}`);
+            config = raw;
         }
         ledgers = { home, config, orch: await openJournal(orchLedger(home)) };
         const factory = options.executor ?? (await import(__rewriteRelativeImportExtension(new URL(import.meta.url.endsWith('.ts') ? './executor/index.ts' : './executor/index.js', import.meta.url).href))).default;
-        engine = new Engine(ledgers, factory(ledgers), options);
+        const executor = factory(ledgers);
+        engine = new Engine(ledgers, executor, options);
+        if (stamp !== undefined) {
+            await recordConfig(ledgers.orch, config);
+            // A change applies between slot admissions, so one admission never mixes two versions of the limits.
+            watcher = watchConfig({ path: configPath(home), stamp, config, orch: ledgers.orch, intervalMs: Math.min(1000, config.k?.trackerMs ?? 1000),
+                apply: change => executor.reconfigure ? executor.reconfigure(change) : change() });
+        }
         await engine.recover();
         await engine.loop(options.signal);
     }
     finally {
         try {
+            await watcher?.stop();
             await engine?.close();
         }
         finally {

package/dist/orchestrator/snapshot.js

@@ -76,6 +76,7 @@ export function snapshotFromEntries(wid, entries) {
     const done = terminal?.type === JT.done ? terminal : undefined;
     const calls = new Map();
     const byExec = new Map();
+    const hibernating = new Map(); // callId → exec that decided to hibernate and is not fenced yet
     const resolved = new Set(entries.filter(e => e.type === JT.attentionResolved).map(e => `${e.id}@${e.rev}`));
     const generations = new Set(), retired = new Set();
     const attention = [];
@@ -115,12 +116,29 @@ export function snapshotFromEntries(wid, entries) {
             call.startedAt ??= e.ts;
             call.lastActivity = e.ts;
             byExec.set(call.exec, call);
+            delete call.hibernated;
+            hibernating.delete(call.callId);
+        }
+        else if (e.type === "hibernated") {
+            // The decision to hibernate precedes the fence; the slot is released only once the execution is fenced.
+            const call = calls.get(String(e.call));
+            if (call?.exec && call.exec === e.exec)
+                hibernating.set(call.callId, call.exec);
+        }
+        else if (e.type === "answer-bound" || (e.type === "resumed" && e.call)) {
+            const call = calls.get(String(e.call));
+            if (call) {
+                delete call.hibernated;
+                hibernating.delete(call.callId);
+            }
         }
         else if (e.type === JT.fenced) {
             // A fenced execution without a seal (stop-all, a quit pi, a loss before its continuation) waits to run again.
             const call = byExec.get(String(e.exec));
             if (call && call.phase === "running")
                 call.phase = "queued";
+            if (call && hibernating.get(call.callId) === e.exec)
+                call.hibernated = true;
         }
         else if (e.type === "selected") {
             const call = byExec.get(String(e.exec)), m = e.model;
@@ -158,6 +176,8 @@ export function snapshotFromEntries(wid, entries) {
             call.phase = "sealed";
             call.result = e.result;
             call.endedAt = e.ts;
+            delete call.hibernated;
+            hibernating.delete(call.callId);
         }
         else if (e.type === JT.attention) {
             const item = e.item;
@@ -189,6 +209,9 @@ export function snapshotFromEntries(wid, entries) {
         if (call && (call.phase === "running" || call.phase === "queued"))
             call.phase = "asking"; // a hibernated asker is fenced
     }
+    for (const c of calls.values())
+        if (c.hibernated && c.phase !== "asking")
+            delete c.hibernated;
     const usageOf = (callId) => sealedUsage.get(callId) ?? live.get(callId);
     const list = [...calls.values()];
     const counts = { queued: 0, running: 0, asking: 0, sealed: 0 };
@@ -302,7 +325,7 @@ export function compactWorkflow(wf) {
             const r = c.result, last = r?.output?.split("\n").map(l => l.trim()).filter(Boolean).at(-1);
             return { key: c.key, gen: c.gen, callId: c.callId, phase: c.phase, ...(r ? { status: r.status, ok: r.ok } : {}),
                 ...(c.model ? { model: c.model } : {}), ...(c.tools ? { tools: c.tools } : {}), ...(c.pending ? { pending: c.pending } : {}), ...(c.switching ? { switching: c.switching } : {}), ...(nonzero(c.usage) ? { usage: c.usage } : {}),
-                ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}) };
+                ...(last ? { lastLine: clip(last, 200) } : {}), ...(r?.error ? { error: clip(r.error, 300) } : {}), ...(c.hibernated ? { hibernated: true } : {}) };
         }),
         attention: wf.attention.map(a => ({ id: a.id, rev: a.rev, kind: a.kind, text: clip(a.text, 300), ...(a.call ? { call: a.call } : {}), ...(a.qid ? { qid: a.qid } : {}) })),
         ...(wf.paused ? { paused: true } : {}), ...(wf.followUps ? { followUps: wf.followUps } : {}),
@@ -338,7 +361,8 @@ export function statusView(home, options = {}) {
     const hidden = all.length - shown.length;
     const paused = all.filter(w => w.paused).length;
     return { workflows: shown.map(compactWorkflow), ...(hidden ? { olderFinished: hidden, hint: "status wid=<wid> shows any workflow in detail" } : {}),
-        ...(paused ? { paused: `${paused} workflow${paused > 1 ? "s" : ""} paused (stop-all, drain or a quit pi) since ${new Date(since).toISOString()}; resume continues them (new runs are not affected)` } : {}) };
+        ...(paused ? { paused: `${paused} workflow${paused > 1 ? "s" : ""} paused (stop-all, drain or a quit pi) since ${new Date(since).toISOString()}; resume continues them (new runs are not affected)` } : {}),
+        ...slotsView(home) };
 }
 const FINAL = ["done", "failed", "stopped"];
 /** Finished with nothing left running (a follow-up on a finished workflow is live work). */
@@ -347,6 +371,33 @@ const age = (ms) => ms < 60_000 ? `${Math.max(0, Math.round(ms / 1000))}s` : ms
 const tokens = (u) => { const n = u ? u.input + u.output : 0; return n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n); };
 /** The latest generation of every key, in first-call order. */
 const latestCalls = (wf) => [...new Map(wf.calls.map(c => [c.key, c])).values()];
+/** Provider slots from the orchestrator ledger: holders per provider (hold/release{pool,slot,exec}) and the limits of
+ *  the settings in effect (the latest config{hash,config}); config-rejected after it is reported too. */
+export function slotsView(home, now = Date.now()) {
+    const held = new Map();
+    let config, rejected;
+    for (const e of readJournalSnapshot(orchLedger(home))) {
+        if (e.type === "hold")
+            held.set(`${e.pool}:${e.slot}`, e);
+        else if (e.type === "release" && held.get(`${e.pool}:${e.slot}`)?.exec === e.exec)
+            held.delete(`${e.pool}:${e.slot}`);
+        else if (e.type === "config") {
+            config = e;
+            rejected = undefined;
+        }
+        else if (e.type === "config-rejected")
+            rejected = e;
+    }
+    const limits = (config?.config?.providers) ?? {};
+    const holders = new Map();
+    for (const e of held.values())
+        if (e.pool !== "memory")
+            holders.set(String(e.pool), (holders.get(String(e.pool)) ?? 0) + 1);
+    const names = [...new Set([...Object.keys(limits), ...holders.keys()])].sort();
+    const slots = names.map(p => { const n = holders.get(p) ?? 0, limit = limits[p]?.slots; return typeof limit === "number" ? `${p} ${n}/${limit}` : `${p} ${n} (no limit)`; });
+    return { ...(slots.length ? { slots } : {}), ...(config ? { config: `${String(config.hash)} since ${age(now - config.ts)} ago` } : {}),
+        ...(rejected ? { configRejected: `${clip(String(rejected.error), 200)} (${age(now - rejected.ts)} ago); ${config ? String(config.hash) : "the start settings"} stay in effect` } : {}) };
+}
 /** Tool status without a wid: what runs, what waits for an answer and what failed, with finished workflows one line each.
  *  The full view (every call's last line and usage) ran to tens of thousands of tokens on a busy home. */
 export function statusBrief(home, options = {}) {
@@ -366,9 +417,11 @@ export function statusBrief(home, options = {}) {
                 ...(live && c.startedAt !== undefined ? { for: age(now - c.startedAt) } : {}),
                 ...(live && c.phase !== "asking" && quiet !== undefined && quiet >= 60_000 ? { quiet: age(quiet) } : {}),
                 ...(live && c.startedAt !== undefined ? { tokens: tokens(c.usage) } : {}),
-                ...(c.result ? { status: c.result.status, ...(c.result.error ? { error: clip(c.result.error, 200) } : {}) } : {}) };
+                ...(c.result ? { status: c.result.status, ...(c.result.error ? { error: clip(c.result.error, 200) } : {}) } : {}),
+                ...(c.hibernated ? { hibernated: true } : {}) };
         });
-        const asking = open.filter(a => a.kind === "question" && a.call).map(a => ({ to: `${w.wid}/${callKey(a.call)}`, ...(a.qid ? { qid: a.qid } : {}), question: clip(a.text, 300) }));
+        const asking = open.filter(a => a.kind === "question" && a.call).map(a => ({ to: `${w.wid}/${callKey(a.call)}`, ...(a.qid ? { qid: a.qid } : {}),
+            ...(w.calls.some(c => c.callId === a.call && c.hibernated) ? { hibernated: true } : {}), question: clip(a.text, 300) }));
         const alerts = open.filter(a => a.kind !== "question").map(a => `${a.kind}${a.call ? ` ${w.wid}/${callKey(a.call)}` : ""}: ${clip(a.text, 200)}`);
         return { wid: w.wid, ...(w.name ? { name: w.name } : {}), status: w.status, ...(w.paused ? { paused: true } : {}), ...(w.followUps ? { followUps: w.followUps } : {}),
             progress: `${p.done}/${p.total}${p.plus ? "+" : ""}`, tokens: tokens(w.usage), calls,
@@ -383,7 +436,7 @@ export function statusBrief(home, options = {}) {
     return {
         active: active.filter(mine).map(brief), ...(others.length ? { otherSessions: others.slice(0, 10).map(line) } : {}),
         finished: finished.slice(0, keep).map(line), ...(finished.length > keep ? { olderFinished: finished.length - keep } : {}),
-        ...(paused ? { paused } : {}),
+        ...(paused ? { paused } : {}), ...slotsView(home, now),
         hint: "status wid=<wid> shows one workflow (outputs clipped); add key=<key> for one call's full result, or full:true for everything",
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-durable-subagents",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "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",