@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/qoderAdapter/observerPlugin.js

@@ -1,245 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, mkdir, mkdtemp, open, realpath, rmdir, unlink, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
-export const OBSERVER_LIMITS = Object.freeze({
-    stdinBytes: 131072, frameBytes: 32768, queueBytes: 1048576, frames: 256,
-});
-const identifier = (value) => typeof value === 'string' &&
-    value.length > 0 && value.length <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-const sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino;
-export async function validateObserverDirectory(plugin) {
-    const directory = await lstat(plugin.pluginDir);
-    if (!directory.isDirectory() || directory.isSymbolicLink() || !sameFile(directory, plugin.directory) ||
-        directory.uid !== process.getuid?.() || (directory.mode & 0o077) !== 0 ||
-        await realpath(plugin.pluginDir) !== plugin.pluginDir)
-        throw new Error('filesystem');
-}
-export async function openObserverFile(plugin, path, writable = false) {
-    await validateObserverDirectory(plugin);
-    const file = await open(path, (writable ? constants.O_RDWR : constants.O_RDONLY) | constants.O_NOFOLLOW);
-    try {
-        const info = await file.stat();
-        if (!info.isFile() || info.nlink !== 1 || info.uid !== process.getuid?.() ||
-            (info.mode & 0o077) !== 0 || (plugin.files[path] && !sameFile(info, plugin.files[path])))
-            throw new Error('filesystem');
-        await validateObserverDirectory(plugin);
-        return file;
-    }
-    catch (error) {
-        await file.close();
-        throw error;
-    }
-}
-export async function acquireObserverLock(plugin) {
-    await validateObserverDirectory(plugin);
-    for (let attempt = 0; attempt < 10; attempt++) {
-        try {
-            await mkdir(plugin.lockPath, { mode: 0o700 });
-            const identity = await lstat(plugin.lockPath);
-            await validateObserverDirectory(plugin);
-            return async () => {
-                const current = await lstat(plugin.lockPath);
-                if (!current.isDirectory() || !sameFile(current, identity))
-                    throw new Error('filesystem');
-                await rmdir(plugin.lockPath);
-            };
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST')
-                throw error;
-            const lock = await lstat(plugin.lockPath);
-            if (!lock.isDirectory() || lock.isSymbolicLink())
-                throw new Error('filesystem');
-            await new Promise((done) => setTimeout(done, 10));
-        }
-    }
-    throw new Error('lock-busy');
-}
-// The generated CJS helper resolves only Node built-ins, independent of cwd or installed packages.
-const HELPER = String.raw `'use strict';
-const fs = require('node:fs'), path = require('node:path');
-const C = fs.constants;
-let config, directory, degraded;
-function same(a,b) { return a.dev === b.dev && a.ino === b.ino; }
-function id(x) { return typeof x === 'string' && x.length > 0 && x.length <= 256 && !/[\x00-\x1f\x7f]/.test(x); }
-function checkDir() {
-  const s = fs.lstatSync(directory);
-  if (!s.isDirectory() || s.isSymbolicLink() || !same(s,config.directory) || s.uid !== process.getuid() ||
-      (s.mode & 63) || fs.realpathSync(directory) !== directory) throw Error('filesystem');
-}
-function file(name, write) {
-  checkDir();
-  const p = path.join(directory,name), fd = fs.openSync(p,(write ? C.O_RDWR : C.O_RDONLY)|C.O_NOFOLLOW);
-  try {
-    const s = fs.fstatSync(fd);
-    if (!s.isFile() || s.nlink !== 1 || s.uid !== process.getuid() || (s.mode & 63) ||
-        (config.files[p] && !same(s,config.files[p]))) throw Error('filesystem');
-    checkDir(); return fd;
-  } catch(e) { fs.closeSync(fd); throw e; }
-}
-function degrade(reason) {
-  try {
-    if (!config) return;
-    checkDir();
-    const fd = fs.openSync(degraded,C.O_WRONLY|C.O_CREAT|C.O_EXCL|C.O_NOFOLLOW,384);
-    try { fs.writeSync(fd,reason.slice(0,128)); } finally { fs.closeSync(fd); }
-  } catch (_) {}
-}
-async function lock() {
-  const p = path.join(directory,'lock');
-  for(let n=0;n<10;n++) {
-    checkDir();
-    try {
-      fs.mkdirSync(p,{mode:448}); const held = fs.lstatSync(p); checkDir();
-      return () => { const now=fs.lstatSync(p); if(!now.isDirectory() || !same(now,held)) throw Error('filesystem'); fs.rmdirSync(p); };
-    } catch(e) {
-      if(e.code !== 'EEXIST') throw e;
-      const s=fs.lstatSync(p); if(!s.isDirectory() || s.isSymbolicLink()) throw Error('filesystem');
-      await new Promise(r=>setTimeout(r,10));
-    }
-  }
-  throw Error('lock-busy');
-}
-async function input(limit) {
-  return new Promise((done,reject)=>{
-    const chunks=[]; let length=0;
-    const timer=setTimeout(()=>{ process.stdin.destroy(); reject(Error('input-timeout')); },1000);
-    process.stdin.on('data',chunk=>{
-      length += chunk.length;
-      if(length > limit) { clearTimeout(timer); process.stdin.destroy(); reject(Error('stdin-limit')); }
-      else chunks.push(chunk);
-    });
-    process.stdin.on('end',()=>{
-      clearTimeout(timer);
-      try { done(new TextDecoder('utf-8',{fatal:true}).decode(Buffer.concat(chunks))); }
-      catch(_) { reject(Error('input')); }
-    });
-    process.stdin.on('error',()=>{ clearTimeout(timer); reject(Error('stdin')); });
-  });
-}
-async function main() {
-  const configPath=process.argv[2];
-  if(!configPath || !path.isAbsolute(configPath) || path.basename(configPath)!=='binding.json') return;
-  directory=path.dirname(configPath); degraded=path.join(directory,'degraded');
-  const fd=fs.openSync(configPath,C.O_RDONLY|C.O_NOFOLLOW);
-  try {
-    const s=fs.fstatSync(fd); if(!s.isFile() || s.nlink!==1 || s.uid!==process.getuid() || (s.mode&63) || s.size>8192) return;
-    const b=Buffer.alloc(8193), size=fs.readSync(fd,b,0,b.length,0);
-    if(size>8192) return; config=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(b.subarray(0,size)));
-  } finally { fs.closeSync(fd); }
-  if(!id(config.rootSessionId)||!id(config.runtimeGeneration)||!id(config.token)||config.token.length<16) return;
-  checkDir();
-  const limits=config.limits, maxima={stdinBytes:131072,frameBytes:32768,queueBytes:1048576,frames:256};
-  for(const k of Object.keys(maxima)) if(!Number.isInteger(limits[k])||limits[k]<1||limits[k]>maxima[k]) return;
-  let raw;
-  try { raw=JSON.parse(await input(limits.stdinBytes)); } catch(e) { degrade(e.message==='stdin-limit'?'stdin-limit':'input'); return; }
-  if(!raw || typeof raw!=='object' || raw.session_id!==config.rootSessionId) { degrade('root-mismatch'); return; }
-  const names=['SubagentStart','SubagentStop','PreToolUse','PostToolUse','PermissionRequest'];
-  if(!names.includes(raw.hook_event_name)) { degrade('unknown-event'); return; }
-  const event={hook_event_name:raw.hook_event_name,session_id:raw.session_id};
-  for(const k of ['tool_use_id','agent_id','tool_name']) {
-    if(raw[k]!==undefined) { if(!id(raw[k])) { degrade('invalid-identity'); return; } event[k]=raw[k]; }
-  }
-  if(raw.hook_event_name==='PostToolUse' && raw.tool_name==='Agent') {
-    const r=raw.tool_response;
-    if(r && typeof r==='object' && !Array.isArray(r)) {
-      event.tool_response={};
-      for(const k of ['kind','agentId','agent_id','status']) if(r[k]!==undefined) {
-        if(!id(r[k])) { degrade('invalid-identity'); return; } event.tool_response[k]=r[k];
-      }
-      if(r.isAsync!==undefined) {
-        if(typeof r.isAsync!=='boolean') { degrade('invalid-identity'); return; }
-        event.tool_response.isAsync=r.isAsync;
-      }
-    }
-  }
-  const line=JSON.stringify({version:1,rootSessionId:config.rootSessionId,runtimeGeneration:config.runtimeGeneration,token:config.token,event})+'\n';
-  if(Buffer.byteLength(line)>limits.frameBytes) { degrade('frame-limit'); return; }
-  const release=await lock();
-  try {
-    const q=file('queue.jsonl',true);
-    try {
-      const s=fs.fstatSync(q); if(s.size>limits.queueBytes) throw Error('queue-limit');
-      const b=Buffer.alloc(limits.queueBytes+1), size=fs.readSync(q,b,0,b.length,0);
-      if(size>limits.queueBytes) throw Error('queue-limit');
-      const previous=new TextDecoder('utf-8',{fatal:true}).decode(b.subarray(0,size));
-      if(previous && !previous.endsWith('\n')) throw Error('queue-invalid');
-      if(size+Buffer.byteLength(line)>limits.queueBytes || previous.split('\n').length-1>=limits.frames) throw Error('queue-limit');
-      fs.writeSync(q,line,size,'utf8');
-    } finally { fs.closeSync(q); }
-  } finally { release(); }
-}
-main().catch(e=>degrade(['lock-busy','queue-limit','queue-invalid'].includes(e.message)?e.message:'filesystem')).finally(()=>process.exit(0));
-`;
-export async function createObserverPlugin(runDir, binding, options = {}) {
-    if (process.release.name !== 'node' || Number(process.versions.node.split('.')[0]) < 20 ||
-        !['linux', 'darwin'].includes(process.platform) || !isAbsolute(process.execPath))
-        throw new Error('Unsupported observer interpreter');
-    if (!identifier(binding.rootSessionId) || !identifier(binding.runtimeGeneration) ||
-        !identifier(binding.token) || binding.token.length < 16)
-        throw new Error('Invalid observer binding');
-    const limits = { ...OBSERVER_LIMITS, ...options.limits };
-    for (const key of Object.keys(OBSERVER_LIMITS)) {
-        if (!Number.isInteger(limits[key]) || limits[key] < 1 || limits[key] > OBSERVER_LIMITS[key])
-            throw new Error('Invalid observer limit');
-    }
-    const parent = await lstat(resolve(runDir));
-    if (!parent.isDirectory() || parent.isSymbolicLink())
-        throw new Error('Invalid observer directory');
-    const pluginDir = await mkdtemp(join(await realpath(runDir), 'observer-'));
-    const helperPath = join(pluginDir, 'observer.cjs'), configPath = join(pluginDir, 'binding.json');
-    const queuePath = join(pluginDir, 'queue.jsonl'), lockPath = join(pluginDir, 'lock');
-    const degradedPath = join(pluginDir, 'degraded');
-    const directories = [join(pluginDir, 'hooks'), join(pluginDir, '.qoder-plugin')];
-    for (const path of directories)
-        await mkdir(path, { mode: 0o700 });
-    const directory = await lstat(pluginDir);
-    const files = {};
-    const put = async (path, text) => {
-        await writeFile(path, text, { mode: 0o600, flag: 'wx' });
-        const info = await lstat(path);
-        files[path] = { dev: info.dev, ino: info.ino };
-    };
-    await put(helperPath, HELPER);
-    await put(queuePath, '');
-    const command = process.execPath, args = [helperPath, configPath];
-    const hooks = Object.fromEntries(['SubagentStart', 'SubagentStop', 'PreToolUse', 'PostToolUse', 'PermissionRequest']
-        .map((name) => [name, [{ hooks: [{ type: 'command', command, args, timeout: 2 }] }]]));
-    await put(join(pluginDir, 'hooks/hooks.json'), JSON.stringify({ hooks }));
-    await put(join(pluginDir, '.qoder-plugin/plugin.json'), JSON.stringify({ name: 'axom-observer', version: '1.0.0' }));
-    await put(configPath, JSON.stringify({ ...binding, directory: { dev: directory.dev, ino: directory.ino }, files, limits }));
-    let disposed = false;
-    const plugin = { ...binding, pluginDir, helperPath, configPath, queuePath, lockPath, degradedPath,
-        command, args, limits, directory: { dev: directory.dev, ino: directory.ino }, files,
-        async dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            const release = await acquireObserverLock(plugin);
-            try {
-                for (const path of [configPath, ...Object.keys(files).filter((path) => path !== configPath)]) {
-                    const info = await lstat(path);
-                    if (!info.isFile() || !sameFile(info, files[path]))
-                        throw new Error('filesystem');
-                    await unlink(path);
-                }
-                try {
-                    const marker = await openObserverFile(plugin, degradedPath);
-                    await marker.close();
-                    await unlink(degradedPath);
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT')
-                        throw error;
-                }
-            }
-            finally {
-                await release();
-            }
-            for (const path of directories)
-                await rmdir(path);
-            await rmdir(pluginDir);
-        },
-    };
-    return plugin;
-}

