@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/qoderAdapter/session.js

@@ -1,319 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { isAbsolute } from 'node:path';
-import { InputQueue } from './inputQueue.js';
-import { createObserverPlugin } from './observerPlugin.js';
-import { ObserverReceiver } from './observerReceiver.js';
-import { PermissionBridge } from './permissions.js';
-import { QoderMessageMapper } from './mapper.js';
-import { TaskLedger } from './taskLedger.js';
-import { TaskControl } from './taskControl.js';
-import { readChildHistory } from './history.js';
-import { supportsQoderSdkSteering } from './sdkDriver.js';
-export class QoderAdapterSession {
-    dependencies;
-    query;
-    input = new InputQueue();
-    receiver;
-    permissions;
-    mapper;
-    taskLedger;
-    taskControl;
-    resultIds = new Set();
-    earlyObservations = [];
-    degraded = false;
-    updateTail = Promise.resolve();
-    taskTail = Promise.resolve();
-    queuedUpdates = 0;
-    pump;
-    shutdown;
-    closed = false;
-    root;
-    cwd;
-    profileState;
-    active;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
-    get currentProfile() {
-        return this.profileState ? { ...this.profileState, capabilities: [...this.profileState.capabilities] } : undefined;
-    }
-    /** Public-SDK child history is exposed through the live adapter, never through private files. */
-    async readChildHistory(agentId, page) {
-        const root = this.root;
-        const dir = page?.dir ?? this.cwd;
-        if (!root || !dir) {
-            return { status: 'unknown', entries: [], rootSessionId: root ?? 'unknown', agentId,
-                offset: page?.offset ?? 0, limit: page?.limit ?? 50, hasMore: false, snapshotStable: false,
-                reason: 'invalid-page' };
-        }
-        return readChildHistory(root, agentId, { ...page, dir });
-    }
-    async publishProfile() {
-        const value = this.currentProfile;
-        if (value)
-            await this.dependencies.profile(value);
-    }
-    degrade() {
-        if (this.degraded)
-            return;
-        this.degraded = true;
-        for (const task of this.taskLedger?.markStale() ?? [])
-            void this.queueTask(task, `degraded-${this.profileState?.runtimeGeneration}`).catch(() => { });
-        if (this.profileState)
-            this.profileState.observerHealthy = false;
-        void this.publishProfile().catch(() => { });
-    }
-    publishTask(task, uuid, summary) {
-        return this.dependencies.taskObservation?.({ rootSessionId: task.origin.rootSessionId,
-            runtimeGeneration: task.origin.runtimeGeneration, taskId: task.origin.taskId, uuid,
-            state: task.state, live: task.live, stale: task.stale,
-            ...(task.taskType ? { taskType: task.taskType } : {}),
-            ...(task.background !== undefined ? { background: task.background } : {}),
-            ...(task.origin.agentId ? { agentId: task.origin.agentId } : {}),
-            ...(task.origin.launchingToolUseId ? { launchingToolUseId: task.origin.launchingToolUseId } : {}),
-            ...(summary !== undefined ? { summary, status: task.state } : {}) }) ?? Promise.resolve();
-    }
-    queueTask(task, uuid, summary) {
-        const pending = this.taskTail.then(() => this.publishTask(task, uuid, summary));
-        this.taskTail = pending.catch(() => this.degrade());
-        return pending;
-    }
-    sendUpdate(update) {
-        if (this.closed)
-            return Promise.resolve();
-        if (this.queuedUpdates >= 256) {
-            this.degrade();
-            return Promise.resolve();
-        }
-        this.queuedUpdates++;
-        const pending = this.updateTail.then(async () => {
-            if (!this.closed)
-                await this.dependencies.update({ sessionId: this.root, update });
-        }).finally(() => { this.queuedUpdates--; });
-        this.updateTail = pending.catch(() => { this.degrade(); });
-        return pending;
-    }
-    observe(observation) {
-        if (this.closed)
-            return;
-        if (!this.profileState?.rootConfirmed) {
-            if (this.earlyObservations.length >= 64)
-                this.degrade();
-            else
-                this.earlyObservations.push(observation);
-            return;
-        }
-        if (observation.origin)
-            this.mapper?.observe(observation.origin);
-        if (observation.launch) {
-            this.mapper?.observe(observation.launch);
-            if (observation.launch.launchingToolUseId && observation.launch.agentId)
-                for (const task of this.taskLedger?.observeLaunch(observation.launch.launchingToolUseId, observation.launch.agentId) ?? [])
-                    void this.queueTask(task, `launch-${observation.launch.launchingToolUseId}`).catch(() => this.degrade());
-        }
-        if (observation.conflict)
-            this.mapper?.conflict(observation.conflict);
-        if (this.profileState)
-            this.profileState.observerHealthy = !this.degraded && this.receiver?.healthy === true;
-        void this.publishProfile().catch(() => { });
-    }
-    async newSession(request) {
-        if (this.root || this.closed)
-            throw new Error('Session already opened or closed');
-        if (!isAbsolute(request.cwd))
-            throw new Error('Session cwd must be absolute');
-        if (request.mcpServers.length)
-            throw new Error('MCP server mapping is not supported');
-        this.root = randomUUID();
-        this.cwd = request.cwd;
-        const generation = randomUUID();
-        this.taskLedger = new TaskLedger(this.root, generation);
-        this.profileState = { cliVersion: this.dependencies.driver.cliVersion, sdkVersion: this.dependencies.driver.sdkVersion,
-            executable: this.dependencies.driver.executable, persistent: true, mode: 'sdk-adapter', agentMessaging: false,
-            transport: 'process', capabilities: [], observerHealthy: false, completedContinuationEnabled: false,
-            sendMessageExposed: false, initialized: false, rootConfirmed: false, platform: process.platform,
-            runtimeSource: 'explicit-local', rootSessionId: this.root, runtimeGeneration: generation };
-        try {
-            const plugin = await createObserverPlugin(this.dependencies.runDir, { rootSessionId: this.root,
-                runtimeGeneration: generation, token: randomUUID() });
-            this.mapper = new QoderMessageMapper({ rootSessionId: this.root, runtimeGeneration: generation }, {
-                correction: (update) => { void this.sendUpdate(update).catch(() => { }); }, degraded: () => this.degrade()
-            });
-            this.receiver = new ObserverReceiver(plugin, { onObservation: (observation) => this.observe(observation), onDegraded: () => this.degrade() });
-            this.permissions = new PermissionBridge({ rootSessionId: this.root, runtimeGeneration: generation,
-                request: this.dependencies.permission ?? (async () => ({ outcome: { outcome: 'cancelled' } })) });
-            this.query = this.dependencies.driver.create({ prompt: this.input, options: { cwd: request.cwd,
-                    sessionId: this.root, plugins: [{ type: 'local', path: plugin.pluginDir }],
-                    canUseTool: this.permissions.canUseTool, onElicitation: this.permissions.onElicitation } });
-            this.taskControl = new TaskControl(this.taskLedger, () => this.currentProfile, this.query, this.dependencies.certifications ?? [], this.dependencies.backendBinding);
-            this.pump = this.readMessages();
-            const initialized = await this.query.initializationResult();
-            if (this.closed)
-                throw new Error('Session closed during initialization');
-            this.profileState.initialized = true;
-            this.profileState.capabilities = initialized.capabilities ?? [];
-            await this.publishProfile();
-            this.receiver.start();
-            return { sessionId: this.root, _meta: { qoderProfile: this.currentProfile } };
-        }
-        catch (error) {
-            await this.close();
-            throw error;
-        }
-    }
-    async readMessages() {
-        try {
-            for await (const message of this.query) {
-                if (this.closed)
-                    break;
-                if (message.type === 'system' && message.subtype === 'init') {
-                    if (message.session_id !== this.root || message.cwd !== this.cwd ||
-                        message.qodercli_version !== this.dependencies.driver.cliVersion ||
-                        message.protocol_version !== '1.5.0')
-                        throw new Error('SDK root identity/profile mismatch');
-                    this.profileState.rootConfirmed = true;
-                    this.profileState.protocolVersion = 1;
-                    for (const observation of this.earlyObservations.splice(0))
-                        this.observe(observation);
-                    await this.publishProfile();
-                    continue;
-                }
-                if (!this.profileState?.rootConfirmed || message.session_id !== this.root)
-                    continue;
-                await this.receive(message);
-            }
-            if (!this.closed)
-                throw new Error('SDK stream ended');
-        }
-        catch (error) {
-            this.active?.reject(error instanceof Error ? error : new Error('SDK transport failed'));
-            this.active = undefined;
-            if (this.profileState)
-                this.profileState.rootConfirmed = false;
-            void this.close();
-        }
-    }
-    async receive(message) {
-        if (message.type === 'result') {
-            if (this.resultIds.has(message.uuid))
-                return;
-            if (this.resultIds.size >= 4096)
-                throw new Error('SDK result identity capacity exceeded');
-            this.resultIds.add(message.uuid);
-            if (message.origin !== undefined && message.origin.kind !== 'human')
-                return;
-            const active = this.active;
-            if (message.subtype === 'error_during_execution' &&
-                (message.terminal_reason === 'aborted_streaming' || message.terminal_reason === 'aborted_tools') &&
-                active?.steeringPending) {
-                // Qoder reports the interrupted prefix as a terminal error before it
-                // starts the injected `now` message. The 1.1.61 SDK uses
-                // `aborted_tools` when the current foreground tool is cancelled,
-                // while newer builds may use `aborted_streaming`. Both are an
-                // internal hand-off, not the host prompt's final result.
-                active.steeringPending--;
-                return;
-            }
-            this.active = undefined;
-            if (message.is_error || message.subtype !== 'success')
-                active?.reject(new Error(`SDK result error: ${message.error_code ?? message.subtype}`));
-            else
-                active?.resolve({ stopReason: message.terminal_reason === 'interrupted' ? 'cancelled' : 'end_turn' });
-        }
-        else if (message.type === 'system' && ['task_started', 'task_progress', 'task_updated',
-            'background_tasks_changed', 'task_notification'].includes(message.subtype)) {
-            const changed = this.taskLedger?.apply(message) ?? [];
-            if (this.taskLedger?.degraded)
-                this.degrade();
-            for (const task of changed)
-                await this.queueTask(task, message.uuid, message.subtype === 'task_notification' && task.origin.taskId === message.task_id
-                    ? message.summary.slice(0, 8192) : undefined);
-        }
-        else {
-            for (const update of this.mapper?.map(message, this.active?.runId) ?? [])
-                await this.sendUpdate(update);
-        }
-    }
-    async prompt(request) {
-        if (this.closed || !this.query || request.sessionId !== this.root || !this.profileState?.initialized)
-            throw new Error('Session unavailable');
-        if (this.active)
-            throw new Error('Session prompt already active');
-        if (request.prompt.some((block) => block.type !== 'text'))
-            throw new Error('Prompt media/resource mapping is unsupported');
-        const text = request.prompt.map((block) => block.type === 'text' ? block.text : '').join('\n');
-        if (Buffer.byteLength(text, 'utf8') > 131072)
-            throw new Error('Prompt capacity exceeded');
-        return new Promise((resolve, reject) => {
-            const runId = randomUUID();
-            this.active = { runId, resolve, reject, steeringPending: 0 };
-            try {
-                this.input.push({ type: 'user', uuid: runId, session_id: this.root,
-                    parent_tool_use_id: null, message: { role: 'user', content: text } });
-            }
-            catch (error) {
-                this.active = undefined;
-                reject(error);
-            }
-        });
-    }
-    async steer(blocks, priority) {
-        if (this.closed || !this.query || !this.profileState?.initialized || !this.profileState.rootConfirmed ||
-            !supportsQoderSdkSteering(this.dependencies.driver.cliVersion) || !this.active)
-            return 'promptRequired';
-        if (blocks.some((block) => block.type !== 'text'))
-            throw new Error('Steering media/resource mapping is unsupported');
-        const text = blocks.map((block) => block.type === 'text' ? block.text : '').join('\n');
-        if (!text.trim())
-            throw new Error('Steering prompt must contain text');
-        if (Buffer.byteLength(text, 'utf8') > 131072)
-            throw new Error('Steering capacity exceeded');
-        const active = this.active;
-        active.steeringPending++;
-        try {
-            this.input.push({ type: 'user', uuid: randomUUID(), session_id: this.root,
-                parent_tool_use_id: null, origin: { kind: 'human' }, shouldQuery: true,
-                ...(priority === undefined ? {} : { priority }), message: { role: 'user', content: text } });
-            return 'injected';
-        }
-        catch (error) {
-            active.steeringPending--;
-            throw error;
-        }
-    }
-    async cancel() { if (!this.closed && this.query)
-        await this.query.interrupt(); }
-    async stopTask(request) {
-        if (this.closed || !this.taskControl)
-            throw new Error('Task stop unavailable');
-        return this.taskControl.stop(request);
-    }
-    close() {
-        if (this.shutdown)
-            return this.shutdown;
-        this.closed = true;
-        this.input.close();
-        for (const task of this.taskLedger?.markStale() ?? [])
-            void this.queueTask(task, `closed-${this.profileState?.runtimeGeneration}`).catch(() => { });
-        this.permissions?.close();
-        this.active?.reject(new Error('Session closed'));
-        this.active = undefined;
-        this.shutdown = (async () => {
-            try {
-                await this.query?.close();
-            }
-            finally {
-                await this.pump;
-                await this.updateTail;
-                await this.taskTail;
-                await this.receiver?.dispose();
-                this.mapper?.dispose();
-                if (this.profileState) {
-                    this.profileState.observerHealthy = false;
-                    await this.publishProfile();
-                }
-            }
-        })();
-        return this.shutdown;
-    }
-}

