@platless/axom-cli 0.3.13 → 0.5.9

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

@@ -46,7 +46,7 @@ export class QoderAdapterSession {
                 offset: page?.offset ?? 0, limit: page?.limit ?? 50, hasMore: false, snapshotStable: false,
                 reason: 'invalid-page' };
         }
-        return readChildHistory(root, agentId, { ...page, dir });
+        return readChildHistory(root, agentId, { ...page, dir }, this.dependencies.historyReader);
     }
     async publishProfile() {
         const value = this.currentProfile;

package/dist/workstation/qoderAdapter/subwork.js

@@ -1,5 +1,8 @@
 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 newSubworkData() {
+    return { calls: {}, count: 0 };
+}
 export function supportsSubworkMeta(info) {
     return (info?.name === 'qoder-cli' && info.version === '1.1.61') ||
         (info?.name === 'axom-qoder-sdk' && info.version === '1.0.50');
@@ -18,10 +21,12 @@ function resultText(value) {
 }
 export class SubworkBoundary {
     root;
-    calls = new Map();
-    constructor(root) {
+    data;
+    constructor(root, data = newSubworkData()) {
         this.root = root;
+        this.data = data;
     }
+    get(toolId) { return Object.hasOwn(this.data.calls, toolId) ? this.data.calls[toolId] : undefined; }
     child(toolId) { return `qoder-agent:${this.root}:${toolId}`; }
     map(event) {
         if (event.acpSessionId && event.acpSessionId !== this.root)
@@ -29,16 +34,17 @@ export class SubworkBoundary {
         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;
+        let call = id(toolId) ? this.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) {
+            ['tool_call', 'tool_call_update'].includes(event.eventName) && this.data.count < 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);
+            Object.defineProperty(this.data.calls, toolId, { value: call, enumerable: true, writable: true, configurable: true });
+            this.data.count += 1;
             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 } : {}) });
@@ -60,14 +66,16 @@ export class SubworkBoundary {
                 events.push({ eventName: 'subagent_state_update', payload: { subagentSessionId: call.child, state: terminal },
                     ...(call.parent ? { acpSessionId: call.parent } : {}) });
                 call.ended = true;
+                // Read only by the check above, once: an ended call keeps no stream (checkpointed state).
+                call.streamedText = '';
             }
             // 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') {
+            const owner = this.get(parent), content = object(p.content);
+            if (owner && !owner.ended && event.eventName === 'agent_message_chunk' && content.type === 'text' && typeof content.text === 'string') {
                 owner.streamedText += content.text;
             }
             return [{ ...event, acpSessionId: this.child(parent) }];

package/dist/workstation/systemMetrics.js

@@ -100,6 +100,97 @@ async function defaultDarwinMemoryPressure() {
         return null;
     }
 }