package/dist/workstation/qoderAdapter/observerReceiver.js

@@ -1,187 +0,0 @@
-import { acquireObserverLock, openObserverFile } from './observerPlugin.js';
-export class ObserverReceiver {
-    plugin;
-    options;
-    rejected = [];
-    closed = false;
-    failed = false;
-    observed = false;
-    started = false;
-    inFlight;
-    timer;
-    get diagnostics() { return [...this.rejected]; }
-    get healthy() { return !this.closed && !this.failed && this.observed; }
-    constructor(plugin, options) {
-        this.plugin = plugin;
-        this.options = options;
-    }
-    degrade(reason) {
-        if (this.closed)
-            return;
-        this.failed = true;
-        this.rejected.push(reason);
-        if (this.rejected.length > 32)
-            this.rejected.shift();
-        try {
-            this.options.onDegraded?.(reason);
-        }
-        catch { /* Observation never interrupts native work. */ }
-    }
-    drain() {
-        if (this.closed)
-            return Promise.resolve();
-        if (!this.inFlight)
-            this.inFlight = this.readBatch().finally(() => { this.inFlight = undefined; });
-        return this.inFlight;
-    }
-    start() {
-        if (this.closed || this.started)
-            return;
-        this.started = true;
-        const poll = async () => {
-            this.timer = undefined;
-            await this.drain();
-            if (!this.closed)
-                this.timer = setTimeout(poll, 100);
-        };
-        this.timer = setTimeout(poll, 0);
-    }
-    async readBatch() {
-        let release;
-        let batch = [];
-        try {
-            const config = await openObserverFile(this.plugin, this.plugin.configPath);
-            await config.close();
-            try {
-                const marker = await openObserverFile(this.plugin, this.plugin.degradedPath);
-                try {
-                    if ((await marker.stat()).size > 128)
-                        throw new Error('filesystem');
-                    this.degrade('helper-degraded');
-                }
-                finally {
-                    await marker.close();
-                }
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-            release = await acquireObserverLock(this.plugin);
-            const file = await openObserverFile(this.plugin, this.plugin.queuePath, true);
-            try {
-                if ((await file.stat()).size > this.plugin.limits.queueBytes)
-                    throw new Error('queue-limit');
-                const bytes = Buffer.alloc(this.plugin.limits.queueBytes + 1);
-                const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
-                if (bytesRead > this.plugin.limits.queueBytes)
-                    throw new Error('queue-limit');
-                const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, bytesRead));
-                if (text && !text.endsWith('\n'))
-                    throw new Error('queue-invalid');
-                const lines = text ? text.slice(0, -1).split('\n') : [];
-                if (lines.length > this.plugin.limits.frames)
-                    throw new Error('queue-limit');
-                batch = lines.map((line) => {
-                    if (Buffer.byteLength(line) + 1 > this.plugin.limits.frameBytes)
-                        throw new Error('frame-limit');
-                    return this.normalize(JSON.parse(line));
-                });
-                await file.truncate(0);
-            }
-            finally {
-                await file.close();
-            }
-            await release();
-            release = undefined;
-            for (const observation of batch) {
-                if (this.closed)
-                    break;
-                this.observed = true;
-                if (observation.conflict)
-                    this.degrade('identity-conflict');
-                try {
-                    this.options.onObservation(observation);
-                }
-                catch {
-                    this.degrade('callback');
-                }
-            }
-        }
-        catch (error) {
-            const reason = error instanceof Error && ['queue-limit', 'frame-limit', 'queue-invalid', 'binding', 'event', 'identity', 'lock-busy'].includes(error.message)
-                ? error.message : 'filesystem';
-            this.degrade(reason);
-        }
-        finally {
-            if (release)
-                try {
-                    await release();
-                }
-                catch {
-                    this.degrade('filesystem');
-                }
-        }
-    }
-    normalize(input) {
-        const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
-        const id = (value) => typeof value === 'string' && value.length > 0 &&
-            value.length <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-        if (!object(input) || input.version !== 1 || input.rootSessionId !== this.plugin.rootSessionId ||
-            input.runtimeGeneration !== this.plugin.runtimeGeneration || input.token !== this.plugin.token)
-            throw new Error('binding');
-        const event = input.event;
-        if (!object(event) || event.session_id !== this.plugin.rootSessionId ||
-            !['PreToolUse', 'PostToolUse', 'SubagentStart', 'SubagentStop', 'PermissionRequest'].includes(event.hook_event_name))
-            throw new Error('event');
-        for (const key of ['agent_id', 'tool_use_id', 'tool_name']) {
-            if (event[key] !== undefined && !id(event[key]))
-                throw new Error('identity');
-        }
-        const eventName = event.hook_event_name;
-        const root = { rootSessionId: this.plugin.rootSessionId, runtimeGeneration: this.plugin.runtimeGeneration };
-        if (eventName === 'PermissionRequest')
-            return { eventName };
-        if (eventName === 'SubagentStart' || eventName === 'SubagentStop') {
-            if (!id(event.agent_id))
-                throw new Error('identity');
-            return { eventName, origin: { ...root, agentId: event.agent_id } };
-        }
-        if (!id(event.tool_use_id))
-            throw new Error('identity');
-        if (eventName === 'PostToolUse' && event.tool_name === 'Agent') {
-            const response = event.tool_response;
-            if (!object(response))
-                throw new Error('identity');
-            const background = response.kind === undefined && response.isAsync === true && response.status === 'async_launched';
-            const foreground = response.kind === 'agent-result' && response.isAsync === undefined && response.status === undefined;
-            if (!foreground && !background)
-                throw new Error('identity');
-            const camel = response.agentId, snake = response.agent_id;
-            if ((camel !== undefined && !id(camel)) || (snake !== undefined && !id(snake)) || (!camel && !snake))
-                throw new Error('identity');
-            if (camel && snake && camel !== snake)
-                return { eventName, conflict: { ...root, launchingToolUseId: event.tool_use_id } };
-            return { eventName, launch: { ...root, launchingToolUseId: event.tool_use_id, agentId: (camel ?? snake) } };
-        }
-        return { eventName, ...(id(event.agent_id) ? { origin: { ...root, toolUseId: event.tool_use_id, agentId: event.agent_id } } : {}) };
-    }
-    async dispose() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        clearTimeout(this.timer);
-        this.timer = undefined;
-        await this.inFlight;
-        try {
-            await this.plugin.dispose();
-        }
-        catch {
-            this.failed = true;
-            try {
-                this.options.onDegraded?.('cleanup');
-            }
-            catch { /* Best-effort observer cleanup. */ }
-        }
-    }
-}