package/dist/workstation/qoderAdapter/subagentMeta.js

@@ -1,28 +0,0 @@
-export const QODER_SUBAGENT_META_VERSION = 1;
-export function qoderSubagentMeta(value) {
-    return { qoder: { version: QODER_SUBAGENT_META_VERSION, ...value } };
-}
-export function qoderChildMeta(parentToolUseId, origin, extra = { source: 'sdk' }) {
-    return qoderSubagentMeta({
-        ...extra,
-        parentToolUseId,
-        route: 'child',
-        ...(origin?.agentId ? { agentId: origin.agentId } : {}),
-        ...(origin?.launchingToolUseId ? { launchingToolUseId: origin.launchingToolUseId } : {}),
-    });
-}
-export function qoderSpawnMeta(toolUseId) {
-    return qoderSubagentMeta({ source: 'sdk', toolName: 'Agent', subagent: true, toolUseId });
-}
-export function qoderCorrectionMeta(source, origin) {
-    const base = {
-        source: 'correction', toolUseId: source.toolUseId,
-        ...(origin?.agentId ? { agentId: origin.agentId } : {}),
-        ...(origin?.launchingToolUseId ? { launchingToolUseId: origin.launchingToolUseId } : {}),
-    };
-    if (source.parentToolUseId && origin)
-        return qoderSubagentMeta({
-            ...base, parentToolUseId: source.parentToolUseId, route: 'child',
-        });
-    return qoderSubagentMeta({ ...base, ...(origin ? {} : { route: 'unknown' }) });
-}

