mixdog 1.4.0 → 1.4.1

package/src/session-runtime/agent-task-sessions.mjs

@@ -15,6 +15,12 @@
  * answer or approval posts one faint line instead; the card stays in the task
  * session for the user.
  *
+ * Whether a turn reports is apart from whose work it is: every accepted send
+ * of an agent is the agent's work in that session (bot-owned-work.mjs, shown
+ * as the bot working) until its chain ends, the point a report would be
+ * final, and with `notify: false` or an unstored watch it reports nothing.
+ * A turn the user types there is owned by no agent.
+ *
  * An agent's send to any other session reports the same way, by an origin for
  * that send only (reportOrigin). Every reporting turn is also watched durably
  * (agent-home-delivery.mjs `watches`) until its end is queued, so a daemon
@@ -41,6 +47,7 @@ import { wrapAgentMessage } from '../runtime/shared/agent-message-envelope.mjs';
 import { hasPendingAgentWork, sessionsWithPendingWork } from '../runtime/shared/pending-agent-work.mjs';
 import { agentTaskIdOfExecution } from './services/agent-tool/restart-notify.mjs';
 import { botChainOf } from '../runtime/shared/bot-hops.mjs';
+import { endBotWork, noteBotWork } from '../runtime/shared/bot-owned-work.mjs';
 import { worktreeError, worktreeNameError } from '../runtime/shared/worktrees/contract.mjs';
 import { samePath } from '../runtime/shared/worktrees/paths.mjs';
 import { readModelCatalog, routeByDisplayName, withEffort } from './task-session-route.mjs';