package/dist/workstation/qoderAdapter/permissions.js

@@ -1,61 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export class PermissionBridge {
-    options;
-    stopped = false;
-    pending = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    canUseTool = async (name, input, options) => {
-        const denied = (message) => ({ behavior: 'deny', message, toolUseID: options.toolUseID });
-        if (this.stopped)
-            return denied('Session closed');
-        if (options.signal.aborted)
-            return denied('Permission request cancelled');
-        if (name === 'AskUserQuestion')
-            return denied('AskUserQuestion answer mapping is unsupported');
-        if (!options.toolUseID || Buffer.byteLength(options.toolUseID, 'utf8') > 256 || /[\x00-\x1f\x7f]/.test(options.toolUseID) ||
-            (options.agentID !== undefined && (!options.agentID || Buffer.byteLength(options.agentID, 'utf8') > 256 || /[\x00-\x1f\x7f]/.test(options.agentID)))) {
-            return denied('Invalid permission identity');
-        }
-        if (this.pending.size >= 64 || [...this.pending.values()].some((entry) => entry.toolUseID === options.toolUseID)) {
-            return denied('Permission request capacity or identity conflict');
-        }
-        if (Buffer.byteLength(JSON.stringify(input), 'utf8') > 32768)
-            return denied('Permission input capacity exceeded');
-        const requestId = randomUUID();
-        const allowed = options.permissionOptions === undefined || options.permissionOptions.some((option) => option.outcome === 'proceed_once' && option.allowed === true);
-        const controller = new AbortController();
-        return new Promise((resolve) => {
-            let settled = false;
-            const settle = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                options.signal.removeEventListener('abort', cancelled);
-                this.pending.delete(requestId);
-                controller.abort();
-                resolve(result);
-                void this.options.closed?.(requestId).catch(() => { });
-            };
-            const cancelled = () => settle(denied('Permission request cancelled'));
-            options.signal.addEventListener('abort', cancelled, { once: true });
-            this.pending.set(requestId, { toolUseID: options.toolUseID, deny: (message) => settle(denied(message)) });
-            const origin = { rootSessionId: this.options.rootSessionId, runtimeGeneration: this.options.runtimeGeneration,
-                toolUseId: options.toolUseID, ...(options.agentID ? { agentId: options.agentID } : {}) };
-            const request = { sessionId: this.options.rootSessionId,
-                toolCall: { toolCallId: options.toolUseID, title: name, rawInput: input,
-                    _meta: { qoderSdk: { version: 1, requestId, origin, blockingScope: 'root', callbackOnly: true } } },
-                options: [...(allowed ? [{ optionId: 'allow', name: 'Allow Once', kind: 'allow_once' }] : []),
-                    { optionId: 'reject', name: 'Reject', kind: 'reject_once' }] };
-            Promise.resolve().then(() => this.options.request(request, controller.signal)).then((response) => {
-                settle(response.outcome.outcome === 'selected' && response.outcome.optionId === 'allow' && allowed
-                    ? { behavior: 'allow', permissionScope: 'once', updatedInput: input, toolUseID: options.toolUseID }
-                    : denied('Rejected by user'));
-            }, () => settle(denied('Permission delivery unavailable')));
-        });
-    };
-    onElicitation = async () => ({ action: 'cancel' });
-    close() { this.stopped = true; for (const request of this.pending.values())
-        request.deny('Session closed'); }
-}