+/**
+ * Parses `ioreg -r -d 1 -w 0 -c AGXAccelerator` output. Apple Silicon publishes live GPU
+ * utilization (`Device Utilization %`, a driver-side running average) and GPU-resident unified
+ * memory (`In use system memory`) in each accelerator's `PerformanceStatistics`, without any
+ * privileges. Intel Macs expose no `AGXAccelerator` class, so they parse to null.
+ */
+export function parseAppleAgxStats(output) {
+    const gpus = output.split('+-o ').slice(1).map((block, index) => {
+        const stats = /"PerformanceStatistics"\s*=\s*\{([^}]*)\}/.exec(block)?.[1];
+        if (stats === undefined)
+            return null;
+        const utilizationPercent = Number(/"Device Utilization %"\s*=\s*(\d+(?:\.\d+)?)/.exec(stats)?.[1]);
+        const memoryUsedBytes = Number(/"In use system memory"\s*=\s*(\d+)/.exec(stats)?.[1]);
+        return {
+            id: `apple:agx-${index}`,
+            name: /"model"\s*=\s*"([^"]+)"/.exec(block)?.[1] ?? 'Apple GPU',
+            utilization: Number.isFinite(utilizationPercent)
+                ? Math.max(0, Math.min(1, utilizationPercent / 100))
+                : null,
+            memoryTotalBytes: null,
+            memoryUsedBytes: Number.isFinite(memoryUsedBytes) && memoryUsedBytes >= 0 ? memoryUsedBytes : null,
+            coreCount: (() => {
+                const cores = Number(/"gpu-core-count"\s*=\s*(\d+)/.exec(block)?.[1]);
+                return Number.isFinite(cores) && cores > 0 ? cores : null;
+            })(),
+        };
+    }).filter((gpu) => gpu !== null);
+    return gpus.length > 0 ? gpus : null;
+}
+async function appleAgxGpuProbe() {
+    try {
+        const { stdout } = await execFileAsync('/usr/sbin/ioreg', ['-r', '-d', '1', '-w', '0', '-c', 'AGXAccelerator'], {
+            timeout: 2_000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return parseAppleAgxStats(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** Parses `nvidia-smi --query-gpu=... --format=csv,noheader,nounits` output; `[N/A]` reads as null. */
+export function parseNvidiaSmiGpus(output) {
+    const mib = (field) => {
+        if (field === undefined)
+            return null;
+        const value = Number(field);
+        return Number.isFinite(value) && value >= 0 ? Math.round(value * 1024 * 1024) : null;
+    };
+    const gpus = output.split(/\r?\n/).map((line) => {
+        const fields = line.split(',').map((field) => field.trim());
+        if (fields.length < 6)
+            return null;
+        const [, uuid, name, utilizationField, totalField, usedField] = fields;
+        if (!/^GPU-/.test(uuid) || name.length === 0)
+            return null;
+        const utilizationPercent = Number(utilizationField);
+        return {
+            id: `nvidia:${uuid}`,
+            name,
+            utilization: Number.isFinite(utilizationPercent)
+                ? Math.max(0, Math.min(1, utilizationPercent / 100))
+                : null,
+            memoryTotalBytes: mib(totalField),
+            memoryUsedBytes: mib(usedField),
+            coreCount: null,
+        };
+    }).filter((gpu) => gpu !== null);
+    return gpus.length > 0 ? gpus : null;
+}
+async function nvidiaSmiGpuProbe() {
+    try {
+        const { stdout } = await execFileAsync('nvidia-smi', [
+            '--query-gpu=index,uuid,name,utilization.gpu,memory.total,memory.used',
+            '--format=csv,noheader,nounits',
+        ], { timeout: 3_000 });
+        return parseNvidiaSmiGpus(stdout);
+    }
+    catch {
+        // Absent binary, driver hiccup, or unsupported GPU -- all read as "no reading", never as failure.
+        return null;
+    }
+}
+async function defaultProbeGpus(platform) {
+    const [apple, nvidia] = await Promise.all([
+        platform === 'darwin' ? appleAgxGpuProbe() : Promise.resolve(null),
+        nvidiaSmiGpuProbe(),
+    ]);
+    const gpus = [...(apple ?? []), ...(nvidia ?? [])];
+    return gpus.length > 0 ? gpus : null;
+}
 /**
  * Low-overhead host sampler. CPU and memory are read only while a heartbeat is being built; storage
  * topology is discovered out of band and capacity reads use the cached representative paths.
@@ -114,6 +205,8 @@ export class SystemMetricsSampler {
     darwinMemoryRefreshInFlight = null;
     darwinMemoryAvailable = null;
     darwinMemoryPressure = null;
+    gpuRefreshInFlight = null;
+    gpus = null;
     constructor(workspaces, deps = {
         platform: process.platform,
         cpus: os.cpus,
@@ -126,12 +219,13 @@ export class SystemMetricsSampler {
         identifyStorage: (cwd, device) => defaultIdentifyStorage(process.platform, cwd, device),
         darwinAvailableMemory: defaultDarwinAvailableMemory,
         darwinMemoryPressure: defaultDarwinMemoryPressure,
+        probeGpus: () => defaultProbeGpus(process.platform),
     }) {
         this.workspaces = workspaces;
         this.deps = deps;
     }
     async start() {
-        await Promise.all([this.refreshTopology(), this.refreshDarwinMemory()]);
+        await Promise.all([this.refreshTopology(), this.refreshDarwinMemory(), this.refreshGpus()]);
         this.refreshTimer = setInterval(() => this.refreshTopologyInBackground(), STORAGE_TOPOLOGY_REFRESH_MS);
         this.refreshTimer.unref();
     }
@@ -143,6 +237,7 @@ export class SystemMetricsSampler {
     snapshot() {
         try {
             this.refreshDarwinMemoryInBackground();
+            this.refreshGpusInBackground();
             const cpus = this.deps.cpus();
             const currentCpu = cpuTotals(cpus);
             const previousCpu = this.previousCpu;
@@ -192,6 +287,7 @@ export class SystemMetricsSampler {
                 memoryTotalBytes,
                 memoryAvailableBytes,
                 storagePools: [...pools.values()],
+                gpus: this.gpus,
             };
         }
         catch {
@@ -218,6 +314,19 @@ export class SystemMetricsSampler {
                 this.darwinMemoryRefreshInFlight = null;
         });
     }
+    refreshGpusInBackground() {
+        if (this.gpuRefreshInFlight)
+            return;
+        const refresh = this.refreshGpus();
+        this.gpuRefreshInFlight = refresh;
+        void refresh.finally(() => {
+            if (this.gpuRefreshInFlight === refresh)
+                this.gpuRefreshInFlight = null;
+        });
+    }
+    async refreshGpus() {
+        this.gpus = await this.deps.probeGpus().catch(() => null);
+    }
     async refreshDarwinMemory() {
         if (this.deps.platform !== 'darwin')
             return;

package/dist/workstation/tools/client.js

@@ -84,15 +84,23 @@ function pidAlive(pid) {
         return error.code === 'EPERM';
     }
 }
+/**
+ * A tools keeper client. The daemon only ever makes the browser kind (`browser`). The kind is required — no default — so nothing can
+ * start the retired terminal-kind tools keeper by accident (spec §9; terminals run in keeper-terminal, files in the daemon's files
+ * host); an explicit `terminal` client exists only for the tests that pin how the retired keeper's startup and tools.info behave.
+ * (`keeperPaths` keeps its terminal default: `keepers/legacy.ts` finds a legacy tools keeper an older CLI left running by it.)
+ */
 export class ToolsClient {
     options;
     kind;
     paths;
     starting;
     browser;
-    constructor(options, kind = 'terminal') {
+    constructor(options, kind) {
         this.options = options;
         this.kind = kind;
+        if (kind !== 'terminal' && kind !== 'browser')
+            throw new Error('ToolsClient needs an explicit kind (browser)');
         this.paths = keeperPaths(options, undefined, undefined, kind);
     }
     async probe(timeoutMs = 250) {

package/dist/workstation/tools/info.js

@@ -0,0 +1,50 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/*
+ * `tools.info`, aggregated by the daemon. Consumers (analysis C §3.6): Workbench app.mjs (version), CoworkService
+ * (files / mediaPreviewVersion / fileFindVersion / home / userName), files.mjs (roots / downloads / terminal),
+ * terminal.mjs (home, terminal / terminalError), browser.mjs (browser* fields). Every field keeps the value and meaning
+ * the legacy tools keeper gave it (tools/core.ts at the merge-base, since deleted, + tools/client.ts), and answering it never
+ * starts any keeper:
+ *   - file fields come from the files host's last `ready` (or are computed here before the first one); `files: true`
+ *     is reported even while the host restarts, so a probe never mistakes the machine for an old CLI;
+ *   - terminal fields come from keeper-terminal's hello capabilities when that keeper is already running (connecting to it,
+ *     never starting it: keepers/terminal/client.ts `terminalStatus`), otherwise from a cached node-pty load check
+ *     (update/ptyPreflight.ts);
+ *   - browser fields come from the browser-kind ToolsClient, whose `tools.info` only returns metadata.
+ */
+/** The legacy keeper always sent this (tools/core.ts at the merge-base); the browser metadata never removed it. */
+export const BROWSER_DISABLED_ERROR = 'Browser tools are not enabled in this release';
+export async function aggregateToolsInfo(sources) {
+    const [files, browser, terminal] = await Promise.all([sources.files(), sources.browser('tools.info', {}), sources.terminal()]);
+    return {
+        version: 1,
+        terminal: terminal.terminal,
+        browser: false,
+        ...files,
+        ...(terminal.terminalError ? { terminalError: terminal.terminalError } : {}),
+        browserError: BROWSER_DISABLED_ERROR,
+        ...browser,
+    };
+}
+/**
+ * The file fields before any files host was ready: the same canonical home and roots the host computes
+ * (scope.ts `configuredRoots`), except that a root which cannot be resolved is left out instead of failing the probe.
+ */
+export async function computeFilesInfo(home, roots) {
+    const canonicalHome = await fs.realpath(home).catch(() => home);
+    const canonical = new Set([canonicalHome]);
+    for (const root of roots) {
+        try {
+            const real = await fs.realpath(root);
+            if ((await fs.stat(real)).isDirectory())
+                canonical.add(real);
+        }
+        catch { /* skipped, as the daemon skips it when starting the host */ }
+    }
+    return {
+        files: true, readOnlyFilesVersion: 1, filesystemFilesVersion: 1, mediaPreviewVersion: 2, fileFindVersion: 1,
+        home: canonicalHome, userName: os.userInfo().username, roots: [...canonical], downloads: path.join(canonicalHome, 'Downloads'),
+    };
+}

package/dist/workstation/tools/keeperProcess.js

@@ -2,18 +2,18 @@ import net from 'node:net';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { ToolsCore } from './core.js';
 import { BrowserCore } from './browser.js';
 import os from 'node:os';
 import { privateDirectory } from './client.js';
 import { object, TOOL_REQUEST_BYTES, TOOL_RESULT_BYTES } from './validation.js';
 export async function runKeeper(config) {
+    // Only the browser keeper runs from here (spec §9): keeper-terminal owns PTYs and the files host owns files.
+    if (config.kind !== 'browser')
+        throw new Error('Only the browser keeper runs from this entry');
     await privateDirectory(path.dirname(config.socket));
     const pidFile = path.join(path.dirname(config.socket), 'keeper.pid.json');
     await fs.writeFile(pidFile, JSON.stringify({ pid: process.pid, identity: config.identity }), { mode: 0o600 });
-    const core = config.kind === 'browser' ? await BrowserCore.create({ home: config.home ?? os.homedir(), profileRoot: config.profileRoot, executablePath: config.executablePath, proxy: config.proxy }) : await ToolsCore.create({ home: config.home, roots: config.roots, uploadStateDir: path.join(path.dirname(config.socket), 'uploads') });
-    if (config.kind !== 'browser')
-        process.chdir(path.dirname(config.socket));
+    const core = await BrowserCore.create({ home: config.home ?? os.homedir(), profileRoot: config.profileRoot, executablePath: config.executablePath, proxy: config.proxy });
     const sockets = new Set();
     let pending = 0;
     const server = net.createServer({ allowHalfOpen: true }, socket => {
@@ -104,7 +104,17 @@ export async function runKeeper(config) {
         } };
 }
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-    const config = JSON.parse(Buffer.from(process.argv[2] ?? '', 'base64').toString('utf8'));
+    let config;
+    try {
+        config = JSON.parse(Buffer.from(process.argv[2] ?? '', 'base64').toString('utf8'));
+    }
+    catch { /* below */ }
+    // Anti-resurrection (spec §9): only the browser keeper still starts from this entry. A terminal-kind config (kind 'terminal',
+    // or no kind from older CLIs) comes from a legacy tools keeper unit restarting (`Restart=on-failure`) or an old launcher:
+    // keeper-terminal owns PTYs now and the files host owns files, so exit cleanly (0, which systemd does not restart) before
+    // touching the socket, the pid manifest or any state.
+    if (config?.kind !== 'browser')
+        process.exit(0);
     const keeper = await runKeeper(config);
     let stopping = false;
     const stop = () => { if (stopping)

package/dist/workstation/tools/router.js

@@ -0,0 +1,55 @@
+import { isFilesToolMethod } from '../files/adapters/toolRequests.js';
+import { keys, validateRequest } from './validation.js';
+export function routeTool(method) {
+    if (method === 'tools.info')
+        return 'info';
+    if (method === 'browser.sharedText')
+        return 'shared-text';
+    if (isFilesToolMethod(method))
+        return 'files';
+    if (method.startsWith('terminal.'))
+        return 'terminal';
+    if (method.startsWith('browser.'))
+        return 'browser';
+    return 'unsupported';
+}
+/** A probe is answered even while the workstation drains and is not work a restart would interrupt. */
+export function isProbeTool(method) { return routeTool(method) === 'info'; }
+/**
+ * Answered while draining and not counted as a shell task: probes, and `terminal.*` (spec §4.1: a PTY lives in its keeper, not in
+ * the daemon, so a restart does not interrupt it; counting every poll made the activity flicker).
+ */
+export function isUnaccountedTool(method) {
+    const route = routeTool(method);
+    return route === 'info' || route === 'terminal';
+}
+export class WorkstationTools {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** One `tool_request` (not `browser.sharedText`). Rejects with the `tool_result.error` text. */
+    async request(method, params) {
+        // Validated at the daemon boundary as well as by whoever runs it.
+        validateRequest(method, params);
+        switch (routeTool(method)) {
+            case 'info':
+                keys(params, []);
+                return this.deps.info();
+            case 'files': return this.deps.files.tool(method, params);
+            case 'terminal':
+                if (!this.deps.terminal)
+                    throw new Error('Workstation terminal keeper is not configured');
+                return this.deps.terminal(method, params);
+            case 'browser':
+                if (!this.deps.browser)
+                    throw new Error('Workstation browser keeper is not configured');
+                return this.deps.browser(method, params);
+            default: throw new Error('Unsupported workstation tool');
+        }
+    }
+    /** One `file_*_request`; never rejects (errors are result frames). */
+    runFrame(request, signal) {
+        return this.deps.files.runFrame(request, signal);
+    }
+}