@bridge4dev/runner 0.64.1 → 0.65.0

package/dist/adapters/claude.js

@@ -10,6 +10,7 @@ import { cageSpawn, noteSessionAgentPid, memoryDeathSentence, releaseSessionScop
 import { evaluateToolUse, maskSecrets, maskString, } from '../policy.js';
 import { availableModes, cardDescription, DIRECT_BRANCH_RULE, folderRuleFor, MODE_REFUSED_TEXT, MODE_WITHDRAWN_TEXT, policyContextFor, DEVBRIDGE_MCP_SERVER_NAME, } from './types.js';
 import { percentFromUtilization, RATE_WINDOW_MINUTES, rateWindowKey } from './rate-limits.js';
+import { AgentTaskTray } from './agent-tasks.js';
 import { applyUsagePercentages, lastUsageRows, readUsageRows } from './claude-usage.js';
 import { assertClaudeInstalled, claudeExecutableOption, sessionClaudePath, } from '../agent-binary.js';
 /** Same 2KB the SDK keeps: enough for the CLI's last words, not a log sink. */
@@ -255,18 +256,6 @@ const EFFORT_LABELS = {
 const EFFORT_DESCRIPTIONS = {
     [ULTRACODE]: 'Extra high, plus the agent orchestrates sub-agent workflows on its own',
 };
-/** Longest a task title may be before the tray truncates it. */
-const TASK_TITLE_LIMIT = 120;
-/** How many live tasks travel in one `agent_tasks` event. */
-const TASK_LIST_CAP = 20;
-/**
- * Floor between two `agent_tasks` publications.
- *
- * A twenty-agent fan-out changes membership dozens of times a minute and every
- * running subagent adds a `task_progress` every ~30s. Each event is a row in
- * `DevSessionEvent`, so the tray coalesces rather than narrating.
- */
-const TASK_PUBLISH_INTERVAL_MS = 1_500;
 /**
  * What the agent calls a finished task, mapped onto the tray's three states.
  *
@@ -433,29 +422,15 @@ class ClaudeSession {
      */
     liveWireModel;
     /**
-     * Everything running beside the conversation, keyed by the agent's task id
-     * (ticket #113). Membership is owned by `background_tasks_changed`; the
-     * details come from the `task_*` bookends.
+     * Everything running beside the conversation (ticket #113). Membership is
+     * owned by `background_tasks_changed`; the details come from the `task_*`
+     * bookends. How the set is published – the floor, the de-duplication, the
+     * per-turn counters – is the tray's, and shared with the Codex adapter (#382).
      */
-    tasks = new Map();
-    /** Ids currently in the agent's live set — the tray shows exactly these. */
-    liveTaskIds = [];
-    /**
-     * Which turn is being counted (#147).
-     *
-     * There are no `started` / `done` accumulators any more, and that is the
-     * whole fix. Two counters with different lifetimes could disagree, and did:
-     * `endTaskTurn` zeroed both while deliberately keeping the ROWS of tasks
-     * still running, so a background shell that outlived its turn was counted as
-     * finished in the next one without ever having been counted as started —
-     * «22 of 21 done». Both numbers are now derived from this map in one pass, so
-     * `done <= total` holds by cardinality rather than by clamping.
-     */
-    turnEpoch = 0;
-    taskPublishTimer = null;
-    taskPublishedAt = 0;
-    /** Last published snapshot, minus the ages — see `flushTasks` (QA-111 M4). */
-    lastTaskFingerprint = '';
+    tray = new AgentTaskTray({
+        emit: (event) => this.emit(event),
+        isStopped: () => this.stopped,
+    });
     /**
      * Ambient tasks the SDK marked `skip_transcript`. Remembered by id because
      * the flag arrives on `task_started`, which is usually NOT the first message
@@ -642,13 +617,6 @@ class ClaudeSession {
         };
         this.q = queryFn({ prompt: this.input, options });
         void this.consume();
-        // Ticket #113. The task level is per-PROCESS: the SDK emits nothing at
-        // startup and tells consumers to reset to the empty set whenever the
-        // session's CLI process (re)starts. The dashboard reads the newest
-        // `agent_tasks` in the stored feed, so without this a session killed
-        // mid-turn — the runner restarted, the machine rebooted — would come back
-        // and show the subagents of its previous life as though they were still
-        // running, right up until the next membership change.
         // Ticket #119 / QA-114 MAJOR-3: if the protected file could not be written,
         // say so where a person will see it, not only in journald.
         if (this.mcpFallbackNotice) {
@@ -658,8 +626,14 @@ class ClaudeSession {
             this.emit({ type: 'notice', level: 'warn', text: MODE_REFUSED_TEXT });
             this.emit({ type: 'settings', mode: this.mode });
         }
-        this.lastTaskFingerprint = JSON.stringify({ done: 0, total: 0, tasks: [] });
-        this.emit({ type: 'agent_tasks', tasks: [], done: 0, total: 0 });
+        // Ticket #113. The task level is per-PROCESS: the SDK emits nothing at
+        // startup and tells consumers to reset to the empty set whenever the
+        // session's CLI process (re)starts. The dashboard reads the newest
+        // `agent_tasks` in the stored feed, so without this a session killed
+        // mid-turn — the runner restarted, the machine rebooted — would come back
+        // and show the subagents of its previous life as though they were still
+        // running, right up until the next membership change.
+        this.tray.announceEmpty();
         // Report what the agent can do right away. `system:init` only arrives with
         // the first turn (verified live), so a free session waiting for its first
         // message would otherwise show no model list at all — while the control
@@ -1540,7 +1514,7 @@ class ClaudeSession {
                     if (!announced.has(id))
                         this.skipTaskIds.delete(id);
                 }
-                this.liveTaskIds = [];
+                const liveIds = [];
                 for (const row of rows) {
                     const id = typeof row['task_id'] === 'string' ? row['task_id'] : null;
                     if (!id)
@@ -1551,16 +1525,17 @@ class ClaudeSession {
                     // and it never left again (QA-111 m4).
                     if (this.skipTaskIds.has(id))
                         continue;
-                    this.liveTaskIds.push(id);
+                    liveIds.push(id);
                     // A task can reach the live set before its own `task_started` — the
                     // SDK says the level usually precedes the bookends. Seed it here so
                     // the tray never has a live id it cannot name.
-                    this.touchTask(id, {
+                    this.tray.touch(id, {
                         kind: typeof row['task_type'] === 'string' ? row['task_type'] : 'task',
                         title: typeof row['description'] === 'string' ? row['description'] : 'Working…',
                     });
                 }
-                this.publishTasks();
+                this.tray.setLive(liveIds);
+                this.tray.publish();
                 break;
             }
             case 'task_started': {
@@ -1572,14 +1547,11 @@ class ClaudeSession {
                 // may already have taken it in before this message arrived.
                 if (msg['skip_transcript'] === true) {
                     this.skipTaskIds.add(id);
-                    this.tasks.delete(id);
-                    const before = this.liveTaskIds.length;
-                    this.liveTaskIds = this.liveTaskIds.filter((live) => live !== id);
-                    if (this.liveTaskIds.length !== before)
-                        this.publishTasks();
+                    if (this.tray.forget(id))
+                        this.tray.publish();
                     break;
                 }
-                this.touchTask(id, {
+                this.tray.touch(id, {
                     kind: typeof msg['task_type'] === 'string' ? msg['task_type'] : 'task',
                     ...(typeof msg['description'] === 'string' ? { title: msg['description'] } : {}),
                     ...(typeof msg['subagent_type'] === 'string'
@@ -1589,7 +1561,7 @@ class ClaudeSession {
                         ? { workflowName: msg['workflow_name'] }
                         : {}),
                 });
-                this.publishTasks();
+                this.tray.publish();
                 break;
             }
             case 'task_progress': {
@@ -1600,7 +1572,7 @@ class ClaudeSession {
                 // denominator (#147).
                 if (!id || this.skipTaskIds.has(id))
                     break;
-                this.touchTask(id, {
+                this.tray.touch(id, {
                     ...(typeof msg['description'] === 'string' ? { title: msg['description'] } : {}),
                     ...(typeof msg['subagent_type'] === 'string'
                         ? { subagentType: msg['subagent_type'] }
@@ -1608,20 +1580,20 @@ class ClaudeSession {
                     ...(typeof msg['summary'] === 'string' ? { summary: msg['summary'] } : {}),
                     ...usagePatch(msg['usage']),
                 });
-                this.publishTasks();
+                this.tray.publish();
                 break;
             }
             case 'task_updated': {
                 const id = typeof msg['task_id'] === 'string' ? msg['task_id'] : null;
                 const patch = (msg['patch'] ?? {});
-                if (!id || !this.tasks.has(id))
+                if (!id || !this.tray.has(id))
                     break;
                 const status = typeof patch['status'] === 'string' ? patch['status'] : undefined;
-                this.touchTask(id, {
+                this.tray.touch(id, {
                     ...(typeof patch['description'] === 'string' ? { title: patch['description'] } : {}),
                     ...(status ? { status: taskStatus(status) } : {}),
                 });
-                this.publishTasks();
+                this.tray.publish();
                 break;
             }
             case 'task_notification': {
@@ -1638,12 +1610,12 @@ class ClaudeSession {
                     }
                     break;
                 }
-                this.touchTask(id, {
+                this.tray.touch(id, {
                     status: taskStatus(typeof msg['status'] === 'string' ? msg['status'] : 'completed'),
                     ...(typeof msg['summary'] === 'string' ? { summary: msg['summary'] } : {}),
                     ...usagePatch(msg['usage']),
                 });
-                this.publishTasks();
+                this.tray.publish();
                 break;
             }
             default:
@@ -1651,181 +1623,21 @@ class ClaudeSession {
         }
     }
     /**
-     * Create-or-merge one task row, and count the TRANSITIONS while doing it.
-     *
-     * The counters live here rather than in the individual message handlers
-     * because «started» and «finished» are properties of the transition, not of
-     * whichever message happened to announce it (QA-111 M1). They were counted
-     * per-message, and both orderings the SDK actually produces missed:
-     *
-     *   `background_tasks_changed` → `task_started`   → `total` stayed 0
-     *   `task_updated{completed}`  → `task_notification` → `done` stayed 0
-     *
-     * The first of those is the COMMON ordering — the SDK documents the level as
-     * usually preceding the bookends — so «N of M done», the one number the
-     * ticket asked for by name, was never printed at all.
-     *
-     * `startedAt` is stamped once and never moves.
-     */
-    touchTask(id, patch) {
-        const existing = this.tasks.get(id);
-        if (existing) {
-            const settledAs = existing.status === 'running' ? null : existing.status;
-            Object.assign(existing, patch);
-            if (patch.title)
-                existing.title = truncate(patch.title, TASK_TITLE_LIMIT);
-            if (patch.summary)
-                existing.summary = truncate(patch.summary, TASK_TITLE_LIMIT);
-            // Settling is one-way. A task that has stopped cannot start again under
-            // the same id: the only messages that could say so are a late
-            // `task_updated` carrying a status this runner does not recognise, or a
-            // frame redelivered after a reconnect — neither of which is news that the
-            // work resumed. Letting either through would make the derived `done`
-            // count downwards on screen.
-            if (settledAs && existing.status === 'running')
-                existing.status = settledAs;
-            return;
-        }
-        this.tasks.set(id, {
-            ...patch,
-            id,
-            kind: patch.kind ?? 'task',
-            title: truncate(patch.title ?? 'Working…', TASK_TITLE_LIMIT),
-            status: patch.status ?? 'running',
-            turnEpoch: this.turnEpoch,
-            startedAt: Date.now(),
-            // The only free-text field an agent writes with no length of its own:
-            // a subagent's closing `summary` runs to kilobytes, and twenty of them
-            // push the event past the payload cap, which replaces the WHOLE payload
-            // with `{truncated:true}` and blinks the tray out (QA-111 m1).
-            ...(patch.summary ? { summary: truncate(patch.summary, TASK_TITLE_LIMIT) } : {}),
-        });
-    }
-    /**
-     * Publish the tray, at most once every `TASK_PUBLISH_INTERVAL_MS`.
-     *
-     * Every publication is a stored row in the session feed, and a wide fan-out
-     * changes membership dozens of times a minute. The trailing timer matters as
-     * much as the floor: the LAST change in a burst is the one that says the work
-     * is over, and dropping it would leave the tray running forever.
-     */
-    publishTasks() {
-        if (this.stopped)
-            return;
-        const wait = TASK_PUBLISH_INTERVAL_MS - (Date.now() - this.taskPublishedAt);
-        if (wait > 0) {
-            if (!this.taskPublishTimer) {
-                this.taskPublishTimer = setTimeout(() => {
-                    this.taskPublishTimer = null;
-                    this.flushTasks();
-                }, wait);
-                this.taskPublishTimer.unref();
-            }
-            return;
-        }
-        this.flushTasks();
-    }
-    flushTasks() {
-        if (this.stopped)
-            return;
-        this.taskPublishedAt = Date.now();
-        const now = Date.now();
-        // Only what the agent still calls live. A task that finished keeps its row
-        // in `this.tasks` for the counters, but the tray is about NOW.
-        const tasks = this.liveTaskIds
-            .map((id) => this.tasks.get(id))
-            .filter((t) => Boolean(t))
-            .slice(0, TASK_LIST_CAP)
-            // How long it has been running, measured HERE (QA-111 m2). `startedAt` is
-            // this machine's clock and the browser's is a different one — subtracting
-            // across them put the dev server's clock skew straight into the number,
-            // so a host ten minutes behind showed «10m 03s» on a task one second old.
-            .map(({ turnEpoch: _turnEpoch, ...task }) => ({
-            ...task,
-            ageMs: Math.max(0, now - task.startedAt),
-        }));
-        // Both numbers, one pass, one map (#147). `done` counts a SUBSET of what
-        // `total` counts, so `done <= total` is a property of set cardinality and
-        // cannot be broken by a message ordering, a redelivery, a re-title, an
-        // ambient row being deleted or a turn boundary. There is no pair of
-        // counters to keep in agreement, because there is no pair.
-        //
-        // Tasks that outlived an earlier turn keep that turn's epoch: they still
-        // render as live rows — background work outliving its turn is the whole
-        // point of the tray — but they belong to neither number here, exactly as
-        // this file's own doctrine says («done/total are per-turn by definition.
-        // The live set does NOT»).
-        let total = 0;
-        let done = 0;
-        for (const task of this.tasks.values()) {
-            if (task.turnEpoch !== this.turnEpoch)
-                continue;
-            total += 1;
-            if (task.status !== 'running')
-                done += 1;
-        }
-        const payload = { type: 'agent_tasks', tasks, done, total };
-        // A frame that says exactly what the last one said is not worth a row in
-        // the session feed (QA-111 M4). `task_progress` fires every ~30s per
-        // running subagent and usually carries nothing new, and with twenty of
-        // them that alone is the throttle's whole budget. `ageMs` is excluded from
-        // the comparison on purpose — it changes every time by definition, and
-        // including it would make every frame unique and the check pointless.
-        const fingerprint = JSON.stringify({
-            done: payload.done,
-            total: payload.total,
-            tasks: tasks.map(({ ageMs: _ageMs, ...rest }) => rest),
-        });
-        if (fingerprint === this.lastTaskFingerprint)
-            return;
-        this.lastTaskFingerprint = fingerprint;
-        this.emit(payload);
-    }
-    /**
-     * The turn ended. Reset what belongs to the TURN — and only that.
-     *
-     * `done`/`total` are per-turn by definition and go back to zero. The live set
-     * does NOT: background work is precisely the work that outlives the turn that
-     * started it, which is the whole reason the ticket asks for it. Caught on
-     * production during this session's own verification — the agent ended its
-     * turn with `sleep 40` still running in the background and the tray, which
-     * cleared everything here, showed nothing at exactly the moment somebody was
-     * reading the answer and wondering whether the deploy had finished.
+     * The turn ended: the tray resets the turn's counters and says what is still
+     * running (see `AgentTaskTray.endTurn`).
      *
      * Membership stays owned by `background_tasks_changed`, which reports the set
-     * emptying when it actually empties. Finished tasks are dropped here because
-     * only the live ids are ever rendered anyway, and keeping their rows would
-     * grow the map for the life of the session.
+     * emptying when it actually empties.
+     *
+     * `skipTaskIds` is NOT cleared here (#147). An ambient task the SDK asked
+     * consumers to hide can span a turn boundary, and clearing the set let its
+     * id back into the live list on the next `background_tasks_changed` – where
+     * it was drawn as a tray row and counted as work. The id is forgotten when
+     * that task settles instead, which is the moment it stops being able to come
+     * back.
      */
     endTaskTurn() {
-        if (this.taskPublishTimer) {
-            clearTimeout(this.taskPublishTimer);
-            this.taskPublishTimer = null;
-        }
-        const live = new Set(this.liveTaskIds);
-        for (const id of [...this.tasks.keys()]) {
-            if (!live.has(id))
-                this.tasks.delete(id);
-        }
-        // `skipTaskIds` is NOT cleared here any more (#147). An ambient task the
-        // SDK asked consumers to hide can span a turn boundary, and clearing the
-        // set let its id back into the live list on the next
-        // `background_tasks_changed` — where it was drawn as a tray row and counted
-        // as work. The id is forgotten when that task settles instead, which is the
-        // moment it stops being able to come back.
-        this.turnEpoch += 1;
-        // Straight through `flushTasks` rather than an empty frame of its own, and
-        // with the de-duplication disarmed for this one frame (plan
-        // `workflow-mode-fixes` S1 p.10). The turn's counters usually changed, but
-        // not always: a task started in an earlier turn and still running, and a
-        // turn that started nothing new, produce exactly the frame the last turn
-        // ended on — and the end of a turn is the moment the API and the tray most
-        // need to hear what is still running, whether or not it is news. The
-        // supervisor de-duplicates the COUNT on its own side; this frame is the
-        // tray's freshness, not the database's.
-        this.taskPublishedAt = 0;
-        this.lastTaskFingerprint = '';
-        this.flushTasks();
+        this.tray.endTurn();
     }
     /**
      * Forget what the LAST turn did, now that a new one is starting (#252).
@@ -2266,10 +2078,7 @@ class ClaudeSession {
             return;
         this.stopped = true;
         // A pending tray publication would fire into a closed output queue.
-        if (this.taskPublishTimer) {
-            clearTimeout(this.taskPublishTimer);
-            this.taskPublishTimer = null;
-        }
+        this.tray.close();
         // Before the process goes: withdraw everything a human was still being
         // asked, WITH a cause. A pending permission used to gutter out as a plain
         // "denied", which put a decision in the audit trail that nobody made.

package/dist/adapters/codex-subagents.d.ts

@@ -0,0 +1,169 @@
+import type { AgentTaskTray } from './agent-tasks.js';
+/**
+ * The tray's word for a helper. The dashboard draws the robot for any kind with
+ * «agent» in it, and this is the word the Claude SDK already uses for the same
+ * thing – so the row looks the same whichever CLI started it.
+ */
+export declare const SUBAGENT_TASK_KIND = "local_agent";
+/** How often the set is re-checked against Codex while a helper is running. */
+export declare const SUBAGENT_RECONCILE_MS = 60000;
+/**
+ * How long after a helper became `running` the snapshot may believe an `idle`.
+ *
+ * A thread handed work reports `idle` first and `active` a little later
+ * (measured: 400 ms and 1.3 s after a spawn), so a snapshot landing in that gap
+ * – a parent that spawns and ends its turn at once – would otherwise settle a
+ * helper that has not started yet. A real ending is still caught: by its own
+ * events at once, or by the next tick once this has passed.
+ */
+export declare const SUBAGENT_SPAWN_GRACE_MS = 30000;
+type HelperState = 'running' | 'done' | 'failed';
+/** Codex's `CollabAgentStatus` → the tray. Unknown is «no news», never a guess. */
+export declare function collabAgentState(status: unknown): HelperState | null;
+/**
+ * Codex's `SubAgentActivityKind` → the tray. Unknown is «no news».
+ *
+ * `interacted` is deliberately NOT «running»: it is one agent putting words in
+ * another's mailbox, and the CLI's own tool description draws the line —
+ * `followup_task` «gives an existing agent a new task and triggers a turn»,
+ * `send_message` «passes a message to a running agent without triggering a
+ * turn». Both produce this one kind. Measured: a helper reported to the session
+ * with `interacted` and the session's thread started no turn for the next 120
+ * seconds. Read as «working», a message to an agent that has already finished
+ * would put a row back in the tray that nothing takes out again until the
+ * snapshot's grace is over. A re-tasked agent announces itself the honest way,
+ * with its own `turn/started` on its own thread.
+ */
+export declare function activityState(kind: unknown): HelperState | null;
+/** What one `thread/read` said, reduced to what the set needs. */
+export type ThreadReading = {
+    kind: 'thread';
+    /** `active` · `idle` · `notLoaded` · `systemError`, or null when absent. */
+    status: string | null;
+    parentThreadId: string | null;
+    /** Spawned by an agent's collaboration tools – the only helpers that count. */
+    spawned: boolean;
+    nickname: string | null;
+    role: string | null;
+    path: string | null;
+}
+/** The thread does not exist in this app-server any more. */
+ | {
+    kind: 'gone';
+}
+/** This Codex has no such request – stop asking. */
+ | {
+    kind: 'unsupported';
+}
+/** No answer worth acting on (a timeout, a transport hiccup). */
+ | {
+    kind: 'unknown';
+};
+export declare function threadReading(raw: unknown): ThreadReading;
+/**
+ * A refused `thread/read` or `thread/loaded/list`, classified by what Codex
+ * said. Measured on 0.154.0: an unknown thread is `-32600 thread not loaded:
+ * <id>`, an unknown request is `-32600 Invalid request: unknown variant …` –
+ * the same code, so the sentence decides.
+ */
+export declare function threadReadingOfError(error: unknown): ThreadReading;
+type Request = (method: string, params: Record<string, unknown>, timeoutMs: number) => Promise<unknown>;
+export interface CodexThreadProbe {
+    read(threadId: string): Promise<ThreadReading>;
+    /** Loaded thread ids, `unsupported`, or null when there was no answer. */
+    loaded(): Promise<string[] | 'unsupported' | null>;
+}
+export declare function threadProbeOver(request: Request): CodexThreadProbe;
+export interface CodexSubagentsOptions {
+    tray: AgentTaskTray;
+    /** The session's own thread – never counted as its own helper. */
+    ownThreadId: () => string | null;
+    probe: CodexThreadProbe;
+    isStopped: () => boolean;
+    reconcileMs?: number;
+    spawnGraceMs?: number;
+}
+export declare class CodexSubagents {
+    private readonly opts;
+    private readonly helpers;
+    /** Loaded threads the snapshot already found are not ours to count. */
+    private readonly notOurs;
+    private timer;
+    private reconciling;
+    /** A full reconcile asked for while one was running – run once more after it. */
+    private reconcileAgain;
+    private snapshotSupported;
+    private closed;
+    private readonly reconcileMs;
+    private readonly spawnGraceMs;
+    constructor(opts: CodexSubagentsOptions);
+    /** One of this session's helpers, at any depth. */
+    isHelper(threadId: string): boolean;
+    /**
+     * A collaboration item, on the session's own thread or on a helper's.
+     *
+     * A helper's helpers are this session's too: a spawned agent can spawn, and a
+     * grandchild at work keeps the session just as busy. An item from any other
+     * thread speaks for somebody else and is ignored.
+     */
+    onItem(senderThreadId: string, item: Record<string, unknown>): void;
+    /**
+     * A helper's own turn started or ended.
+     *
+     * Only for a helper already known: a thread's turn says it is working, not
+     * whose it is, and Codex runs threads of its own (review, compaction) that are
+     * nobody's helpers.
+     */
+    onHelperTurn(threadId: string, phase: 'started' | 'completed', turnStatus?: string): void;
+    /** A helper's thread was closed. */
+    onThreadClosed(threadId: string): void;
+    /**
+     * The session's turn ended: reset the turn's counters, say what is still
+     * running, then check the set against Codex.
+     *
+     * The frame goes out synchronously, BEFORE the caller emits `turn_end` – the
+     * supervisor decides «is this the person's turn now» on the count it holds at
+     * that moment. The snapshot follows in the background; if it changes the
+     * set, the supervisor re-reports the resting status with the new count.
+     */
+    endTurn(): void;
+    close(): void;
+    /**
+     * Check the set against Codex (R16).
+     *
+     * `everything` – at the end of a turn: every helper not known to be gone, plus
+     * every loaded thread not classified yet. Otherwise (the minute tick) only
+     * the ones believed running, which is what can go stale.
+     */
+    reconcile(options: {
+        everything: boolean;
+    }): Promise<void>;
+    private gone;
+    private reconcileOnce;
+    /** What one reading means for a helper already held. */
+    private absorb;
+    /** The helper's record, created (as finished) if it is new. */
+    private remember;
+    /**
+     * Move one helper to a state, and publish.
+     *
+     * The session itself is never its own helper: a helper reporting back to its
+     * parent names the PARENT as the agent it «interacted» with
+     * (`agentThreadId` = the session's thread, `agentPath: "/root"`) – measured
+     * on 0.154.0, and counted it would keep the session «busy» for ever.
+     */
+    private apply;
+    /** New facts about a helper, onto its row if it has one. */
+    private learn;
+    /**
+     * Ask Codex for the helper's name once, right after it appears. The activity
+     * item carries only its path (`/root/a`); the name Codex gives it
+     * («Heisenberg») is what Codex's own interface calls it.
+     */
+    private askName;
+    private syncLive;
+    private startTimer;
+    private stopTimer;
+}
+export {};
+//# sourceMappingURL=codex-subagents.d.ts.map