@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/acp/test/keeperWorld.js

@@ -16,8 +16,10 @@ import { expect, vi } from 'vitest';
 import { killKeepersUnder, tempDir } from '../../../test/keeperKit.js';
 import { AcpKeeperClient } from '../../keepers/acp/client.js';
 import { computeBuildVersion } from '../../keepers/kit/buildVersion.js';
+import { readKeeperManifest } from '../../keepers/kit/bundle.js';
 import { keeperGen } from '../../keepers/kit/identity.js';
 import { KeeperLauncher } from '../../keepers/kit/launcher.js';
+import { acquireStartupLock, releaseStartupLock } from '../../keepers/kit/lock.js';
 import { AgentSessionManager } from '../../agentSessions.js';
 import { AGENT_WIRE_VERSION } from '../../protocol/agent.js';
 import { TaskRegistry } from '../../update/taskRegistry.js';
@@ -97,6 +99,32 @@ export class KeeperWorld {
         this.agentDir = this.newAgentDir(`${prefix}agent-`);
         this.launcher = this.launcherFor(realDist);
     }
+    /** These integrations require keeper hosting, rather than fallback after an unrelated lock-port collision. */
+    static async create(prefix, includeOlderGeneration = false) {
+        const current = keeperGen((await readKeeperManifest(join(realDist, 'acp'))).buildVersion);
+        for (let attempt = 0; attempt < 100; attempt++) {
+            const candidate = new this(prefix);
+            const locks = [];
+            try {
+                const generations = [current];
+                if (includeOlderGeneration)
+                    generations.push(candidate.olderGeneration().oldGen);
+                for (const gen of new Set(generations)) {
+                    locks.push(await acquireStartupLock(candidate.launcher.pathsFor('acp', gen).lockPort));
+                }
+                return candidate;
+            }
+            catch (error) {
+                await candidate.dispose();
+                if (error.code !== 'EADDRINUSE')
+                    throw error;
+            }
+            finally {
+                await Promise.all(locks.map(releaseStartupLock));
+            }
+        }
+        throw new Error('No unoccupied keeper-acp integration fixture identity');
+    }
     launcherFor(distDir) {
         return new KeeperLauncher({ configDir: this.configDir, workstationId: 'ws-t21', server: 'http://test.invalid', distDir, useSystemd: false,
             startTimeoutMs: 20_000, umask: 0o022 });
@@ -116,12 +144,13 @@ export class KeeperWorld {
         const real = new KeeperTransport(new AcpKeeperClient({ launcher: use }));
         const keeper = (over.wrapKeeper ? over.wrapKeeper(real) : real);
         const generations = keeperGenerations({ launcher: use, current: keeper, log: () => { } });
-        const local = new LocalTransport({ configDir: this.configDir });
+        const journalRoot = use.ownership ? join(this.configDir, 'registrations', use.ownership.registrationId) : this.configDir;
+        const local = new LocalTransport({ configDir: journalRoot, ownership: use.ownership });
         const acp = new AcpAgents({ cacheDir: this.configDir, registry: { load: async () => [] }, transports: { keeper, local }, keeperGenerations: generations,
             sessionStartTimeoutMs: 15_000, ...over.acp });
         const tasks = new TaskRegistry();
         const sent = [];
-        const manager = new AgentSessionManager(acp, null, join(this.configDir, 'agents'), tasks);
+        const manager = new AgentSessionManager(acp, null, join(journalRoot, 'agents'), tasks, () => true, use.ownership);
         manager.bindSend((frame) => { sent.push(frame); server.apply(frame); }, AGENT_WIRE_VERSION);
         let killed = false;
         const result = {
@@ -195,7 +224,7 @@ export class KeeperWorld {
         const n = this.processes.length + 1;
         const framesOut = join(this.configDir, `frames-daemon-${n}.jsonl`);
         const stderrFile = join(this.configDir, `daemon-${n}.stderr`);
-        const child = spawn(join(packageRoot, 'node_modules', '.bin', 'vite-node'), [DAEMON_LIFE,
+        const child = spawn(join(packageRoot, 'node_modules', '.bin', 'vite-node'), ['--config', join(packageRoot, 'src/test/fixtures/nodeRuntime.vite.config.ts'), DAEMON_LIFE,
             JSON.stringify({ configDir: this.configDir, distDir: realDist, framesOut, faults })], { cwd: packageRoot, stdio: ['pipe', 'ignore', 'pipe'] });
         let stderr = '';
         child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); appendFileSync(stderrFile, chunk); });

package/dist/workstation/acp/test/raw/sources.js

@@ -1,29 +1,15 @@
-/**
- * Every capture Task 17d's gate runs on, and how each becomes a processor raw log.
- *
- * - `real`: the committed, sanitised real captures (`*.jsonl` in this directory, by discovery).
- * - `qoder`: Qoder captures wrapped from the update-level Qoder fixtures (`qoderCaptures.ts`) — there
- *   is no raw Qoder capture; a real one is T23's.
- * - `synthetic`: hand-written captures that pin the known ordering fixes — experiment 0.1's wire
- *   (analysis B §0.1) and out-of-turn chunks followed by the next prompt (17b) — an interrupt
- *   mid-turn (`session/cancel`), which no real capture has, and (T19 prerequisite) a `session/load`
- *   with history and a Qoder `session/resume`.
- *
- * {@link buildLog} plays the daemon: the transducer (`fixtures.ts`), plus, for Qoder, the
- * `qoder_terminal_repair` note where `AcpAgents` enables the repair today (after the `session/new`
- * response) and the side-file notes the daemon's `BackgroundSideNotes` reader appends once the native
- * rows exist (after the turn, as the live repair sees them).
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { BackgroundSideNotes, nativeTerminalHistoryPath } from '../../../qoderAdapter/backgroundTerminal.js';
+import { join } from 'node:path';
 import { decodeStreamRecord } from '../../processor/record.js';
-import { sideDemand } from '../../processor/sideChannel.js';
-import { run } from '../../processor/test/harness.js';
 import { fixtureNames, RAW_DIR, readFixtureText, transduce } from './fixtures.js';
-import { captureText, CERTIFIED_QODER, down, qoderCaptures, up, update } from './qoderCaptures.js';
+/** Lines → kit-stream ndjson (a synthetic `proc spawn` first, `t` = position). */
+export function captureText(lines) {
+    const records = [JSON.stringify({ o: 0, t: 0, k: 'proc', kind: 'spawn', spawnId: 'capture', pid: 0, pgid: 0, startTime: 0 })];
+    lines.forEach((line, index) => records.push(JSON.stringify({ o: index + 1, t: index + 1, k: line.k, l: JSON.stringify(line.message) })));
+    return `${records.join('\n')}\n`;
+}
+export const up = (message) => ({ k: 'up', message });
+export const down = (message) => ({ k: 'down', message });
+export const update = (sessionId, value) => up({ jsonrpc: '2.0', method: 'session/update', params: { sessionId, update: value } });
 const SYNTHETIC_PROMPT = [{ type: 'text', text: 'go' }];
 const opening = (sessionId) => [
     down({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } }),
@@ -117,7 +103,7 @@ function loadThenPrompt() {
         ]) };
 }
 /**
- * T19 prerequisite: a Qoder cached `session/resume` (the certified runtime advertising
+ * T19 prerequisite: a cached `session/resume` (an adapter advertising
  * `sessionCapabilities.resume`) — no history, a config snapshot on the response, then one turn.
  */
 function resumeThenPrompt() {
@@ -125,7 +111,7 @@ function resumeThenPrompt() {
     return { name: 'synthetic-resume', kind: 'synthetic', text: captureText([
             down({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } }),
             up({ jsonrpc: '2.0', id: 1, result: { protocolVersion: 1, agentCapabilities: { loadSession: true, sessionCapabilities: { resume: {} } },
-                    authMethods: [], agentInfo: CERTIFIED_QODER } }),
+                    authMethods: [], agentInfo: { name: '@agentclientprotocol/claude-agent-acp', version: '1.0.0' } } }),
             down({ jsonrpc: '2.0', id: 2, method: 'session/resume', params: { sessionId: S, cwd: '/work/synthetic', mcpServers: [] } }),
             up({ jsonrpc: '2.0', id: 2, result: { configOptions: [{ id: 'model', name: 'Model', type: 'select', currentValue: 'model-0001',
                             options: [{ value: 'model-0001', name: 'xxxxx' }, { value: 'model-0002', name: 'xxxxx' }] }] } }),
@@ -134,116 +120,16 @@ function resumeThenPrompt() {
             up({ jsonrpc: '2.0', id: 3, result: { stopReason: 'end_turn' } }),
         ]) };
 }
