@platless/axom-cli 0.1.0 → 0.3.13

package/dist/workstation/qoderAdapter/session.js

@@ -0,0 +1,319 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,163 @@
+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));
+    }
+}

package/dist/workstation/qoderAdapter/types.js

@@ -0,0 +1 @@
+export {};