@@ -813,17 +820,24 @@ async function sendReportOrigin({ loadSession, agentName }, sessionId, agentId,
 }
 
 /** Re-attach one watch a stopped daemon left: report the turn's end once
- *  from the target's record, or watch it until it ends. */
+ *  from the target's record, or watch it until it ends. `quiet`: `watch` is
+ *  the record of work that reports nothing (no home, no title): the same
+ *  follow, but its end is only the end of the agent's work, dropped from
+ *  `disown`, and no progress update or report goes out. */
 async function rearmTaskWatch(
-  { deliver, loadSession, materializeSession, queuedSubmissionIds, artifactFields, followToFinal, log },
-  watch
+  { deliver, disown, loadSession, materializeSession, queuedSubmissionIds, artifactFields, followToFinal, log },
+  watch,
+  { quiet = false } = {}
 ) {
   const sessionId = watch.taskSessionId;
   // The turn that answers: the watched submission's own, or the one it
   // follows (a room member's turn under another submission id).
   const turnId = watch.follows || watch.runId;
-  const finish = async (status, text = '', answerId = '') =>
-    deliver(watch.agentId, {
+  // The work is the agent's until its end is reported (or cannot be).
+  const finish = async (status, text = '', answerId = '') => {
+    endBotWork(watch.runId);
+    if (quiet) return disown(watch.runId);
+    return deliver(watch.agentId, {
       runId: `${watch.runId}_end`,
       taskSessionId: sessionId,
       title: watch.title,
@@ -836,6 +850,7 @@ async function rearmTaskWatch(
       ...progressOf(watch.runId, answerId),
       ...(watch.textOnly || text === GONE_TEXT || text === LOST_TEXT ? {} : await artifactFields(sessionId, turnId)),
     });
+  };
   if (!(await loadSession(sessionId))) return finish('cancelled', GONE_TEXT);
   let runtime;
   try {
@@ -845,6 +860,7 @@ async function rearmTaskWatch(
     log(`${sessionId} could not be loaded after the restart: ${error?.message || error}`);
     return finish('failed', RESUME_FAILED_TEXT);
   }
+  noteBotWork({ runId: watch.runId, sessionId, agentId: watch.agentId });
   let done = false;
   let checking = false;
   let again = false;
@@ -878,22 +894,26 @@ async function rearmTaskWatch(
             sessionId,
             runId: turnId,
             runtime,
-            wakeOwed: true,
+            // Only a report wakes the session for the results the restart left
+            // it; work that reports nothing is only observed, never driven.
+            wakeOwed: !quiet,
             // The turns an earlier process already reported as progress.
             progressedThrough: watch.progressed || '',
-            interim: (answer) =>
-              deliver(watch.agentId, {
-                runId: progressRunId(watch.runId, answer.id),
-                taskSessionId: sessionId,
-                title: watch.title,
-                status: 'working',
-                text: answer.text,
-                progressWatchId: watch.runId,
-                answerId: answer.id,
-                ...(watch.target === 'session' ? { target: 'session' } : {}),
-                ...(watch.hop > 0 ? { hop: watch.hop } : {}),
-                ...roomFrom(watch.homeSessionId),
-              }),
+            interim: quiet
+              ? null
+              : (answer) =>
+                  deliver(watch.agentId, {
+                    runId: progressRunId(watch.runId, answer.id),
+                    taskSessionId: sessionId,
+                    title: watch.title,
+                    status: 'working',
+                    text: answer.text,
+                    progressWatchId: watch.runId,
+                    answerId: answer.id,
+                    ...(watch.target === 'session' ? { target: 'session' } : {}),
+                    ...(watch.hop > 0 ? { hop: watch.hop } : {}),
+                    ...roomFrom(watch.homeSessionId),
+                  }),
             finish: async (status, text, answerId) => {
               done = true;
               unsubscribe();
@@ -925,13 +945,16 @@ function createSendSettlement(log) {
   const settledTurns = new WeakMap();
   let sendCount = 0;
 
-  /** Add send `member` (`{ seq, id, unwatch, settle }`) to the settlement
+  /** Add send `member` (`{ seq, id, notify, unwatch, settle }`) to the settlement
    *  `detail` of its turn, per reporting conversation. The sends of one turn
    *  settle in the same tick; after it the earliest (the turn's own, whose
    *  record holds the whole turn) settles with all their ids and the others
    *  stand down. */
   function join(detail, origin, member) {
-    const key = `${origin.agentId}\0${origin.sessionId}`;
+    // Sends that report and sends that do not settle apart: the group's first
+    // member settles for the group, so a quiet one must never stand for a
+    // send that owes a report.
+    const key = `${origin.agentId}\0${origin.sessionId}\0${member.notify ? 'report' : 'quiet'}`;
     let groups = settledTurns.get(detail);
     if (!groups) {
       groups = new Map();
@@ -1074,13 +1097,19 @@ function startedGate() {
 export function createAgentTaskSessions({
   getSessionService,
   deliver = async (agentId, report) => (await import('./agent-home-delivery.mjs')).deliverAgentTask(agentId, report),
-  // The durable watch of each reporting turn until its end is queued.
+  // The durable watch of each reporting turn until its end is queued. A bot's
+  // turn that reports nothing (reports off, or a watch that could not be
+  // stored) keeps a record of its work instead (`own`, `owned`, `disown`),
+  // which no report and no hand-off follows: a restart re-attaches both.
   watches = {
     add: async (watch) => (await import('./agent-home-delivery.mjs')).watchAgentTask(watch),
     list: async () => (await import('./agent-home-delivery.mjs')).agentTaskWatches(),
     remove: async (runId) => (await import('./agent-home-delivery.mjs')).unwatchAgentTask(runId),
     follow: async (runId, submissionId) =>
       (await import('./agent-home-delivery.mjs')).followAgentTask(runId, submissionId),
+    own: async (work) => (await import('./agent-home-delivery.mjs')).ownAgentTask(work),
+    owned: async () => (await import('./agent-home-delivery.mjs')).agentOwnedTasks(),
+    disown: async (runId) => (await import('./agent-home-delivery.mjs')).disownAgentTask(runId),
   },
   // Submissions still queued (durably) for a session after a restart.
   queuedSubmissionIds = async (sessionId) =>
@@ -1209,7 +1238,35 @@ export function createAgentTaskSessions({
         log(`report of ${sessionId} failed: ${error?.message || error}`)
       );
     let unwatch = () => {};
-    // Set once the turn ended completed: the report waits for the final answer.
+    // The agent's work in `sessionId`: owned from the send's acceptance until
+    // it settles or is cancelled, whether or not it reports (`notify`). A send
+    // that holds no report watch keeps a durable record of the work instead
+    // (`watches.own`), so a restart re-attaches it (recover); the writes of
+    // one send go in order, so a record never outlives its work.
+    let owning = true;
+    let recorded = false;
+    let recording = Promise.resolve();
+    const record = (write) => {
+      recording = recording
+        .then(write)
+        .catch((error) => log(`recording the work of ${sessionId} failed: ${error?.message || error}`));
+      return recording;
+    };
+    // The work of every send `ids` this turn answered ends together: one
+    // write drops all their records (a send standing down for the turn's
+    // first leaves its record to that one write).
+    const disown = (ids = [id]) => {
+      owning = false;
+      for (const done of ids) endBotWork(done);
+      if (recorded || ids.length > 1) void record(() => watches.disown?.(ids));
+    };
+    const standDown = () => {
+      unwatch();
+      owning = false;
+      endBotWork(id);
+    };
+    // Set once the turn ended completed: the work and any report wait for the
+    // final answer.
     let follow = null;
     let result;
     /** This send ends the turn `detail` for the sends `answered` (createSendSettlement). */
@@ -1217,11 +1274,12 @@ export function createAgentTaskSessions({
       sendIds = answered;
       const status = turnStatus(detail);
       const text = detail?.result?.content || detail?.error || '';
-      // A failed or cancelled turn reports at once; a completed one
-      // reports the task's final answer (followToFinal).
+      // A failed or cancelled turn ends at once; a completed one ends with
+      // the task's final answer (followToFinal).
       if (status !== 'completed') {
         unwatch();
-        void report(status, text);
+        disown(sendIds);
+        if (notify) void report(status, text);
         return;
       }
       follow = followToFinal({
@@ -1231,23 +1289,23 @@ export function createAgentTaskSessions({
         immediate: { status, text },
         finish: async (endStatus, endText, answerId) => {
           unwatch();
-          await report(endStatus, endText, { answerId });
+          disown(sendIds);
+          if (notify) await report(endStatus, endText, { answerId });
         },
-        // Each other answer of its chain: a progress update that wakes nobody.
-        interim: (answer) => deliverReport('working', answer.text, { answerId: answer.id }),
+        // Each other answer of its chain: a progress update that wakes nobody
+        // (only a send that reports gives them).
+        ...(notify ? { interim: (answer) => deliverReport('working', answer.text, { answerId: answer.id }) } : {}),
       });
       follow.check();
     };
     try {
-      if (notify) {
-        runtime = await sessions.materializeSession(sessionId);
-        const onState = approvalWaitReporter(id, report);
-        unwatch =
-          runtime?.subscribe?.(() => {
-            follow?.check();
-            onState(runtime.getState?.() || {});
-          }) || unwatch;
-      }
+      runtime = await sessions.materializeSession(sessionId);
+      const onState = notify ? approvalWaitReporter(id, report) : null;
+      unwatch =
+        runtime?.subscribe?.(() => {
+          follow?.check();
+          onState?.(runtime.getState?.() || {});
+        }) || unwatch;
       // A bot's send to a session that is not its own task session reaches the
       // model inside the sender envelope (`envelopeName`, set by reportOrigin).
       const sent = origin.envelopeName
@@ -1259,39 +1317,55 @@ export function createAgentTaskSessions({
         id,
         mode: 'prompt',
         transcriptMeta: sendTranscriptMeta(origin),
-        ...(notify
-          ? {
-              // A room answers this send in a turn under another submission
-              // id (one turn for several sends, or a fresh turn for one cut
-              // short): the watch follows that turn, recorded before it runs.
-              follow: (submissionId) => watches.follow?.(id, submissionId),
-              onSettled: (detail) =>
-                settlement.join(detail, origin, {
-                  seq,
-                  id,
-                  unwatch: () => unwatch(),
-                  settle: (answered) => settleTurn(detail, answered),
-                }),
-            }
-          : {}),
+        // A room answers this send in a turn under another submission id (one
+        // turn for several sends, or a fresh turn for one cut short): the
+        // watch follows that turn, recorded before it runs.
+        ...(notify ? { follow: (submissionId) => watches.follow?.(id, submissionId) } : {}),
+        onSettled: (detail) =>
+          settlement.join(detail, origin, {
+            seq,
+            id,
+            notify,
+            // Standing down for the turn's first send, which owns the same work.
+            unwatch: standDown,
+            settle: (answered) => settleTurn(detail, answered),
+          }),
       });
     } catch (error) {
       unwatch();
+      disown();
       if (notify) await dropWatch();
       throw error;
     }
     const accepted = result?.accepted === true;
     if (!accepted) {
       unwatch();
+      disown();
       if (notify) await dropWatch();
+    } else if (owning) {
+      // Unless it already settled: nothing then is left to end the work.
+      noteBotWork({ runId: id, sessionId, agentId: origin.agentId });
+      if (!notify) {
+        recorded = true;
+        await record(() =>
+          watches.own?.({
+            runId: id,
+            agentId: origin.agentId,
+            taskSessionId: sessionId,
+            owner: processToken,
+            at: Date.now(),
+          })
+        );
+      }
     }
     return sendResult(accepted, notify, id, noReport);
   }
 
-  const rearm = (watch) =>
+  const rearm = (watch, options) =>
     rearmTaskWatch(
       {
         deliver,
+        disown: async (runId) => watches.disown?.(runId),
         loadSession,
         materializeSession: (sessionId) => service().materializeSession(sessionId),
         queuedSubmissionIds,
@@ -1299,13 +1373,25 @@ export function createAgentTaskSessions({
         followToFinal,
         log,
       },
-      watch
+      watch,
+      options
     );
 
-  /** Daemon start: re-attach every reporting turn an earlier process watched.
+  /** Daemon start: re-attach every reporting turn an earlier process watched,
+   *  and every turn of a bot's that reported nothing but whose work it owned
+   *  (nothing is reported for those, they are only the bot's work again).
    *  Resolves once each is reported or watched. */
   async function recover() {
-    const pending = (await watches.list()).filter((watch) => watch?.owner !== processToken);
+    const earlier = (list) => list.filter((entry) => entry?.owner !== processToken);
+    const pending = earlier(await watches.list());
+    const quiet = earlier(
+      await Promise.resolve(watches.owned?.() ?? [])
+        .then((list) => (Array.isArray(list) ? list : []))
+        .catch((error) => {
+          log(`reading the records of bot work failed: ${error?.message || error}`);
+          return [];
+        })
+    );
     // The agents the restart killed become queued failure results first, so
     // each re-attached task session has them to take (followToFinal wakeOwed).
     if (pending.length) {
@@ -1313,12 +1399,15 @@ export function createAgentTaskSessions({
         .then(settleAgentResults)
         .catch((error) => log(`settling the agents of the previous process failed: ${error?.message || error}`));
     }
-    await Promise.all(
-      pending.map((watch) =>
-        rearm(watch).catch((error) => log(`re-attaching ${watch?.taskSessionId} failed: ${error?.message || error}`))
-      )
-    );
-    return pending.length;
+    const reattach = (work, options) =>
+      rearm(work, options).catch((error) =>
+        log(`re-attaching ${work?.taskSessionId} failed: ${error?.message || error}`)
+      );
+    await Promise.all([
+      ...pending.map((watch) => reattach(watch)),
+      ...quiet.map((work) => reattach(work, { quiet: true })),
+    ]);
+    return pending.length + quiet.length;
   }
 
   /** Create the task session for `brief` and start it; returns at once.

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

@@ -5,55 +5,22 @@
  */
 
 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 };
-}
+import { resolveRequestedModel } from './services/agent-tool/model-select.mjs';
 
 // `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.
+// pinned model is resolved here, by the same rule the in-process agent tool
+// applies (exact id, display name, then every query word; ambiguous or
+// unknown names fail with candidates), and forwarded as the exact route.
 export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null, listProviderModels = null }) {
   const routedAgentTool = {
     ...agentTool,
     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;
-        }
-      }
+      const routedArgs =
+        typeof listProviderModels === 'function' && clean(args?.model) && (clean(args.type) || 'spawn') === 'spawn'
+          ? await resolveRequestedModel(args, listProviderModels)
+          : args;
       return executeAgentControl(routedArgs, context);
     },
     closeAll(reason, scope = {}) {

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

@@ -22,7 +22,10 @@ import { TOOL_DEFS as OFFICE_TOOL_DEFS } from '../../runtime/office/tool-defs.mj
 import { TOOL_DEFS as MEDIA_TOOL_DEFS } from '../../runtime/media/tool-defs.mjs';
 import { TOOL_DEFS as TIDY_TOOL_DEFS } from '../../runtime/tidy/tool-defs.mjs';
 import { TOOL_DEFS as VISUALIZE_BRIDGE_TOOL_DEFS } from '../../runtime/visualize-bridge/tool-defs.mjs';
-import { ASK_USER_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
+import {
+  ASK_USER_TOOL_DEFS,
+  HANDOFF_USER_TOOL_DEFS,
+} from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
 import { REACTION_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { SETUP_TOOL_DEFS } from '../setup-tool/tool-defs.mjs';
 import { createSetupToolExecutor } from '../setup-tool/executor.mjs';
@@ -171,6 +174,7 @@ function wireToolSurface(boot) {
     visualizeToolDefs: VISUALIZE_BRIDGE_TOOL_DEFS,
     setupToolDefs: SETUP_TOOL_DEFS,
     askUserToolDefs: ASK_USER_TOOL_DEFS,
+    handoffUserToolDefs: HANDOFF_USER_TOOL_DEFS,
     reactionToolDefs: REACTION_TOOL_DEFS,
     goalTools: goalRuntime.tools,
     agentTools: agentTool.tools,

package/src/session-runtime/bot-status.mjs

@@ -1,8 +1,9 @@
 /**
  * `session bots`: the state of the user's bots, read on demand (never injected
  * into a turn). One line per bot: its home chat (`sess_home_<id>`), the last
- * activity there and its latest line, whether it works now (its chat, or a
- * task session it runs), approvals waiting on the user, its routines and what
+ * activity there and its latest line, whether it works now (its chat, or work
+ * it sent running in a task session; a turn the user typed there is the
+ * user's), approvals waiting on the user, its routines and what
  * needs attention. With one bot (`session_id`: its id or chat id): its
  * routines, its held requests and its recent sessions.
  *
@@ -143,7 +144,7 @@ function span(ms) {
 const ago = (at, now) => `${span(now - at)} ago`;
 const until = (at, now) => (at <= now ? 'due now' : `in ${span(at - now)}`);
 
-async function defaultListBots() {
+export async function defaultListBots() {
   const [{ workflowHelpers }, { getPluginData, loadConfig }, { isAgentDisabled, isContactAgentId }] = await Promise.all(
     [
       import('./boot/shared.mjs'),
@@ -264,7 +265,12 @@ export function createBotStatus({
     const homeId = agentHomeSessionId(bot.id);
     const owned = ctx.owned.get(bot.id) || [];
     const home = ctx.rows.get(homeId) || null;
-    // Running task sessions: a turn whose report is still owed, or one working now.
+    // Work this bot sent that is running now: a session working with the bot's
+    // send in flight (`handedBy`, bot-owned-work.mjs). A turn the user typed
+    // in the bot's task session is the user's, not the bot working.
+    const sentWork = (row) => isWorking(row) && row.handedBy?.includes(bot.id) === true;
+    // Running task sessions: a turn whose report is still owed, or the bot's
+    // work running now.
     const tasks = new Map();
     const addTask = (id, title, at) => {
       const known = tasks.get(id);
@@ -276,7 +282,7 @@ export function createBotStatus({
       addTask(watch.taskSessionId, watch.title, Number(watch.at) || 0);
     }
     for (const row of owned) {
-      if (row.id === homeId || roomMemberOfSession(row.id) || !isWorking(row)) continue;
+      if (row.id === homeId || roomMemberOfSession(row.id) || !sentWork(row)) continue;
       addTask(row.id, row.title, Number(row.createdAt) || 0);
     }
     const running = [...tasks.values()].sort((left, right) => left.at - right.at || (left.id < right.id ? -1 : 1));
@@ -302,7 +308,7 @@ export function createBotStatus({
       approvals,
       routines,
       flags,
-      working: isWorking(home) || running.some((task) => isWorking(ctx.rows.get(task.id))),
+      working: isWorking(home) || running.some((task) => sentWork(ctx.rows.get(task.id))),
       lastAt: activityOf(home),
     };
   }

package/src/session-runtime/bot-target.mjs

@@ -0,0 +1,38 @@
+// A bot id as the `session_id` of read, send and status: a bot's chat is a
+// session of its own (`sess_home_<id>`), but the schema also lets a model name
+// the bot (`bots` takes either), so the id resolves to that home chat — before
+// any check of the target, so the bot-chain, hop and task-origin checks see
+// the chat they would for `sess_home_<id>`. A minted session id always has an
+// underscore, a normalized bot id never does (agent-home.mjs), so only ids
+// shaped like a bot id are looked up.
+import { MIXY_AGENT_ID, agentHomeSessionId } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import { defaultListBots, quotedText } from './bot-status.mjs';
+
+const MAX_NAMED_BOTS = 30;
+/** The actions whose `session_id` may be a bot id. */
+export const BOT_TARGET_ACTIONS = new Set(['read', 'send', 'status']);
+
+/** The ids of the bots a send can reach: Mixy and every contact agent. */
+async function botIds(listBots) {
+  return [MIXY_AGENT_ID, ...(await listBots()).map((bot) => bot.id)];
+}
+
+/** `target`'s home chat when it is a known bot id, else `target` unchanged. */
+export async function resolveBotTarget(target, listBots = defaultListBots) {
+  const home = agentHomeSessionId(target);
+  return home && (await botIds(listBots)).includes(target) ? home : target;
+}
+
+/** Whether `target` is shaped like a bot id (so, with no session, a mistyped one). */
+export const isBotShaped = (target) => agentHomeSessionId(target) !== '';
+
+/** The error for a bot-shaped `target` that is neither a known bot nor a session. */
+export async function unknownBotError(target, listBots = defaultListBots, cause) {
+  const ids = await botIds(listBots);
+  const named = ids.slice(0, MAX_NAMED_BOTS).join(', ');
+  const more = ids.length > MAX_NAMED_BOTS ? `, … (${ids.length - MAX_NAMED_BOTS} more)` : '';
+  return new Error(
+    `session: "${quotedText(target, 64)}" is neither a session nor a known bot id; bot ids: ${named}${more}; session action=list finds session ids`,
+    cause ? { cause } : undefined
+  );
+}

package/src/session-runtime/channel-config-api.mjs

@@ -12,7 +12,12 @@ import {
   testWebhook,
   withScheduleRenameReserved,
 } from './services/channel-admin.mjs';
-import { getSchedule, markScheduleFailure, markScheduleSkipped, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import {
+  getSchedule,
+  markScheduleFailure,
+  markScheduleSkipped,
+  markScheduleSuccess,
+} from '../runtime/channels/lib/schedules-db.mjs';
 import { scheduleRenameUncertainError } from '../runtime/channels/lib/schedule-errors.mjs';
 import { loadEndpointConfig, readEndpointLastPayload } from '../runtime/channels/lib/webhooks-db.mjs';
 import { webhookEventSummary, webhookRunPrompt } from '../runtime/channels/lib/webhook/session-dispatch.mjs';

package/src/session-runtime/conversation-import/codex-titles.mjs

@@ -0,0 +1,88 @@
+/**
+ * The thread titles Codex itself stores, by thread id (read-only):
+ *
+ *   state_<N>.sqlite   `threads.title`, overridden by `threads.name` (a rename)
+ *   session_index.jsonl  append-only `{ id, thread_name }`; the latest
+ *                        non-empty name of an id wins and overrides the DB
+ *
+ * Anything unreadable is skipped: a missing or locked store simply leaves the
+ * conversation to the title derived from its messages.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { titleFromText } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+
+const STATE_DB_RE = /^state_(\d+)\.sqlite$/i;
+
+async function newestStateDb(home) {
+  let newest = null;
+  for (const name of await readdir(home).catch(() => [])) {
+    const version = STATE_DB_RE.exec(name)?.[1];
+    if (version !== undefined && (!newest || Number(version) > newest.version)) {
+      newest = { name, version: Number(version) };
+    }
+  }
+  return newest ? join(home, newest.name) : null;
+}
+
+function readStateRows(path) {
+  const db = new DatabaseSync(path, { readOnly: true });
+  try {
+    const columns = new Set(
+      db
+        .prepare('PRAGMA table_info(threads)')
+        .all()
+        .map((column) => column.name)
+    );
+    const wanted = ['title', 'name'].filter((column) => columns.has(column));
+    if (!wanted.length) return [];
+    return db.prepare(`SELECT id, ${wanted.join(', ')} FROM threads`).all();
+  } finally {
+    db.close();
+  }
+}
+
+async function readStateTitles(home, titles) {
+  try {
+    const path = await newestStateDb(home);
+    if (!path) return;
+    const rows = readStateRows(path);
+    for (const column of ['title', 'name']) {
+      for (const row of rows) {
+        const title = titleFromText(row[column]);
+        if (title && typeof row.id === 'string') titles.set(row.id, title);
+      }
+    }
+  } catch {
+    /* unreadable store: fall back to the session index and derived titles */
+  }
+}
+
+async function readIndexTitles(home, titles) {
+  let text;
+  try {
+    text = await readFile(join(home, 'session_index.jsonl'), 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const title = titleFromText(entry?.thread_name);
+    if (title && typeof entry.id === 'string') titles.set(entry.id, title);
+  }
+}
+
+/** Map of Codex thread id → its stored title (whitespace-normalized, ≤100 chars). */
+export async function loadCodexThreadTitles(home) {
+  const titles = new Map();
+  await readStateTitles(home, titles);
+  await readIndexTitles(home, titles);
+  return titles;
+}