package/dist/workstation/qoderAdapter/subwork.js

@@ -1,77 +0,0 @@
-const object = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
-const id = (v) => typeof v === 'string' && v.length > 0 && v.length <= 256 && !/[\x00-\x1f\x7f]/.test(v);
-export function supportsSubworkMeta(info) {
-    return (info?.name === 'qoder-cli' && info.version === '1.1.61') ||
-        (info?.name === 'axom-qoder-sdk' && info.version === '1.0.50');
-}
-function resultText(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value)) {
-        const texts = value.filter(v => object(v).type === 'text').map(v => object(v).text).filter(v => typeof v === 'string');
-        return texts.length ? texts.join('\n') : undefined;
-    }
-    const v = object(value);
-    if (v.kind === 'agent-result')
-        return resultText(v.content ?? v.result);
-    return undefined;
-}
-export class SubworkBoundary {
-    root;
-    calls = new Map();
-    constructor(root) {
-        this.root = root;
-    }
-    child(toolId) { return `qoder-agent:${this.root}:${toolId}`; }
-    map(event) {
-        if (event.acpSessionId && event.acpSessionId !== this.root)
-            return [event];
-        const p = event.payload, q = object(object(p._meta).qoder), input = object(p.rawInput);
-        const marked = q.version === 1 && ['native-acp-patch', 'sdk', 'correction'].includes(String(q.source));
-        const toolId = p.toolCallId;
-        let call = id(toolId) ? this.calls.get(toolId) : undefined;
-        const parent = marked && q.route !== 'unknown' && id(q.parentToolUseId) ? q.parentToolUseId : undefined;
-        const events = [];
-        if (!call && marked && p.kind === 'think' && q.toolName === 'Agent' && id(toolId) &&
-            typeof input.prompt === 'string' && (input.subagent_type == null || typeof input.subagent_type === 'string') &&
-            (input.run_in_background === undefined || typeof input.run_in_background === 'boolean') &&
-            ['tool_call', 'tool_call_update'].includes(event.eventName) && this.calls.size < 4096) {
-            call = { child: this.child(toolId), ...(parent ? { parent: this.child(parent) } : {}),
-                background: input.run_in_background === true, ended: false, streamedText: '' };
-            this.calls.set(toolId, call);
-            events.push({ eventName: 'subagent_spawned', payload: { subagentSessionId: call.child,
-                    name: typeof input.description === 'string' && input.description.trim() ? input.description : input.subagent_type ?? 'Agent',
-                    task: input.prompt, capabilities: {} }, ...(call.parent ? { acpSessionId: call.parent } : {}) });
-            events.push({ eventName: 'user_message_chunk', payload: { content: { type: 'text', text: input.prompt } }, acpSessionId: call.child });
-        }
-        if (call && ['tool_call', 'tool_call_update'].includes(event.eventName)) {
-            if (call.ended)
-                return events;
-            const output = object(p.rawOutput);
-            const state = output.kind === 'agent-result' ? output.state : undefined;
-            const terminal = state === 'completed' ? 'completed' : ['error', 'failed'].includes(String(state)) ? 'failed' :
-                state === 'cancelled' ? 'cancelled' : ['failed', 'cancelled'].includes(String(p.status)) ? p.status :
-                    !call.background && p.status === 'completed' ? 'completed' : undefined;
-            if (terminal) {
-                const text = resultText(p.rawOutput);
-                if (text !== undefined && !call.streamedText.endsWith(text))
-                    events.push({ eventName: 'agent_message_chunk',
-                        payload: { content: { type: 'text', text } }, acpSessionId: call.child });
-                events.push({ eventName: 'subagent_state_update', payload: { subagentSessionId: call.child, state: terminal },
-                    ...(call.parent ? { acpSessionId: call.parent } : {}) });
-                call.ended = true;
-            }
-            // The Agent invocation becomes a dispatch/result in subwork. Keeping the vendor tool here
-            // would also create the old delegation card for the very same task.
-            return events;
-        }
-        if (parent) {
-            const owner = this.calls.get(parent), content = object(p.content);
-            if (owner && event.eventName === 'agent_message_chunk' && content.type === 'text' && typeof content.text === 'string') {
-                owner.streamedText += content.text;
-            }
-            return [{ ...event, acpSessionId: this.child(parent) }];
-        }
-        return [event];
-    }
-}

