@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/qoderAdapter/sdkRuntime.js

@@ -0,0 +1,93 @@
+import { createHash } from 'node:crypto';
+import { readFile, realpath, lstat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { clientDir } from '../config.js';
+export const QODER_SDK_VERSION = '1.0.50';
+export const QODER_SDK_PACKAGE = '@qoder-ai/qoder-agent-sdk';
+export const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export async function sdkRecipe(options = {}) {
+    const directory = options.recipeDir ?? fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../../../runtime-deps/qoder-sdk/' : '../../runtime-deps/qoder-sdk/', import.meta.url));
+    const [manifest, lock] = await Promise.all(['package.json', 'package-lock.json'].map(file => readFile(join(directory, file))));
+    const pkg = JSON.parse(manifest.toString());
+    const parsed = JSON.parse(lock.toString());
+    if (pkg.dependencies?.[QODER_SDK_PACKAGE] !== QODER_SDK_VERSION ||
+        parsed.packages?.['']?.dependencies?.[QODER_SDK_PACKAGE] !== QODER_SDK_VERSION ||
+        parsed.packages?.[`node_modules/${QODER_SDK_PACKAGE}`]?.version !== QODER_SDK_VERSION)
+        throw new Error('Invalid bundled Qoder SDK recipe');
+    const digest = sha256(Buffer.concat([Buffer.from('axom-qoder-sdk-v1\0'), manifest, Buffer.from('\0'), lock]));
+    return { manifest, lock, digest, packages: parsed.packages,
+        root: resolve(options.configDir ?? clientDir(), 'acp-adapters', 'qoder-sdk', digest, `${process.platform}-${process.arch}-node${process.versions.node.split('.')[0]}`) };
+}
+function inside(root, file) {
+    const rel = relative(root, file);
+    return rel !== '' && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/** Validate the selected instance, never a package found in an ancestor or global prefix. */
+export async function validateSdkInstance(instance, recipe) {
+    const canonical = await realpath(instance);
+    if (!(await lstat(instance)).isDirectory())
+        throw new Error('SDK instance must not be a symlink');
+    for (const [file, bytes] of [['package.json', recipe.manifest], ['package-lock.json', recipe.lock]]) {
+        if (!(await readFile(join(instance, file))).equals(bytes))
+            throw new Error(`SDK ${file} does not match recipe`);
+    }
+    for (const [key, metadata] of Object.entries(recipe.packages)) {
+        if (key === '')
+            continue;
+        if (!key.startsWith('node_modules/') || key.split('/').includes('..') || metadata.link)
+            throw new Error('Invalid SDK lockfile package path');
+        const directory = join(instance, key);
+        let actual;
+        try {
+            if (!inside(canonical, await realpath(directory)))
+                throw new Error('SDK dependency escapes its instance');
+            actual = JSON.parse(await readFile(join(directory, 'package.json'), 'utf8'));
+        }
+        catch (error) {
+            if (metadata.optional && error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        const name = key.slice(key.lastIndexOf('node_modules/') + 'node_modules/'.length);
+        if (actual.name !== name || actual.version !== metadata.version)
+            throw new Error(`SDK dependency mismatch: ${name}`);
+    }
+    const require = createRequire(join(instance, 'package.json'));
+    const entry = await realpath(require.resolve(QODER_SDK_PACKAGE));
+    if (!inside(join(canonical, 'node_modules', QODER_SDK_PACKAGE), entry))
+        throw new Error('SDK entry escapes its package');
+    return { entry, entrySha256: sha256(await readFile(entry)) };
+}
+export function assertSdkApi(sdk) {
+    const api = sdk;
+    if (!api || ['query', 'qodercliAuth', 'listSubagents', 'getSubagentMessages'].some(key => typeof api[key] !== 'function') || !api.ProcessTransport?.default)
+        throw new Error('Prepared Qoder SDK is missing required APIs');
+}
+export async function readPreparedSdkRuntime(options = {}) {
+    const recipe = await sdkRecipe(options);
+    const pointer = JSON.parse(await readFile(join(recipe.root, 'current.json'), 'utf8'));
+    if (pointer.digest !== recipe.digest || !/^[a-f0-9-]{36}$/.test(pointer.installationId ?? ''))
+        throw new Error('Invalid SDK installation pointer');
+    const instance = join(recipe.root, 'instances', pointer.installationId);
+    const receipt = JSON.parse(await readFile(join(instance, 'receipt.json'), 'utf8'));
+    const validated = await validateSdkInstance(instance, recipe);
+    if (receipt.schema !== 1 || receipt.digest !== recipe.digest || receipt.version !== QODER_SDK_VERSION ||
+        receipt.installationId !== pointer.installationId || receipt.entrySha256 !== validated.entrySha256 ||
+        receipt.lockSha256 !== sha256(recipe.lock))
+        throw new Error('Prepared SDK receipt does not match installation');
+    return { instance, ...validated };
+}
+/** Read-only: ACP serving must never install dependencies or fall back to the developer SDK. */
+export async function loadPreparedSdkRuntime(options = {}) {
+    try {
+        const prepared = await readPreparedSdkRuntime(options);
+        const sdk = await import(pathToFileURL(prepared.entry).href);
+        assertSdkApi(sdk);
+        return { ...prepared, sdk };
+    }
+    catch (cause) {
+        throw new Error(`Qoder SDK is not prepared or is damaged. Run axom qoder-acp --prepare-sdk as the same user with AXOM_WORKSTATION_CONFIG_DIR=${options.configDir ?? clientDir()}`, { cause });
+    }
+}

package/dist/workstation/qoderAdapter/sdkRuntimeInstall.js

@@ -0,0 +1,145 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertSdkApi, QODER_SDK_VERSION, readPreparedSdkRuntime, sdkRecipe, sha256, validateSdkInstance } from './sdkRuntime.js';
+/** No shell, bounded output, and no surviving npm subprocesses after timeout or cancellation. */
+export function runSdkCommand(command, args, options) {
+    return new Promise((resolvePromise, reject) => {
+        if (options.signal?.aborted) {
+            reject(new Error('Qoder SDK preparation cancelled'));
+            return;
+        }
+        if (options.timeoutMs <= 0) {
+            reject(new Error('Qoder SDK preparation timed out'));
+            return;
+        }
+        let output = '', failure;
+        const child = spawn(command, args, { cwd: options.cwd, stdio: ['ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32', windowsHide: true });
+        const capture = (chunk) => { output = (output + chunk.toString()).slice(-8192); };
+        child.stdout.on('data', capture);
+        child.stderr.on('data', capture);
+        const stop = (reason) => {
+            failure ??= new Error(reason);
+            if (!child.pid)
+                return;
+            if (process.platform === 'win32') {
+                const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+                killer.on('error', () => { child.kill('SIGKILL'); });
+            }
+            else {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
+                }
+                catch {
+                    child.kill('SIGKILL');
+                }
+            }
+        };
+        const abort = () => stop('Qoder SDK preparation cancelled');
+        const timer = setTimeout(() => stop('Qoder SDK preparation timed out'), options.timeoutMs);
+        options.signal?.addEventListener('abort', abort, { once: true });
+        const cleanup = () => { clearTimeout(timer); options.signal?.removeEventListener('abort', abort); };
+        child.once('error', error => { cleanup(); reject(error); });
+        child.once('close', code => {
+            cleanup();
+            if (failure)
+                reject(failure);
+            else if (code !== 0)
+                reject(new Error(`Qoder SDK preparation failed (${code}): ${output}`));
+            else
+                resolvePromise();
+        });
+    });
+}
+/** Resolve the npm JavaScript entry so standard Windows npm.cmd never needs shell execution. */
+export async function sdkNpmCli() {
+    const configured = process.env.AXOM_WORKSTATION_NPM_PATH;
+    const candidates = configured ? [configured] : [join(dirname(process.execPath), process.platform === 'win32' ? 'npm.cmd' : 'npm'),
+        ...(process.env.PATH ?? '').split(delimiter).filter(Boolean).map(dir => join(dir, process.platform === 'win32' ? 'npm.cmd' : 'npm'))];
+    for (const candidate of candidates) {
+        try {
+            const actual = await realpath(candidate);
+            if (actual.endsWith(`${join('bin', 'npm-cli.js')}`))
+                return actual;
+            for (const script of [join(dirname(actual), 'node_modules/npm/bin/npm-cli.js'), join(dirname(actual), '../lib/node_modules/npm/bin/npm-cli.js')]) {
+                if ((await stat(script).catch(() => undefined))?.isFile())
+                    return resolve(script);
+            }
+        }
+        catch { /* try the next PATH entry */ }
+    }
+    throw new Error('Cannot resolve npm CLI. Set AXOM_WORKSTATION_NPM_PATH to the standard npm executable.');
+}
+const preparing = new Map();
+export async function prepareSdkRuntime(options = {}) {
+    const recipe = await sdkRecipe(options);
+    // Calls with independent cancellation signals keep their own lifecycle; immutable publication
+    // also handles separate processes without a cross-process lock.
+    if (!options.signal && preparing.has(recipe.root))
+        return preparing.get(recipe.root);
+    const pending = prepare(options, recipe);
+    if (!options.signal)
+        preparing.set(recipe.root, pending);
+    try {
+        return await pending;
+    }
+    finally {
+        if (preparing.get(recipe.root) === pending)
+            preparing.delete(recipe.root);
+    }
+}
+async function prepare(options, recipe) {
+    const budget = options.timeoutMs ?? 300_000;
+    if (!Number.isFinite(budget) || budget <= 0)
+        throw new Error('SDK preparation timeout must be positive');
+    const deadline = Date.now() + budget;
+    const commandOptions = (cwd) => ({ cwd, timeoutMs: deadline - Date.now(), signal: options.signal });
+    const probe = async (entry, cwd) => {
+        const code = `const sdk=await import(${JSON.stringify(pathToFileURL(entry).href)}); (${assertSdkApi.toString()})(sdk);`;
+        await runSdkCommand(process.execPath, ['--input-type=module', '-e', code], commandOptions(cwd));
+    };
+    try {
+        const existing = await readPreparedSdkRuntime(options);
+        await probe(existing.entry, existing.instance);
+        return { instance: existing.instance, alreadyInstalled: true };
+    }
+    catch { /* Missing/damaged runtime: publish a new instance; leave old instances untouched. */ }
+    const installationId = randomUUID();
+    const staging = join(recipe.root, 'staging', installationId);
+    const instance = join(recipe.root, 'instances', installationId);
+    const pointerTemp = join(recipe.root, `current-${installationId}.json`);
+    await mkdir(staging, { recursive: true, mode: 0o700 });
+    try {
+        await writeFile(join(staging, 'package.json'), recipe.manifest);
+        await writeFile(join(staging, 'package-lock.json'), recipe.lock);
+        if (options.install)
+            await options.install(staging, commandOptions(staging));
+        else
+            await runSdkCommand(process.execPath, [await sdkNpmCli(), 'ci', '--ignore-scripts', '--omit=dev', '--include=optional',
+                '--no-audit', '--no-fund'], commandOptions(staging));
+        const validated = await validateSdkInstance(staging, recipe);
+        await probe(validated.entry, staging);
+        if (options.signal?.aborted)
+            throw new Error('Qoder SDK preparation cancelled');
+        if (Date.now() >= deadline)
+            throw new Error('Qoder SDK preparation timed out');
+        await writeFile(join(staging, 'receipt.json'), JSON.stringify({ schema: 1, digest: recipe.digest,
+            version: QODER_SDK_VERSION, installationId, lockSha256: sha256(recipe.lock), entrySha256: validated.entrySha256 }));
+        await mkdir(dirname(instance), { recursive: true, mode: 0o700 });
+        await rename(staging, instance);
+        await writeFile(pointerTemp, JSON.stringify({ digest: recipe.digest, installationId }), { flag: 'wx', mode: 0o600 });
+        if (options.signal?.aborted)
+            throw new Error('Qoder SDK preparation cancelled');
+        if (Date.now() >= deadline)
+            throw new Error('Qoder SDK preparation timed out');
+        await rename(pointerTemp, join(recipe.root, 'current.json'));
+        return { instance, alreadyInstalled: false };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+        await rm(pointerTemp, { force: true });
+    }
+}

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 }, this.dependencies.historyReader);
+    }
+    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' }) });
+}