package/dist/workstation/qoderAdapter/profile.js

@@ -1,93 +0,0 @@
-// H7 must add independently certified records. Runtime declarations cannot populate this list.
-export const QODER_CERTIFICATIONS = [];
-const certificationKeys = ['cliVersion', 'sdkVersion', 'mode', 'persistent', 'agentMessaging',
-    'transport', 'executable', 'protocolVersion', 'platform', 'runtimeSource',
-    'completedContinuationEnabled', 'sendMessageExposed'];
-export function sameProfileIdentity(previous, next) {
-    return ['cliVersion', 'sdkVersion', 'mode', 'persistent', 'agentMessaging', 'transport',
-        'executable', 'platform', 'runtimeSource', 'completedContinuationEnabled']
-        .every((key) => previous[key] === undefined || previous[key] === 'unknown' || previous[key] === next[key]);
-}
-export function capabilitiesFor(profile, task, certifications = QODER_CERTIFICATIONS, binding) {
-    const bound = profile.rootConfirmed === true && profile.initialized === true &&
-        !!profile.rootSessionId && profile.rootSessionId === task.origin.rootSessionId &&
-        !!profile.runtimeGeneration && profile.runtimeGeneration === task.origin.runtimeGeneration;
-    const profileFingerprint = [profile.executable, profile.cliVersion, profile.sdkVersion].join('\u001e');
-    const bindingMatches = !binding || (binding.mode === 'SDK_ADAPTER' &&
-        binding.launchFingerprint === profileFingerprint && binding.agentKey === 'qoder' &&
-        binding.registryAgent === 'qoder');
-    const certified = bound && bindingMatches && profile.mode === 'sdk-adapter' && profile.observerHealthy && !task.stale &&
-        certifications.some((entry) => certificationKeys.every((key) => entry[key] === profile[key]));
-    const exact = !!task.origin.taskId?.trim();
-    return {
-        inspect: !!task.origin.rootSessionId.trim() && !task.stale,
-        stopActiveRun: certified && exact && task.live && task.state === 'running' &&
-            profile.capabilities.includes('background_tasks_v1'),
-        continueCompleted: certified && exact && task.state === 'completed' && !task.live &&
-            profile.persistent && profile.agentMessaging && profile.completedContinuationEnabled && profile.sendMessageExposed,
-        continueStopped: false,
-    };
-}
-export function parseQoderProfile(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    const strings = ['cliVersion', 'sdkVersion', 'executable'];
-    const booleans = ['persistent', 'agentMessaging', 'observerHealthy', 'completedContinuationEnabled', 'sendMessageExposed'];
-    if (strings.some((key) => typeof input[key] !== 'string' || !input[key].trim() ||
-        input[key].length > (key === 'executable' ? 4096 : 64) ||
-        /[\x00-\x1f\x7f]/.test(input[key])) ||
-        !/^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/.test(input.cliVersion) ||
-        !/^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/.test(input.sdkVersion) ||
-        /^[a-zA-Z]+:\/\//.test(input.executable) ||
-        booleans.some((key) => typeof input[key] !== 'boolean') ||
-        !['native-acp', 'sdk-adapter'].includes(input.mode) ||
-        !['process', 'worker'].includes(input.transport) ||
-        !Array.isArray(input.capabilities) || input.capabilities.length > 256 ||
-        input.capabilities.some((item) => typeof item !== 'string' || item.length > 128 || !/^[a-zA-Z0-9_.-]+$/.test(item)))
-        return undefined;
-    const result = Object.fromEntries([...strings, ...booleans, 'mode', 'transport']
-        .map((key) => [key, input[key]]));
-    for (const key of ['initialized', 'rootConfirmed']) {
-        if (input[key] !== undefined) {
-            if (typeof input[key] !== 'boolean')
-                return undefined;
-            result[key] = input[key];
-        }
-    }
-    for (const key of ['rootSessionId', 'runtimeGeneration', 'platform']) {
-        if (input[key] !== undefined) {
-            if (typeof input[key] !== 'string' || !input[key].trim() ||
-                input[key].length > 256 || /[\x00-\x1f\x7f]/.test(input[key]))
-                return undefined;
-            result[key] = input[key];
-        }
-    }
-    if (input.protocolVersion !== undefined) {
-        if (!Number.isSafeInteger(input.protocolVersion) || input.protocolVersion < 0 ||
-            input.protocolVersion > 2_147_483_647)
-            return undefined;
-        result.protocolVersion = input.protocolVersion;
-    }
-    if (input.runtimeSource !== undefined) {
-        if (!['explicit-local', 'sdk-bundled', 'downloaded', 'unknown'].includes(input.runtimeSource))
-            return undefined;
-        result.runtimeSource = input.runtimeSource;
-    }
-    return { ...result, capabilities: [...new Set(input.capabilities)] };
-}
-export function isRuntimeDiagnostics(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const input = value;
-    const bounded = (value, max) => typeof value === 'string' &&
-        value.trim().length > 0 && value.length <= max && !/[\x00-\x1f\x7f]/.test(value);
-    if (!bounded(input.generation, 256) || !Number.isSafeInteger(input.revision) ||
-        input.revision < 0 || typeof input.available !== 'boolean' ||
-        !input.launch || typeof input.launch !== 'object')
-        return false;
-    const launch = input.launch;
-    return ['command-override', 'registry', 'registry-fallback', 'direct'].includes(launch.source) &&
-        bounded(launch.executable, 4096) && bounded(launch.platform, 64) && bounded(launch.architecture, 64) &&
-        launch.transport === 'stdio' && (input.profile === undefined || parseQoderProfile(input.profile) !== undefined);
-}