package/dist/workstation/qoderAdapter/taskControl.js

@@ -1,38 +0,0 @@
-import { capabilitiesFor } from './profile.js';
-const validId = (value) => value.length > 0 && Buffer.byteLength(value, 'utf8') <= 256 &&
-    !/[\x00-\x1f\x7f]/.test(value);
-export class TaskControl {
-    ledger;
-    profile;
-    query;
-    certifications;
-    binding;
-    requests = new Map();
-    constructor(ledger, profile, query, certifications, binding) {
-        this.ledger = ledger;
-        this.profile = profile;
-        this.query = query;
-        this.certifications = certifications;
-        this.binding = binding;
-    }
-    async stop(request) {
-        if (![request.sessionId, request.taskId, request.requestId].every(validId))
-            throw new Error('Invalid task stop identity');
-        const previous = this.requests.get(request.requestId);
-        if (previous) {
-            if (previous.sessionId !== request.sessionId || previous.taskId !== request.taskId)
-                throw new Error('Task stop request identity conflict');
-            return previous.receipt;
-        }
-        const profile = this.profile(), task = this.ledger.get(request.taskId);
-        if (!profile || !task || request.sessionId !== profile.rootSessionId ||
-            !task.origin.agentId || !task.origin.launchingToolUseId || task.taskType !== 'local_agent' ||
-            task.background !== true || !capabilitiesFor(profile, task, this.certifications, this.binding).stopActiveRun)
-            throw new Error('Task stop unavailable');
-        if (this.requests.size >= 4096)
-            throw new Error('Task stop receipt capacity exceeded');
-        const receipt = this.query.stopTask(request.taskId).then(() => ({ requestId: request.requestId, state: 'accepted' }), () => ({ requestId: request.requestId, state: 'unknown' }));
-        this.requests.set(request.requestId, { sessionId: request.sessionId, taskId: request.taskId, receipt });
-        return receipt;
-    }
-}

