mixdog 1.3.3 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",
@@ -153,7 +153,7 @@
     "arm64"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.105.0",
+    "@anthropic-ai/sdk": "^0.135.0",
     "@formulajs/formulajs": "^4.6.1",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/transformers": "^4.3.1",

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-client-version.mjs

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.308';
+export const DEFAULT_CLI_VERSION = '2.1.309';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

package/src/runtime/shared/agent-room-host.mjs

@@ -30,7 +30,7 @@ function hosts() {
  *   resolves the turn's end status ('done' when it finished).
  * - `stop(roomSessionId)` → boolean: the room's stop button: the speaking
  *   member's turn is cancelled, queued calls settle cancelled, and no one else
- *   gets a turn; true when an exchange was running.
+ *   gets a turn; true when an exchange or incoming request was cancelled.
  * `hop`: the send's or report's place in a bot-to-bot chain (bot-hops.mjs);
  * the member's turn carries it, so the sends it makes count on from there.
  * `follow(submissionId)` (both): the turn that answers is submitted under

package/src/runtime/shared/llm/usage-rollup.mjs

@@ -1,78 +1,15 @@
 /**
- * Durable per-day usage rollup (provider × model).
- *
- * The gateway usage store keeps one raw event per turn, but it is bounded to a
- * recent window (TTL + row cap) because it exists to answer "what is happening
- * right now". Totals for a month ago cannot be recovered from it once the cap
- * evicts those rows, so every turn is ALSO folded into a per-day bucket here.
- * A bucket is a few numbers, which keeps years of history in one small file.
- *
- * Most turns on this machine are NOT the user typing: background runners
- * (memory cycles, schedules, webhooks) spend tokens on their own and outnumber
- * conversation turns several times over. Every bucket therefore carries a
- * `conversation` sub-total beside the full one, so "what did I spend" can be
- * answered without the background drowning it.
- *
- * Session token totals are kept id-keyed only while a day is recent; older days
- * keep the anonymous per-session totals alone. Only conversation sessions are
- * tracked: a background runner mints a fresh id per cycle, which would turn
- * "how many sessions" into a count of cycles.
- *
- * `firstTs`/`lastTs` bound the turns already folded into a day. A reader that
- * also holds the raw event list adds ONLY the events outside that span, which
- * is what lets both stores be read together without counting a turn twice.
- *
- * Shape:
- *   {
- *     version, updatedAt,
- *     days: {
- *       "2026-08-12": {
- *         turns, input, output, cacheRead, cacheWrite,
- *         costUsd, costBilled, costEstimated, costKnownTurns,
- *         durationMs, durationTurns, firstTs, lastTs,
- *         conversation: { …the same turn totals, user-driven turns only },
- *         conversationPartial,
- *         models: { "<provider>/<model>": {
- *           provider, model, kind, turns, input, output, cacheRead, cacheWrite,
- *           costUsd, conversation: { …route totals }
- *         } },
- *         sessions: { "<sessionId>": <tokens> },
- *         sessionTokens: [<tokens>, …],
- *         sessionsDropped
- *       }
- *     }
- *   }
+ * Day keys, conversation-source classification and numeric helpers shared by the
+ * usage ledger and the stats model. The daily JSON rollup these helpers were
+ * written for is no longer produced; its past day records are still imported
+ * by usage-ledger-import.mjs.
  */
-import { billableInputTokensForProvider } from './cost.mjs';
-
-const USAGE_ROLLUP_VERSION = 2;
-
-// A day costs well under a kilobyte, so a long retention stays cheap while
-// making "all time" mean something closer to the install date.
-const RETENTION_DAYS = 400;
-// Session ids are the only identifying values in the file; drop them once the
-// day is old enough that per-session drill-down no longer matters.
-const SESSION_DETAIL_DAYS = 45;
-const MAX_MODELS_PER_DAY = 80;
-const MAX_SESSION_IDS_PER_DAY = 400;
-const MAX_SESSION_TOKENS_PER_DAY = 400;
-const DAY_MS = 24 * 60 * 60 * 1000;
-const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 
 export function num(value) {
   const n = Number(value);
   return Number.isFinite(n) && n > 0 ? n : 0;
 }
 
-export function cleanId(value) {
-  const text = typeof value === 'string' ? value.trim() : '';
-  return text && !UNSAFE_KEYS.has(text) ? text.slice(0, 200) : '';
-}
-
-export function round6(value) {
-  return Math.round(value * 1e6) / 1e6;
-}
-
 /** Local calendar day, so "today" in the UI means the user's today. */
 export function usageRollupDayKey(ts) {
   const date = new Date(Number.isFinite(Number(ts)) ? Number(ts) : Date.now());
@@ -92,324 +29,8 @@ export function isConversationUsageSource(sourceType) {
   return !BACKGROUND_SOURCES.has(id);
 }
 
-function emptyRouteTotals() {
-  return {
-    turns: 0,
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    costUsd: 0,
-    costBilled: 0,
-    costEstimated: 0,
-    costKnownTurns: 0,
-  };
-}
-
-function emptyTurnTotals() {
-  return {
-    ...emptyRouteTotals(),
-    durationMs: 0,
-    durationTurns: 0,
-  };
-}
-
-function addRouteTotals(target, turn, { priced, billed } = {}) {
-  target.turns += turn.turns;
-  target.input += turn.input;
-  target.output += turn.output;
-  target.cacheRead += turn.cacheRead;
-  target.cacheWrite += turn.cacheWrite;
-  target.costUsd = round6(target.costUsd + turn.costUsd);
-  if (priced) {
-    target.costKnownTurns += 1;
-    if (billed) target.costBilled = round6(target.costBilled + turn.costUsd);
-    else target.costEstimated = round6(target.costEstimated + turn.costUsd);
-  }
-}
-
-function addTurnTotals(target, turn, pricing) {
-  addRouteTotals(target, turn, pricing);
-  const { durationMs } = pricing;
-  if (durationMs > 0) {
-    target.durationMs += durationMs;
-    target.durationTurns += 1;
-  }
-}
-
-function emptyModel(provider, model) {
-  return {
-    provider,
-    model,
-    kind: '',
-    ...emptyRouteTotals(),
-    conversation: emptyRouteTotals(),
-  };
-}
-
-function emptyDay() {
-  return {
-    ...emptyTurnTotals(),
-    firstTs: 0,
-    lastTs: 0,
-    conversation: emptyTurnTotals(),
-    conversationPartial: false,
-    // Rebuilt from session transcripts rather than recorded turn by turn. The
-    // flag travels with the bucket so a surface can keep saying so long after
-    // the transcripts it came from are gone.
-    restored: false,
-    // Set once a day's pre-classification session ids have been cleared, which
-    // is what tells a reader the remaining ids can be trusted.
-    sessionsPurged: true,
-    models: {},
-    sessions: {},
-    sessionTokens: [],
-    sessionsDropped: 0,
-  };
-}
-
-function readRouteTotals(raw, target) {
-  target.turns = num(raw?.turns);
-  target.input = num(raw?.input);
-  target.output = num(raw?.output);
-  target.cacheRead = num(raw?.cacheRead);
-  target.cacheWrite = num(raw?.cacheWrite);
-  target.costUsd = round6(num(raw?.costUsd));
-  target.costBilled = round6(num(raw?.costBilled));
-  target.costEstimated = round6(
-    raw?.costEstimated == null ? Math.max(0, target.costUsd - target.costBilled) : num(raw.costEstimated)
-  );
-  if (raw?.costKnownTurns != null) target.costKnownTurns = num(raw.costKnownTurns);
-  else target.costKnownTurns = target.costUsd > 0 ? target.turns : 0;
-  return target;
-}
-
 /** Turns with a known cost: the recorded count, else every turn when the usage carries any cost at all. */
 export function knownCostTurns(usage, amount = num) {
   if (usage.costKnownTurns != null) return amount(usage.costKnownTurns);
   return amount(usage.costUsd) > 0 ? amount(usage.turns) : 0;
 }
-
-function readTurnTotals(raw, target) {
-  readRouteTotals(raw, target);
-  target.costEstimated = round6(num(raw?.costEstimated));
-  target.costKnownTurns = num(raw?.costKnownTurns);
-  target.durationMs = num(raw?.durationMs);
-  target.durationTurns = num(raw?.durationTurns);
-  return target;
-}
-
-function normalizeModel(raw, key) {
-  const slash = typeof key === 'string' ? key.indexOf('/') : -1;
-  const bucket = emptyModel(
-    cleanId(raw?.provider) || (slash > 0 ? key.slice(0, slash) : ''),
-    cleanId(raw?.model) || (slash > 0 ? key.slice(slash + 1) : '')
-  );
-  bucket.kind = cleanId(raw?.kind);
-  readRouteTotals(raw, bucket);
-  // A bucket written before turns carried a source has no split to read.
-  // `null` means unknown, which a reader must not quietly treat as zero.
-  bucket.conversation =
-    raw?.conversation && typeof raw.conversation === 'object'
-      ? readRouteTotals(raw.conversation, emptyRouteTotals())
-      : null;
-  return bucket;
-}
-
-function normalizeDay(raw) {
-  const day = emptyDay();
-  readTurnTotals(raw, day);
-  day.firstTs = num(raw?.firstTs);
-  day.lastTs = num(raw?.lastTs);
-  day.conversation =
-    raw?.conversation && typeof raw.conversation === 'object'
-      ? readTurnTotals(raw.conversation, emptyTurnTotals())
-      : null;
-  day.conversationPartial = raw?.conversationPartial === true;
-  day.restored = raw?.restored === true;
-  // A day that never held unclassified turns needs no purge; one that did is
-  // trusted only once it says the old ids were cleared.
-  day.sessionsPurged = !day.conversationPartial || raw?.sessionsPurged === true;
-  day.sessionsDropped = num(raw?.sessionsDropped);
-  const models = raw?.models && typeof raw.models === 'object' ? raw.models : {};
-  for (const [key, value] of Object.entries(models)) {
-    const id = cleanId(key);
-    if (!id) continue;
-    day.models[id] = normalizeModel(value, id);
-  }
-  const sessions = raw?.sessions && typeof raw.sessions === 'object' ? raw.sessions : {};
-  for (const [key, value] of Object.entries(sessions)) {
-    const id = cleanId(key);
-    if (!id) continue;
-    day.sessions[id] = num(value);
-  }
-  if (Array.isArray(raw?.sessionTokens)) {
-    day.sessionTokens = raw.sessionTokens.map(num).slice(-MAX_SESSION_TOKENS_PER_DAY);
-  }
-  return day;
-}
-
-/** Defensive read: a hand-edited or partially written file must not throw. */
-export function normalizeUsageRollup(raw) {
-  const days = {};
-  const source = raw?.days && typeof raw.days === 'object' ? raw.days : {};
-  for (const [key, value] of Object.entries(source)) {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(key)) continue;
-    days[key] = normalizeDay(value);
-  }
-  return {
-    version: USAGE_ROLLUP_VERSION,
-    updatedAt: num(raw?.updatedAt),
-    days,
-  };
-}
-
-/** Retention + identifier aging. Both bounds are evaluated against `now`. */
-function pruneUsageRollup(rollup, now = Date.now()) {
-  const dropBefore = usageRollupDayKey(now - RETENTION_DAYS * DAY_MS);
-  const anonymizeBefore = usageRollupDayKey(now - SESSION_DETAIL_DAYS * DAY_MS);
-  for (const [key, day] of Object.entries(rollup.days)) {
-    if (key < dropBefore) {
-      delete rollup.days[key];
-      continue;
-    }
-    if (key >= anonymizeBefore) continue;
-    const ids = Object.keys(day.sessions);
-    if (!ids.length) continue;
-    const archived = day.sessionTokens.concat(ids.map((id) => day.sessions[id]));
-    day.sessionTokens = archived.slice(-MAX_SESSION_TOKENS_PER_DAY);
-    day.sessions = {};
-  }
-  return rollup;
-}
-
-/**
- * Fold one gateway usage summary into the rollup. Pure: the caller owns the
- * document, which is what makes this testable without touching disk.
- */
-export function foldUsageRollup(current, summary, now = Date.now()) {
-  const rollup = normalizeUsageRollup(current);
-  const provider = cleanId(summary?.provider);
-  const model = cleanId(summary?.model);
-  // A turn that cannot be attributed to a route would silently inflate every
-  // total it lands in, so it is dropped rather than bucketed as "unknown".
-  if (!provider || !model) return pruneUsageRollup(rollup, now);
-
-  const at = Number(summary?.ts ?? summary?.at);
-  const ts = Number.isFinite(at) && at > 0 ? at : now;
-  const key = usageRollupDayKey(ts);
-  const day = rollup.days[key] || emptyDay();
-
-  const cacheRead = num(summary?.cacheReadTokens);
-  const cacheWrite = num(summary?.cacheWriteTokens);
-  const turn = {
-    turns: 1,
-    // Providers disagree about what `inputTokens` counts: several report the
-    // whole prompt with the cached part inside it. Stripping it where it is
-    // already included is what keeps one cache hit from being counted twice.
-    input: billableInputTokensForProvider(provider, num(summary?.inputTokens), cacheRead, cacheWrite),
-    output: num(summary?.outputTokens),
-    cacheRead,
-    cacheWrite,
-    costUsd: num(summary?.costUsd),
-  };
-  const tokens = turn.input + turn.output + turn.cacheRead + turn.cacheWrite;
-  const costSource = cleanId(summary?.costSource);
-  // costSource 'none' means neither the provider nor the catalog priced this
-  // turn; counting it keeps the surface honest about partial cost coverage.
-  const pricing = {
-    priced:
-      summary?.costUsd != null &&
-      Number.isFinite(Number(summary.costUsd)) &&
-      !['', 'none', 'unpriced'].includes(costSource),
-    billed: costSource === 'provider',
-    durationMs: num(summary?.durationMs),
-  };
-  const conversation = isConversationUsageSource(summary?.sourceType);
-
-  addTurnTotals(day, turn, pricing);
-  day.firstTs = day.firstTs > 0 ? Math.min(day.firstTs, ts) : ts;
-  day.lastTs = Math.max(day.lastTs, ts);
-  if (conversation) {
-    if (!day.conversation) {
-      // A day carried over from before turns were classified: what is already
-      // in it stays unattributed, and the flag lets a reader say so.
-      day.conversation = emptyTurnTotals();
-      day.conversationPartial = true;
-      // Those ids were collected while background cycles still counted, and
-      // most of them are cycles. Keeping them would report cycles as sessions.
-      day.sessions = {};
-      day.sessionTokens = [];
-      day.sessionsPurged = true;
-    }
-    addTurnTotals(day.conversation, turn, pricing);
-  }
-
-  const modelKey = `${provider}/${model}`;
-  const known = Object.hasOwn(day.models, modelKey);
-  if (known || Object.keys(day.models).length < MAX_MODELS_PER_DAY) {
-    const bucket = known ? day.models[modelKey] : emptyModel(provider, model);
-    bucket.kind = cleanId(summary?.providerKind) || bucket.kind;
-    addRouteTotals(bucket, turn, pricing);
-    if (conversation) {
-      if (!bucket.conversation) bucket.conversation = emptyRouteTotals();
-      addRouteTotals(bucket.conversation, turn, pricing);
-    }
-    day.models[modelKey] = bucket;
-  }
-
-  // Only conversation sessions are kept: a background runner mints a new id per
-  // cycle, so counting those would report cycles as sessions.
-  const sessionId = conversation ? cleanId(summary?.sessionId) : '';
-  if (sessionId) {
-    if (Object.hasOwn(day.sessions, sessionId)) {
-      day.sessions[sessionId] += tokens;
-    } else if (Object.keys(day.sessions).length < MAX_SESSION_IDS_PER_DAY) {
-      day.sessions[sessionId] = tokens;
-    } else {
-      day.sessionsDropped += 1;
-    }
-  }
-
-  rollup.days[key] = day;
-  rollup.updatedAt = now;
-  return pruneUsageRollup(rollup, now);
-}
-
-/**
- * Write transcript-rebuilt days into the rollup, so they outlive the sessions
- * they were derived from.
- *
- * The session store prunes: ephemeral sessions past 14 days or beyond the
- * newest 300 are deleted, which silently takes their tokens out of any figure
- * derived from them. The rollup is a few numbers per day kept for 400 days, so
- * once a rebuilt day lands here it stops depending on the transcripts at all.
- *
- * Recording always wins. A day the rollup already holds is left exactly as it
- * is — including a day already frozen this way, because re-deriving it from a
- * half-pruned store would quietly shrink it.
- *
- * Pure: the caller owns the document.
- */
-export function freezeRestoredDays(current, historyDays, now = Date.now()) {
-  const rollup = normalizeUsageRollup(current);
-  const source = historyDays && typeof historyDays === 'object' ? historyDays : {};
-  const dropBefore = usageRollupDayKey(now - RETENTION_DAYS * DAY_MS);
-  const today = usageRollupDayKey(now);
-  let frozen = 0;
-  for (const [key, day] of Object.entries(source)) {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(key)) continue;
-    if (Object.hasOwn(rollup.days, key)) continue;
-    if (key < dropBefore) continue;
-    // Today is still being recorded turn by turn; freezing it now would pin a
-    // partial rebuild and lock out the rest of the day's real events.
-    if (key >= today) continue;
-    const bucket = normalizeDay(day);
-    if (bucket.turns <= 0) continue;
-    bucket.restored = true;
-    rollup.days[key] = bucket;
-    frozen += 1;
-  }
-  if (frozen > 0) rollup.updatedAt = now;
-  return { rollup, frozen };
-}