package/dist/workstation/qoderAdapter/sdkDriver.js

@@ -1,48 +0,0 @@
-import { execFile } from 'node:child_process';
-import { realpath, stat } from 'node:fs/promises';
-import { isAbsolute } from 'node:path';
-import { promisify } from 'node:util';
-/**
- * Versions whose SDK stream contract has been exercised with live steering.
- * Keep this allowlist explicit: a future Qoder release must first prove that
- * `priority: "now"` still emits an abort receipt followed by the replacement
- * result before the adapter advertises the extension.  Retirement condition:
- * once ACP exposes a native steering capability with the same lifecycle
- * semantics, remove this adapter gate and route through that capability.
- */
-export const QODER_SDK_STEERING_CLI_VERSIONS = ['1.1.61', '1.1.64'];
-export function supportsQoderSdkSteering(cliVersion) {
-    return QODER_SDK_STEERING_CLI_VERSIONS.includes(cliVersion);
-}
-export async function loadSdkDriver(executable, sdk, queryFactory) {
-    if (!isAbsolute(executable))
-        throw new Error('Qoder executable must be an absolute local path');
-    let selected;
-    try {
-        selected = await realpath(executable);
-        if (!(await stat(selected)).isFile())
-            throw new Error('not a file');
-    }
-    catch {
-        throw new Error('Qoder executable is unavailable');
-    }
-    let version;
-    try {
-        const result = await promisify(execFile)(selected, ['--version'], { timeout: 5000, maxBuffer: 1024, encoding: 'utf8' });
-        version = result.stdout.trim();
-    }
-    catch {
-        throw new Error('Qoder executable version check failed');
-    }
-    if (!supportsQoderSdkSteering(version))
-        throw new Error(`Qoder executable must report a supported version (${QODER_SDK_STEERING_CLI_VERSIONS.join(' or ')})`);
-    return { executable: selected, sdkVersion: '1.0.50', cliVersion: version,
-        create: ({ prompt, options }) => (queryFactory ?? sdk.query)({ prompt, options: {
-                cwd: options.cwd, sessionId: options.sessionId, plugins: options.plugins,
-                canUseTool: options.canUseTool, onElicitation: options.onElicitation,
-                mcpServers: options.mcpServers, model: options.model, permissionMode: options.permissionMode,
-                sessionStore: options.sessionStore, transport: sdk.ProcessTransport.default,
-                auth: sdk.qodercliAuth(), pathToQoderCLIExecutable: selected,
-            } }),
-    };
-}