package/dist/workstation/qoderAdapter/taskEvent.js

@@ -1,26 +0,0 @@
-const id = (value) => typeof value === 'string' && value.length > 0 &&
-    Buffer.byteLength(value, 'utf8') <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-const states = new Set(['pending', 'paused', 'running', 'completed', 'stopped', 'failed', 'unknown']);
-const terminal = new Set(['completed', 'stopped', 'failed']);
-export function parseTaskObservation(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    if (['rootSessionId', 'runtimeGeneration', 'taskId', 'uuid'].some((key) => !id(input[key])) ||
-        !states.has(input.state) || typeof input.live !== 'boolean' ||
-        typeof input.stale !== 'boolean' || (terminal.has(input.state) && input.live) ||
-        ['agentId', 'launchingToolUseId'].some((key) => input[key] !== undefined && !id(input[key])) ||
-        (input.taskType !== undefined && (!id(input.taskType) || Buffer.byteLength(input.taskType, 'utf8') > 128)) ||
-        (input.background !== undefined && typeof input.background !== 'boolean') ||
-        (input.status !== undefined && (!terminal.has(input.status) || input.status !== input.state)) ||
-        (input.summary !== undefined && (typeof input.summary !== 'string' ||
-            Buffer.byteLength(input.summary, 'utf8') > 8192 || input.status === undefined)))
-        return undefined;
-    return Object.fromEntries(['rootSessionId', 'runtimeGeneration', 'taskId', 'uuid', 'state', 'live', 'stale',
-        'taskType', 'background', 'agentId', 'launchingToolUseId', 'status', 'summary']
-        .filter((key) => input[key] !== undefined).map((key) => [key, input[key]]));
-}
-export function taskEventMatchesHost(event, host) {
-    return host.selected && host.available && host.confirmed &&
-        event.rootSessionId === host.rootSessionId && event.runtimeGeneration === host.runtimeGeneration;
-}