package/src/session-runtime/agent-tool-routing.mjs

@@ -4,12 +4,57 @@
  * status for the facade.
  */
 
-export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null }) {
+import { clean } from '../runtime/shared/clean.mjs';
+
+const lower = (value) => clean(value).toLowerCase();
+
+// A pinned model named by its catalog display name ("GPT-6.1-Sol") is not a
+// wire id. Canonicalize it only on an unambiguous EXACT match: the id itself,
+// or a display name / label, case-insensitively, within the requested provider
+// (or across providers when none is given and exactly one row matches).
+// Anything else — no match, several matches, an empty or partial catalog —
+// returns the args unchanged: the catalog never refuses a model and never
+// substitutes a near one.
+export function canonicalizePinnedModel(args, rows) {
+  const model = clean(args?.model);
+  if (!model || !Array.isArray(rows)) return args;
+  const provider = lower(args.provider);
+  const pool = rows.filter((row) => row && (!provider || lower(row.provider) === provider));
+  const wanted = model.toLowerCase();
+  const exactId = pool.filter((row) => row.id === model);
+  // A partial catalog may lack the real id a display name collides with, so
+  // only an exact id can pass there; aliases wait for a complete catalog.
+  const partial = pool.some((row) => row.catalogPartial === true);
+  const hits = exactId.length
+    ? exactId
+    : partial
+      ? []
+      : pool.filter((row) => lower(row.id) === wanted || lower(row.display) === wanted || lower(row.label) === wanted);
+  const distinct = [...new Map(hits.map((row) => [`${row.provider}\n${row.id}`, row])).values()];
+  if (distinct.length !== 1) return args;
+  const [hit] = distinct;
+  if (hit.id === model && hit.provider === args.provider) return args;
+  return { ...args, provider: hit.provider, model: hit.id };
+}
+
+// `listProviderModels` is this runtime's provider catalog. The agent control
+// behind `executeAgentControl` (the daemon's canonical agent) has none, so a
+// display-name model is canonicalized here before it is forwarded. Only the
+// cached/quick catalog is read, so a spawn never waits on provider listings.
+export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null, listProviderModels = null }) {
   const routedAgentTool = {
     ...agentTool,
-    execute(args, context = {}) {
-      if (typeof executeAgentControl === 'function') return executeAgentControl(args, context);
-      return agentTool.execute(args, context);
+    async execute(args, context = {}) {
+      if (typeof executeAgentControl !== 'function') return agentTool.execute(args, context);
+      let routedArgs = args;
+      if (typeof listProviderModels === 'function' && clean(args?.model) && (clean(args.type) || 'spawn') === 'spawn') {
+        try {
+          routedArgs = canonicalizePinnedModel(args, await listProviderModels({ quick: true }));
+        } catch {
+          routedArgs = args;
+        }
+      }
+      return executeAgentControl(routedArgs, context);
     },
     closeAll(reason, scope = {}) {
       if (typeof executeAgentControl !== 'function') {

package/src/session-runtime/boot/tools.mjs

@@ -98,6 +98,8 @@ function wireAgent(boot) {
     rt,
     agentTool,
     executeAgentControl: params.executeAgentControl,
+    // Lazy, as above.
+    listProviderModels: (options) => boot.collectProviderModels(options),
   });
   bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
   Object.assign(boot, { agentTool, routedAgentTool, agentStatusState });

package/src/session-runtime/services/agent-tool/close-flow.mjs

@@ -5,7 +5,7 @@ import {
   listBackgroundTasks,
   taskIdFromArgs,
 } from '../../../runtime/shared/background-tasks.mjs';
-import { agentScope, clean, clearAgentStatuslineRoute } from './helpers.mjs';
+import { agentScope, clean, clearAgentStatuslineRoute, sessionMatchesContext } from './helpers.mjs';
 import { isLeadPoolAgent } from './worker-rows.mjs';
 import { createCloseAll } from './close-flow/close-all.mjs';
 import { closeManagedSession } from '../../lifecycle/shared.mjs';
@@ -20,6 +20,16 @@ export function createCloseFlow({ mgr, registry, views }) {
   // Stale local metadata only: resolveTag found no session in this
   // terminal/scope, so there is no sessionId-safe worker row to delete. Never
   // turn it into a tag-wide persisted-row removal.
+  // `tags`/`tagAgents` are shared by every caller on the canonical agent, so a
+  // binding alone does not prove the caller owns it: only a live session or a
+  // persisted row inside the caller's scope does. Another session's tag must
+  // stay untouched.
+  function tagBoundByCaller(target, scopedContext) {
+    const live = registry.getLiveSession(tags.get(target));
+    if (live) return sessionMatchesContext(live, scopedContext);
+    return registry.readWorkerRows(scopedContext).some((row) => clean(row.tag) === target);
+  }
+
   function forgetStaleLocalTag(target, task) {
     registry.unbindTag(target);
     if (task?.taskId) cancelBackgroundTask(task.taskId, CLOSE_REASON);
@@ -55,7 +65,9 @@ export function createCloseFlow({ mgr, registry, views }) {
     }
     const sessionId = registry.resolveTag(target, scopedContext, { scanSessions: registry.wantsSessionScan(args) });
     if (!sessionId) {
-      if (!target.startsWith('sess_') && tagAgents.has(target)) return forgetStaleLocalTag(target, task);
+      if (!target.startsWith('sess_') && tagAgents.has(target) && tagBoundByCaller(target, scopedContext)) {
+        return forgetStaleLocalTag(target, task);
+      }
       throw new Error(`agent close: target "${target}" not found`);
     }
     if (isLeadPoolAgent(registry.getLiveSession(sessionId)?.agent)) {

package/src/session-runtime/services/agent-tool/execute.mjs

@@ -67,7 +67,12 @@ export function createAgentExecute({
           }
           // Targetless status is the same compact overview as list.
           return renderResult({
-            workers: views.list({ scanSessions: registry.wantsSessionScan(args), context: scopedContext }),
+            // Idle workers stay open for follow-ups; the model must see them to close them.
+            workers: views.list({
+              scanSessions: registry.wantsSessionScan(args),
+              context: scopedContext,
+              includeIdle: true,
+            }),
             jobs: views.listJobs(scopedContext),
           });
         case 'read':

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -25,6 +25,14 @@ export function isActiveWorkerRow(row = {}) {
   return !isTerminalWorkerStatus(effective);
 }
 
+// A finished worker that is still open: it takes follow-ups and can be closed.
+function isOpenIdleRow(row = {}) {
+  const status = String(row.status ?? '').trim().toLowerCase();
+  const stage = String(row.stage ?? '').trim().toLowerCase();
+  if (CANCELLED_WORKER_STATUS.test(stage) || CANCELLED_WORKER_STATUS.test(status)) return false;
+  return (status || stage) === 'idle';
+}
+
 function rowState(session, runtime) {
   const status = session.closed === true ? 'closed' : session.status || 'idle';
   const stage =
@@ -78,7 +86,7 @@ function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
 }
 
 export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntries, progress }) {
-  return function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
+  return function list({ scanSessions = false, context = {}, includeTerminal = false, includeIdle = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
     const rows = [];
@@ -89,7 +97,8 @@ export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntr
       // loads the worker's stored session, and a Lead's status pulse (every
       // 2 s) would otherwise read every worker it ever ran, whole transcripts
       // on first sight, synchronously on the daemon loop.
-      if (!includeTerminal && !isActiveWorkerRow(rowState(session, runtime))) continue;
+      const state = rowState(session, runtime);
+      if (!includeTerminal && !isActiveWorkerRow(state) && !(includeIdle && isOpenIdleRow(state))) continue;
       rows.push(
         agentRow({
           tag,

package/src/session-runtime/services/agent-tool/render.mjs

@@ -156,9 +156,11 @@ export function renderResult(value, { includeDiagnostics = false } = {}) {
   if (typeof value === 'string') return value;
   if (value && typeof value === 'object') {
     if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value);
+    // close-flow results carry `closed` plus task_id: render the close outcome.
+    // close-flow results carry `closed` plus task_id: render the close outcome.
+    if (value.closed !== undefined) return renderClosed(value);
     if (value.task_id) return renderTask(value, includeDiagnostics);
     if (value.queued) return renderQueued(value);
-    if (value.closed !== undefined) return renderClosed(value);
     if (value.content !== undefined) return renderContent(value);
   }
   return JSON.stringify(value, null, 2);

package/src/session-runtime/services/agent-tool/tool-def.mjs

@@ -28,7 +28,7 @@ export const AGENT_TOOL = {
     agentHidden: false,
   },
   description:
-    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery.',
+    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery. Close finished agents yourself.',
   inputSchema: {
     type: 'object',
     properties: {

package/src/session-runtime/usage-stats-api.mjs

@@ -203,7 +203,7 @@ export function createUsageStatsApi({
       // beyond a clock captured before the import started.
       const now = Date.now();
       const period = usagePeriodFor(options, now);
-      // The rollup query runs off the event loop (usage-rollup-worker.mjs).
+      // The rollup query runs off the event loop (usage-ledger-worker.mjs).
       const rollup = await store.rollupAsync(usageRollupQuery(period));
       // The ledger returns the same rollup object while nothing was committed
       // (and while a rolling window lost no record), so identical back-to-back