-/**
- * Real Qoder captures (T30a/T30b): `qoder-real-<what>.jsonl`, written by `scripts/acp-capture.mjs` against `qodercli --acp` or the SDK
- * adapter and sanitised by `axom-cli/scripts/acp-sanitize.mjs` (with `--side` when the capture has one). Each is discovered like any
- * real capture, joins every gate that runs on all sources (`processor/rawFixtures.test.ts`, the goldens of
- * `processor/equivalence.test.ts`), and is played as the daemon plays a live Qoder session: the repair note right after the open's
- * response (`session/new`) or right after a load's open note, for the certified runtime only (`nativeTerminalHistoryPath`), and the
- * side file `<name>.side.ndjson` — the root native transcript rows — read through the daemon's `BackgroundSideNotes` after the turn.
- */
-export const REAL_QODER_PREFIX = 'qoder-real-';
-export const sideFileOf = (fixture) => fixture.replace(/\.jsonl$/, '.side.ndjson');
-/** The discovered real Qoder capture names (without `.jsonl`), for the static source lists of the gates. */
-export const realQoderNames = () => fixtureNames().filter((name) => name.startsWith(REAL_QODER_PREFIX)).map((name) => name.replace(/\.jsonl$/, ''));
-/** The capture's first open (`session/new` / `load` / `resume`), its response and the adapter's `initialize` identity. */
-export function openFacts(capture) {
-    const lines = capture.filter((r) => r.kind === 'up' || r.kind === 'down')
-        .map((r) => { try {
-        return { r, m: JSON.parse(r.line) };
-    }
-    catch {
-        return undefined;
-    } }).filter((x) => x !== undefined);
-    const responseTo = (id) => lines.find(({ r, m }) => r.kind === 'up' && m.method === undefined && JSON.stringify(m.id) === JSON.stringify(id));
-    const init = lines.find(({ r, m }) => r.kind === 'down' && m.method === 'initialize');
-    const agentInfo = init ? responseTo(init.m.id)?.m.result?.agentInfo : undefined;
-    const open = lines.find(({ r, m }) => r.kind === 'down' && ['session/new', 'session/load', 'session/resume'].includes(m.method ?? ''));
-    if (!open)
-        return undefined;
-    const response = responseTo(open.m.id);
-    if (!response)
-        return undefined;
-    const mode = open.m.method.slice('session/'.length);
-    const sessionId = String(mode === 'new' ? response.m.result?.sessionId : open.m.params?.sessionId);
-    return { mode, responseO: response.r.o, sessionId, cwd: String(open.m.params?.cwd), ...(agentInfo ? { agentInfo } : {}) };
-}
-/** A real Qoder source from a capture's text and its side file's text (if any). */
-export function qoderRealSource(name, text, sideText, path) {
-    const facts = openFacts(text.split('\n').filter((line) => line.trim()).map((line) => decodeStreamRecord(JSON.parse(line))));
-    return { name, kind: 'qoder-real', text, ...(path ? { path } : {}),
-        ...(facts ? { sessionId: facts.sessionId, cwd: facts.cwd } : {}),
-        ...(sideText !== undefined ? { nativeRows: sideText.split('\n').filter((line) => line.trim()).map((line) => JSON.parse(line)) } : {}) };
-}
-function realQoderSource(fixture) {
-    const side = join(RAW_DIR, sideFileOf(fixture));
-    return qoderRealSource(fixture.replace(/\.jsonl$/, ''), readFixtureText(fixture), existsSync(side) ? readFileSync(side, 'utf8') : undefined, join(RAW_DIR, fixture));
-}
 export async function allSources() {
-    const real = fixtureNames().map((name) => (name.startsWith(REAL_QODER_PREFIX) ? realQoderSource(name) : {
+    const real = fixtureNames().map((name) => ({
         name: name.replace(/\.jsonl$/, ''), kind: 'real', text: readFixtureText(name), path: join(RAW_DIR, name),
     }));
-    const qoder = (await qoderCaptures()).map((capture) => ({ ...capture, kind: 'qoder' }));
-    return [...real, ...qoder, experiment01(), outOfTurnThenPrompt(), interruptMidTurn(), loadThenPrompt(), resumeThenPrompt()];
+    return [...real, experiment01(), outOfTurnThenPrompt(), interruptMidTurn(), loadThenPrompt(), resumeThenPrompt()];
 }
 export function captureRecords(source) {
     return source.text.split('\n').filter((line) => line.trim()).map((line) => decodeStreamRecord(JSON.parse(line)));
 }
-/** Write the Qoder native rows where the certified repair reads them under `home`. */
-export async function writeNativeRows(source, home) {
-    const path = nativeTerminalHistoryPath(CERTIFIED_QODER, source.sessionId, source.cwd, home);
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${source.nativeRows.map((row) => JSON.stringify(row)).join('\n')}\n`);
-    return path;
-}
-/** The processor raw log for `source` (see the file comment). */
 export async function buildLog(source, options = {}) {
-    const capture = captureRecords(source);
-    const after = new Map();
-    const repairNote = (nativeSessionId) => [{ kind: 'note', note: { type: 'qoder_terminal_repair', nativeSessionId } }];
-    let afterLoadOpen;
-    if (source.kind === 'qoder') {
-        const openResponse = capture.find((record) => record.kind === 'up' && JSON.parse(record.line).id === 2);
-        after.set(openResponse.o, () => repairNote(source.sessionId));
-    }
-    else if (source.kind === 'qoder-real') {
-        // `AcpAgents.startSession`: the repair is enabled only where `nativeTerminalHistoryPath` certifies the runtime.
-        const facts = openFacts(capture);
-        if (facts && nativeTerminalHistoryPath(facts.agentInfo, facts.sessionId, facts.cwd, '/home/certification')) {
-            if (facts.mode === 'load')
-                afterLoadOpen = repairNote;
-            else
-                after.set(facts.responseO, () => repairNote(facts.sessionId));
-        }
-    }
-    const transduced = transduce(capture, { after, ...(afterLoadOpen ? { afterLoadOpen } : {}),
-        ...(options.launch !== undefined ? { launch: options.launch } : {}) });
-    let sideNotes = 0;
-    if (source.nativeRows && source.sessionId && source.cwd && after.size + (afterLoadOpen ? 1 : 0) > 0) {
-        const home = await mkdtemp(join(tmpdir(), 'axom-raw-side-'));
-        try {
-            const path = await writeNativeRows(source, home);
-            const reader = new BackgroundSideNotes({ path, nativeSessionId: source.sessionId, cwd: source.cwd });
-            let next = transduced.session.log.head;
-            // T19's loop: ask the processor's current demand, read, append the notes, fold; until a poll
-            // brings nothing new (the live repair's 1 s timer, without the timer).
-            for (let poll = 0; poll < 8; poll += 1) {
-                const demand = sideDemand(transduced.processor.state);
-                if (!demand)
-                    break;
-                const notes = await reader.poll(demand);
-                for (const note of notes)
-                    transduced.session.log.append({ kind: 'note', note });
-                next = run(transduced.processor, transduced.session, next);
-                sideNotes += notes.length;
-                if (notes.length === 0)
-                    break;
-            }
-            reader.close();
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-        }
-    }
-    return { ...transduced, records: transduced.session.log.read(0), source, sideNotes };
+    const transduced = transduce(captureRecords(source), options);
+    return { ...transduced, records: transduced.session.log.read(0), source, sideNotes: 0 };
 }

package/dist/workstation/acp/test/realAdapter.js

@@ -1,37 +1,3 @@
-/**
- * The opt-in real-adapter harness on the processor path (Task 30a). It replaces the real-adapter coverage Task 29 deleted with
- * `AcpSession` (`qoderContract.test.ts`'s `AXOM_ACP_CONTRACT_COMMAND` certification, `providerLifecycleBaseline`,
- * `qoderAdapter/acpHostIntegration`): every case opens through `AcpAgents.open` → `ProcessorSession`, over the local transport and
- * over a real keeper-acp (the built bundle in `dist/keepers`), and reads what the daemon would — the session's frames and its raw log.
- *
- * ## Isolation
- *
- * Every run gets its own temp config dir (keeper-acp's sockets, raw logs and outboxes live there, never `~/.config/axom`), its own
- * temp workspace and its own temp HOME. The adapter is started by a small launcher ({@link writeLauncher}) that:
- * - puts it in a process group of its own (the owned-group cleanup of the deleted certification), and
- * - replaces its environment with a minimal one read from a 0600 file in the run dir: PATH, the temp HOME, temp `CLAUDE_CONFIG_DIR`,
- *   `CODEX_HOME`, `XDG_CONFIG_HOME` (all created), the build's own launch env, and only the variables named in
- *   `AXOM_REAL_ADAPTER_ENV_PASS`. Nothing else of this process's environment (API keys, `CLAUDE_CODE_*`, tokens) reaches the
- *   adapter, and the environment is never in the spawn's argv (keeper-acp records argv in its label).
- *
- * A case that needs a logged-in adapter uses `AXOM_REAL_ADAPTER_AUTH_HOME` as HOME instead of a temp one: a directory the operator
- * prepared for this purpose (e.g. `HOME=<dir> qodercli` once, then log in). The harness never defaults to the real HOME.
- *
- * ## Flags (all off: `npm test` runs only the hermetic cases and reports the rest as skipped, with the reason)
- *
- * | variable | effect |
- * |---|---|
- * | `AXOM_REAL_ADAPTER_HARNESS=1` | enables the real-adapter tiers at all |
- * | `AXOM_REAL_ADAPTER_AGENTS=claude-acp,codex-acp` | registry adapters for the no-prompt tier, installed into the temp config dir |
- * | `AXOM_ACP_CONTRACT_COMMAND` / `AXOM_ACP_CONTRACT_ARGS` | an adapter command (and a JSON argv, default `["--acp"]`): the no-prompt tier, and the Qoder certification's adapter |
- * | `AXOM_REAL_ADAPTER_PROMPTS=1` | also runs the cases that send prompts (model usage, see each case's cost) |
- * | `AXOM_REAL_ADAPTER_AUTH_HOME` | HOME for the prompt cases (required by them) |
- * | `AXOM_REAL_ADAPTER_ENV_PASS=A,B` | extra variables passed through to the adapter (token-based auth) |
- * | `AXOM_REAL_ADAPTER_TRANSPORTS=local,keeper` | which transports to run on (default both) |
- * | `AXOM_QODER_SDK_QODERCLI=<path>` | the real SDK adapter tier: `node dist/cli.js qoder-acp --qodercli <path>` (prompts) |
- */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path, { join } from 'node:path';
@@ -68,7 +34,6 @@ export function realAdapterConfig(env = process.env) {
         ...(env.AXOM_REAL_ADAPTER_AUTH_HOME ? { authHome: env.AXOM_REAL_ADAPTER_AUTH_HOME } : {}),
         envPass: list(env.AXOM_REAL_ADAPTER_ENV_PASS),
         transports: transports.length > 0 ? transports : ['local', 'keeper'],
-        ...(env.AXOM_QODER_SDK_QODERCLI ? { sdkQodercli: env.AXOM_QODER_SDK_QODERCLI } : {}),
     };
 }
 /** Why a tier does not run (undefined: it runs). Shown as the skipped test's name. */
@@ -84,7 +49,7 @@ export function skipReason(config, tier) {
         return 'needs a logged-in adapter: set AXOM_REAL_ADAPTER_AUTH_HOME';
     if (tier === 'qoder')
         return config.command ? undefined : 'set AXOM_ACP_CONTRACT_COMMAND to qodercli';
-    return config.sdkQodercli ? undefined : 'set AXOM_QODER_SDK_QODERCLI to qodercli';
+    return undefined;
 }
 /**
  * A provider history failure fails certification but never prevents local teardown; each local step is guarded on its own, so one
@@ -364,14 +329,3 @@ export async function historyOf(opened) {
             history.push(event);
     return history;
 }
-/** `node dist/cli.js` (the built CLI), for the real SDK adapter (`qoder-acp --qodercli`). */
-export const BUILT_CLI = join(PACKAGE_ROOT, 'dist', 'cli.js');
-export const builtCliExists = () => existsSync(BUILT_CLI);
-/** Runs `node dist/cli.js qoder-acp --prepare-sdk` once (network: the SDK runtime) under `env`. */
-export async function prepareSdkRuntime(env) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [BUILT_CLI, 'qoder-acp', '--prepare-sdk'], { env, stdio: ['ignore', 'inherit', 'inherit'] });
-        child.once('error', reject);
-        child.once('exit', (code) => (code === 0 ? resolve() : reject(new Error(`qoder-acp --prepare-sdk exited ${code}`))));
-    });
-}

package/dist/workstation/acp/test/scriptAgent.js

@@ -19,7 +19,9 @@
 //   stderrMcpHeaders?: boolean       on session/new and session/load: every MCP header value received, on stderr (raw and JSON)
 //   version?: string                 initialize's agentInfo.version (default '1.0.0')                                    (Task 24)
 //   noLoad?: boolean                 initialize does not advertise loadSession
+//   failInitializeOn?: string        initialize answers an error once this marker exists
 //   failLoad?: boolean               session/load answers an error
+//   failLoadOn?: string              session/load answers an error once this marker exists
 //   loadWaitFor?: string             session/load waits for this file before it answers
 //   historyOnLoad?: string[]         agent_message_chunk texts replayed (as history) before session/load answers
 //   configOptions?: object[]         session/new and session/load answer these configOptions (load: as configured — the agent keeps
@@ -118,8 +120,14 @@ function onLine(line) {
     }
     switch (message.method) {
         case 'initialize': {
-            const answer = () => send({ id: message.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: !config.noLoad, ...(config.mcpHttp ? { mcpCapabilities: { http: true } } : {}) }, authMethods: [],
-                    agentInfo: { name: 'script-agent', version: config.version ?? '1.0.0' } } });
+            const answer = () => {
+                if (config.failInitializeOn && existsSync(at(config.failInitializeOn))) {
+                    send({ id: message.id, error: { code: -32002, message: 'Initialize refused: old build unavailable' } });
+                    return;
+                }
+                send({ id: message.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: !config.noLoad, ...(config.mcpHttp ? { mcpCapabilities: { http: true } } : {}) }, authMethods: [],
+                        agentInfo: { name: 'script-agent', version: config.version ?? '1.0.0' } } });
+            };
             if (config.initializeWaitFor)
                 void waitForFile(config.initializeWaitFor).then(answer);
             else
@@ -135,7 +143,7 @@ function onLine(line) {
             void (async () => {
                 if (config.loadWaitFor)
                     await waitForFile(config.loadWaitFor);
-                if (config.failLoad) {
+                if (config.failLoad || (config.failLoadOn && existsSync(at(config.failLoadOn)))) {
                     send({ id: message.id, error: { code: -32002, message: 'Resource not found: session' } });
                     return;
                 }

package/dist/workstation/agentFlow.js

@@ -21,7 +21,7 @@
  *   window could ever open for them;
  * - **control frames** bypass both and are written at once: RPC replies (`agent_opened`, `agent_steered`,
  *   `agent_config_option_set`, `agent_native_sessions`, `agent_native_deleted`, `agent_verified`, `agent_authenticated`,
- *   `agent_installed`, `agent_delegation_renewed`, `agent_provider_task_stopped`, `agent_backfill_done`), levels
+ *   `agent_installed`, `agent_provider_task_stopped`, `agent_backfill_done`), levels
  *   (`agent_session_state`, `agent_runtime_profile`, `agent_provider_task_event`), `agent_session_lost`, `agent_resume_offer`,
  *   `agent_auth_url`/`agent_auth_done`, and the channel's own heartbeat. They are small and rare, an answer the server is waiting
  *   for (a 10–120 s timeout) must not queue behind a session's backlog, and an answer to a user (a permission card's state) must