package/dist/workstation/qoderAdapter/taskLedger.js

@@ -1,163 +0,0 @@
-const identifier = (value) => typeof value === 'string' && value.length > 0 &&
-    Buffer.byteLength(value, 'utf8') <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-const terminal = (state) => state === 'completed' || state === 'failed' || state === 'stopped';
-const defaultMaxTasks = 4096;
-const sameTask = (a, b) => a.state === b.state && a.live === b.live && a.stale === b.stale && a.taskType === b.taskType &&
-    a.background === b.background && JSON.stringify(a.origin) === JSON.stringify(b.origin);
-export class TaskLedger {
-    rootSessionId;
-    runtimeGeneration;
-    maxTasks;
-    tasks = new Map();
-    seen = new Set();
-    actors = new Map();
-    launchTasks = new Map();
-    conflicts = new Set();
-    notified = new Set();
-    failed = false;
-    constructor(rootSessionId, runtimeGeneration, maxTasks = defaultMaxTasks) {
-        this.rootSessionId = rootSessionId;
-        this.runtimeGeneration = runtimeGeneration;
-        this.maxTasks = maxTasks;
-        if (!identifier(rootSessionId) || !identifier(runtimeGeneration))
-            throw new Error('Invalid task ledger binding');
-        if (!Number.isInteger(maxTasks) || maxTasks < 1 || maxTasks > defaultMaxTasks)
-            throw new Error('Invalid task ledger capacity');
-    }
-    get(taskId) {
-        const task = this.tasks.get(taskId);
-        return task && { ...task, origin: { ...task.origin } };
-    }
-    all() { return [...this.tasks.keys()].map((id) => this.get(id)); }
-    get launchObservationCount() { return this.actors.size; }
-    get degraded() { return this.failed; }
-    markStale() {
-        for (const [id, task] of this.tasks)
-            this.tasks.set(id, { ...task, live: false, stale: true });
-        return this.all();
-    }
-    degrade() {
-        this.failed = true;
-        return this.markStale();
-    }
-    observeLaunch(toolUseId, agentId) {
-        if (this.failed || !identifier(toolUseId) || !identifier(agentId))
-            return [];
-        const prior = this.actors.get(toolUseId);
-        if (prior !== undefined && prior !== agentId)
-            this.actors.set(toolUseId, null);
-        else if (prior === undefined && this.actors.size < this.maxTasks)
-            this.actors.set(toolUseId, agentId);
-        const changed = [];
-        for (const [id, task] of this.tasks) {
-            if (task.origin.launchingToolUseId !== toolUseId)
-                continue;
-            const actor = this.actors.get(toolUseId);
-            const next = { ...task, origin: { ...task.origin,
-                    agentId: this.conflicts.has(id) ? undefined : actor ?? undefined },
-                stale: actor === null || this.conflicts.has(id) || task.stale };
-            this.tasks.set(id, next);
-            changed.push(next);
-        }
-        return changed;
-    }
-    ensure(taskId) {
-        if (!identifier(taskId))
-            return undefined;
-        const existing = this.tasks.get(taskId);
-        if (existing)
-            return existing;
-        if (this.tasks.size >= this.maxTasks) {
-            this.degrade();
-            return undefined;
-        }
-        const task = { origin: { rootSessionId: this.rootSessionId, runtimeGeneration: this.runtimeGeneration,
-                taskId }, state: 'unknown', live: false, stale: false };
-        this.tasks.set(taskId, task);
-        return task;
-    }
-    apply(message) {
-        if (this.failed || message.type !== 'system' || message.session_id !== this.rootSessionId ||
-            !identifier(message.uuid) || this.seen.has(message.uuid))
-            return [];
-        if (this.seen.size >= this.maxTasks * 4)
-            return this.degrade();
-        if (message.subtype === 'background_tasks_changed' && message.tasks.length > this.maxTasks)
-            return this.degrade();
-        if (message.subtype === 'background_tasks_changed') {
-            const added = new Set();
-            for (const entry of message.tasks) {
-                if (identifier(entry.task_id) && !this.tasks.has(entry.task_id))
-                    added.add(entry.task_id);
-                if (this.tasks.size + added.size > this.maxTasks)
-                    return this.degrade();
-            }
-        }
-        const previous = new Map(this.tasks);
-        this.seen.add(message.uuid);
-        if (message.subtype === 'background_tasks_changed') {
-            const current = new Map(message.tasks.filter((entry) => identifier(entry.task_id))
-                .map((entry) => [entry.task_id, entry]));
-            for (const [id, task] of this.tasks) {
-                if (!terminal(task.state) && task.background) {
-                    const next = { ...task, live: current.has(id),
-                        stale: current.has(id) ? this.conflicts.has(id) : task.stale };
-                    if (!sameTask(task, next))
-                        this.tasks.set(id, next);
-                }
-            }
-            for (const [id, entry] of current) {
-                const task = this.ensure(id);
-                if (task && !terminal(task.state)) {
-                    const next = { ...task, state: 'running', live: true,
-                        stale: this.conflicts.has(id), taskType: entry.task_type, background: true };
-                    if (!sameTask(task, next))
-                        this.tasks.set(id, next);
-                }
-            }
-        }
-        else if (message.subtype === 'task_started' || message.subtype === 'task_progress') {
-            const task = this.ensure(message.task_id);
-            if (task && !terminal(task.state)) {
-                const toolId = identifier(message.tool_use_id) ? message.tool_use_id : task.origin.launchingToolUseId;
-                if (toolId && !this.launchTasks.has(toolId) && this.launchTasks.size < this.maxTasks)
-                    this.launchTasks.set(toolId, message.task_id);
-                else if (toolId && this.launchTasks.get(toolId) !== message.task_id) {
-                    this.conflicts.add(message.task_id);
-                    const other = this.launchTasks.get(toolId);
-                    if (other) {
-                        this.conflicts.add(other);
-                        const previous = this.tasks.get(other);
-                        if (previous)
-                            this.tasks.set(other, { ...previous, stale: true,
-                                origin: { ...previous.origin, agentId: undefined } });
-                    }
-                }
-                const actor = toolId && this.actors.get(toolId);
-                this.tasks.set(message.task_id, { ...task, state: 'running', stale: this.conflicts.has(message.task_id),
-                    taskType: 'task_type' in message ? message.task_type : task.taskType,
-                    origin: { ...task.origin, launchingToolUseId: toolId,
-                        agentId: this.conflicts.has(message.task_id) ? undefined : actor ?? task.origin.agentId } });
-            }
-        }
-        else if (message.subtype === 'task_updated') {
-            const task = this.ensure(message.task_id);
-            if (task && !terminal(task.state)) {
-                const status = message.patch.status;
-                const state = status === 'killed' ? 'stopped' : status ?? task.state;
-                this.tasks.set(message.task_id, { ...task, state, live: terminal(state) ? false : task.live,
-                    stale: this.conflicts.has(message.task_id), background: message.patch.is_backgrounded ?? task.background });
-            }
-        }
-        else if (message.subtype === 'task_notification') {
-            const task = this.ensure(message.task_id);
-            if (task && (!this.notified.has(message.task_id) ||
-                (task.state === 'stopped' && message.status === 'completed'))) {
-                this.notified.add(message.task_id);
-                this.tasks.set(message.task_id, { ...task, state: message.status,
-                    live: false, stale: this.conflicts.has(message.task_id) });
-            }
-        }
-        return [...this.tasks].filter(([id, task]) => task !== previous.get(id)).map(([id]) => this.get(id));
-    }
-}