@agenthippo-ai/agenthippo 1.110.11 → 1.110.20

package/out/sandbox/support.js

@@ -1,301 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEPRECATED_SANDBOX_ENV_ALIASES = void 0;
-exports.dockerExec = dockerExec;
-exports.alignSandboxWorkspaceOwnership = alignSandboxWorkspaceOwnership;
-exports.resolveSandboxImageUser = resolveSandboxImageUser;
-exports.ensureSandboxStateDir = ensureSandboxStateDir;
-exports.sandboxScriptArg = sandboxScriptArg;
-exports.applyDeprecatedSandboxEnvAliases = applyDeprecatedSandboxEnvAliases;
-exports.loadWarrantKeypair = loadWarrantKeypair;
-exports.mintSandboxInferenceWarrant = mintSandboxInferenceWarrant;
-/**
- * Small pieces the sandbox layer needs at its composition root: the container-runtime shim and
- * the per-sandbox model token (blocker C — the model key leaves the engine's reach).
- */
-const node_child_process_1 = require("node:child_process");
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const warrant_1 = require("../authority/warrant");
-/** Runs `docker <args>`; never throws — the driver decides what a non-zero code means. */
-function dockerExec(args) {
-    return new Promise((resolve) => {
-        (0, node_child_process_1.execFile)('docker', args, { maxBuffer: 8 << 20 }, (err, stdout, stderr) => {
-            if (err) {
-                const code = typeof err.code === 'number' ? err.code : 1;
-                resolve({ stdout: `${stdout ?? ''}${stderr ?? ''}`, code });
-                return;
-            }
-            resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code: 0 });
-        });
-    });
-}
-/**
- * Make the shared workspace writable BY THE SANDBOX, without giving the sandbox root.
- *
- * A sandbox image runs non-root (the runtime image is uid 10001) while serve runs as root — it has
- * to, it drives the container runtime. So every file serve syncs into the bind-mounted workspace
- * lands root-owned, and the sandbox's own pack sync then dies on `EACCES: unlink …/SKILL.md`. Until
- * now that was a manual `chown -R 10001:10001 <workspace>` AFTER serve booted, which is exactly
- * the kind of undocumented step a deployment forgets.
- *
- * The uid is ASKED OF THE IMAGE rather than hardcoded — `Config.User` is often a name ("agent")
- * that only resolves inside the image, so `id -u` in the image is the only honest source. The
- * alternative fix, `--user <serve uid>`, would make the sandbox run as root inside the container and
- * trade an ownership problem for a weaker boundary; this keeps the sandbox non-root.
- *
- * Best effort by design: a failure here is a warning with the exact command to run, never a boot
- * failure — an operator whose workspace is already aligned must not be blocked by it.
- */
-async function alignSandboxWorkspaceOwnership(opts) {
-    const hostDirs = opts.writable.map((e) => (e.includes(':') ? e.slice(0, e.indexOf(':')) : e));
-    if (hostDirs.length === 0) {
-        return;
-    }
-    const owner = await resolveSandboxImageUser(opts.exec, opts.image);
-    if (!owner) {
-        opts.logger?.warn(`[Sandbox] could not determine the sandbox image's uid; if turns fail with EACCES in the workspace, run: chown -R <image-uid> ${hostDirs.join(' ')}`);
-        return;
-    }
-    // A root image needs no alignment: it can already write anything serve wrote.
-    if (owner.uid === 0) {
-        return;
-    }
-    const { uid, gid } = owner;
-    for (const dir of hostDirs) {
-        try {
-            const changed = chownTree(dir, uid, gid);
-            if (changed > 0) {
-                opts.logger?.info(`[Sandbox] aligned ${changed} path(s) under ${dir} to the sandbox image's uid ${uid}:${gid}`);
-            }
-        }
-        catch (err) {
-            opts.logger?.warn(`[Sandbox] could not align ownership of ${dir} for the sandbox (uid ${uid}): ${err instanceof Error ? err.message : String(err)}. Run: chown -R ${uid}:${gid} ${dir}`);
-        }
-    }
-}
-/**
- * The uid/gid the sandbox image actually runs as. Resolved once per boot and reused — it costs two
- * container starts, and both the workspace alignment and every per-session state dir need it.
- */
-async function resolveSandboxImageUser(exec, image) {
-    const uid = await imageId(exec, image, '-u');
-    if (uid === undefined) {
-        return undefined;
-    }
-    return { uid, gid: (await imageId(exec, image, '-g')) ?? uid };
-}
-/**
- * Create this session's state directory, owned by the sandbox so it can write there.
- *
- * The directory outlives the sandbox on purpose — it holds `provider-sessions/` and the engines'
- * rollout files, which is the only reason a session can resume after its sandbox is reaped.
- */
-function ensureSandboxStateDir(dir, owner) {
-    fs.mkdirSync(dir, { recursive: true });
-    if (owner && owner.uid !== 0) {
-        try {
-            chownTree(dir, owner.uid, owner.gid);
-        }
-        catch { /* best effort — warned at boot */ }
-    }
-    return dir;
-}
-/** `id -u` / `id -g` AS THE IMAGE'S DEFAULT USER — the only place a name like "agent" resolves. */
-async function imageId(exec, image, flag) {
-    const res = await exec(['run', '--rm', '--network', 'none', '--entrypoint', 'id', image, flag]);
-    if (res.code !== 0) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(res.stdout.trim(), 10);
-    return Number.isInteger(parsed) ? parsed : undefined;
-}
-/** Recursive chown, touching only what is not already owned by the sandbox. Returns how many. */
-function chownTree(dir, uid, gid) {
-    let changed = 0;
-    const visit = (p) => {
-        // lstat/lchown: a symlink is retargeted by chown, so follow nothing.
-        const st = fs.lstatSync(p);
-        if (st.uid !== uid || st.gid !== gid) {
-            fs.lchownSync(p, uid, gid);
-            changed++;
-        }
-        if (st.isDirectory()) {
-            for (const entry of fs.readdirSync(p)) {
-                visit(path.join(p, entry));
-            }
-        }
-    };
-    if (!fs.existsSync(dir)) {
-        return 0;
-    }
-    visit(dir);
-    return changed;
-}
-// REMOVED (2026-07-29): `mintSandboxModelToken` / `verifySandboxModelToken`.
-//
-// They HMAC'd the upstream provider key and truncated the result to 32 hex characters, and their
-// own docstring conceded that the "spend cap" they claimed to carry was never actually encoded in
-// the token, let alone enforced. Nothing in serve used them — the shipped path is the ES256
-// warrant below (`mintSandboxInferenceWarrant`), which the inference proxy verifies with a public
-// key it cannot mint with. A second, weaker credential format that looks like it does the same job
-// is a liability: it invites a future call site to reach for the one with no signature and no
-// audience separation. The conformance `cost-cap` check now exercises the warrant path instead.
-// -----------------------------------------------------------------------------
-// Warrant-based sandbox model tokens (the shape the inference proxy verifies)
-// -----------------------------------------------------------------------------
-/**
- * Load the authority plane's signing key, or generate an ephemeral one.
- *
- * `AGENTHIPPO_WARRANT_PRIVATE_KEY` (PKCS#8 PEM) + `AGENTHIPPO_WARRANT_KID` pin a stable key so
- * gateways can be configured with the matching public key. With neither set, serve generates a
- * keypair at boot and logs the public key: fine for a single-node dev run, useless across a
- * restart — which is the honest tradeoff, not a silent one.
- */
-/**
- * Virtual filesystem roots used by single-file builds. Paths under these are reported by
- * `process.argv[1]` but are not real files a child process can be pointed at — and crucially the
- * runtime mounts them, so `fs.existsSync` returns TRUE and cannot be used to tell them apart.
- */
-const VIRTUAL_SCRIPT_ROOTS = ['/$bunfs', '/snapshot'];
-/**
- * Normalize a script path for the virtual-root check: Windows separators become `/`, and a drive
- * letter is stripped. `pkg` on Windows reports `C:\snapshot\app\index.js`, which the bare
- * `startsWith('/snapshot')` test missed. serve is effectively Linux-only so this has never bitten,
- * but the check costs one line and the failure it prevents (`unknown command 'C:\snapshot\…'`,
- * every sandbox dead at boot) is opaque.
- */
-function normalizeScriptPath(script) {
-    return script.replace(/\\/g, '/').replace(/^[A-Za-z]:/, '');
-}
-/**
- * The script argument to pass when re-invoking ourselves to launch a sandbox.
- *
- * `node <script> sandbox …` needs the script path; a compiled single-file binary must be invoked as
- * `<binary> sandbox …` with no script at all. Passing the virtual path made the child treat it as
- * the subcommand (`unknown command '/$bunfs/root/index.js'`), so every tier-0 sandbox died at boot.
- */
-function sandboxScriptArg(argv = process.argv, execPath = process.execPath) {
-    const script = argv[1];
-    if (!script || script === execPath) {
-        return [];
-    }
-    const normalized = normalizeScriptPath(script);
-    if (VIRTUAL_SCRIPT_ROOTS.some((root) => normalized.startsWith(root))) {
-        return [];
-    }
-    return [script];
-}
-// -----------------------------------------------------------------------------
-// cell → sandbox migration: deprecated environment aliases
-// -----------------------------------------------------------------------------
-/**
- * Environment variables renamed by the cell → sandbox migration, old name → new name.
- *
- * Only variables that actually CHANGE BEHAVIOUR are listed. An operator env file still saying
- * `AGENTHIPPO_CELL_TIER=2` would otherwise select nothing at all — the deployment would come up
- * one tier weaker than asked for, with no error anywhere. Silent degradation is the failure mode
- * this migration must not have; a loud warning plus the old value continuing to work is.
- */
-exports.DEPRECATED_SANDBOX_ENV_ALIASES = [
-    ['AGENTHIPPO_CELL', 'AGENTHIPPO_SANDBOX'],
-    ['AGENTHIPPO_CELL_TIER', 'AGENTHIPPO_SANDBOX_TIER'],
-    ['AGENTHIPPO_CELL_SOCKET_DIR', 'AGENTHIPPO_SANDBOX_SOCKET_DIR'],
-    ['AGENTHIPPO_CELL_STRICT_EGRESS', 'AGENTHIPPO_SANDBOX_STRICT_EGRESS'],
-    ['AGENTHIPPO_CELL_ALLOW_PROVIDER_KEY', 'AGENTHIPPO_SANDBOX_ALLOW_PROVIDER_KEY'],
-];
-/** One warning per process per variable — a per-turn log would bury it. */
-const warnedAliases = new Set();
-/**
- * Accept the pre-rename `AGENTHIPPO_CELL*` spellings, loudly.
- *
- * A NEW name already present always wins: an operator who has migrated is never overridden by a
- * stale variable left in a shell profile. Returns the aliases that were applied, for tests.
- */
-function applyDeprecatedSandboxEnvAliases(env = process.env, warn = (m) => console.warn(m), once = warnedAliases) {
-    const applied = [];
-    for (const [oldName, newName] of exports.DEPRECATED_SANDBOX_ENV_ALIASES) {
-        const legacy = env[oldName];
-        if (legacy === undefined || legacy === '') {
-            continue;
-        }
-        if (env[newName] !== undefined && env[newName] !== '') {
-            if (!once.has(oldName)) {
-                once.add(oldName);
-                warn(`[Sandbox] DEPRECATED: ${oldName} is set but ${newName} is also set — using ${newName} ` +
-                    `and IGNORING ${oldName}. Remove ${oldName}; it was renamed in the cell → sandbox migration.`);
-            }
-            continue;
-        }
-        env[newName] = legacy;
-        applied.push(newName);
-        if (!once.has(oldName)) {
-            once.add(oldName);
-            warn(`[Sandbox] DEPRECATED: ${oldName} was renamed to ${newName} in the cell → sandbox migration. ` +
-                `The old value is being honoured for now, but it will stop working — set ${newName}=${legacy} instead.`);
-        }
-    }
-    return applied;
-}
-// Applied at import so the aliases are in place before anything reads the new names. This module is
-// on the import path of every sandbox composition root (serve and the `sandbox` subcommand both
-// pull `dockerExec` / `sandboxScriptArg` / `loadWarrantKeypair` from here), and the alternative —
-// a call the composition root must remember to make — is exactly the kind of step a deployment
-// forgets, which is the failure this exists to prevent.
-applyDeprecatedSandboxEnvAliases();
-function loadWarrantKeypair(logger) {
-    const pem = process.env.AGENTHIPPO_WARRANT_PRIVATE_KEY?.trim();
-    const kid = process.env.AGENTHIPPO_WARRANT_KID?.trim();
-    if (pem) {
-        const crypto = require('node:crypto');
-        const publicKeyPem = crypto.createPublicKey(pem).export({ type: 'spki', format: 'pem' }).toString();
-        return { privateKeyPem: pem, publicKeyPem, kid: kid || 'default' };
-    }
-    const generated = (0, warrant_1.generateWarrantKeypair)(kid);
-    logger?.info(`[Warrant] no AGENTHIPPO_WARRANT_PRIVATE_KEY — generated an ephemeral key (kid=${generated.kid}). Configure gateways with:\nGATEWAY_SANDBOX_WARRANT_KEYS=${JSON.stringify({ [generated.kid]: generated.publicKeyPem })}`);
-    return generated;
-}
-/**
- * Mint the token a sandbox presents to the inference proxy: a signed, audience-bound warrant naming
- * the end user (cost attribution), the sandbox (spend metering + replay defence), and the tier.
- * The proxy verifies with a public key and can never mint one.
- */
-function mintSandboxInferenceWarrant(key, claims) {
-    return (0, warrant_1.mintWarrant)({ ...claims, aud: 'inference' }, key);
-}

package/out/sandbox/types.js

@@ -1,55 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RevocationUnsupportedError = exports.SANDBOX_PROVIDER_KEY_ENV = exports.SANDBOX_TIER_ENV = void 0;
-exports.sandboxHoldsProviderKey = sandboxHoldsProviderKey;
-exports.isContainerSandbox = isContainerSandbox;
-/**
- * The tier the surrounding sandbox ACTUALLY delivers, declared by the driver that created it.
- *
- * Read by engines that sandbox themselves: an engine may only stand its own boundary down when
- * something stronger already confines it. `AGENTHIPPO_SANDBOX=1` cannot answer that question —
- * it says "inside a sandbox", and the tier-0 process driver is a sandbox that confines nothing.
- * Set from the driver's own `tier`, never from the caller's spec, because the driver is the only
- * thing that knows what boundary was really built.
- */
-exports.SANDBOX_TIER_ENV = 'AGENTHIPPO_SANDBOX_TIER';
-/**
- * Set to `1` when this sandbox was handed a RAW PROVIDER KEY (the Cursor exception — see
- * `processDriver.baseSandboxEnv`).
- *
- * The tier says how strong the surrounding boundary is; this says whether the credential invariant
- * ("the sandbox holds no provider key") actually holds inside it. They are different claims and a
- * deployment that discloses one while quietly violating the other is the failure this exists to
- * prevent: an engine here can reach the provider directly, around the inference proxy's meter and
- * around the per-sandbox warrant.
- */
-exports.SANDBOX_PROVIDER_KEY_ENV = 'AGENTHIPPO_SANDBOX_PROVIDER_KEY';
-/** True when this process was given a raw provider key despite running in a sandbox. */
-function sandboxHoldsProviderKey(env = process.env) {
-    return env[exports.SANDBOX_PROVIDER_KEY_ENV] === '1';
-}
-/**
- * True only when a boundary stronger than the engine's own confinement surrounds this process.
- *
- * Absent or unparseable ⇒ false: an engine keeps its own sandbox rather than dropping it on a
- * guess. The failure mode of guessing wrong in the other direction is an unconfined agent.
- */
-function isContainerSandbox(env = process.env) {
-    return Number(env[exports.SANDBOX_TIER_ENV]) >= 2;
-}
-/**
- * Thrown when a driver is asked for an enforcement it cannot actually deliver — e.g. narrowing a
- * single route on the tier-0 `process` driver, which has no network boundary. Failing loudly
- * beats a silent no-op: a caller that believes it revoked the inference route when nothing
- * happened is exactly the "safe by convention" failure this architecture exists to remove.
- */
-class RevocationUnsupportedError extends Error {
-    constructor(driver, what) {
-        super(`${driver} driver cannot revoke '${what}' — no enforcement boundary at this tier (use 'all', which kills the sandbox)`);
-        this.name = 'RevocationUnsupportedError';
-    }
-}
-exports.RevocationUnsupportedError = RevocationUnsupportedError;

package/out/scripts/analytics/fleet-local-adapter.js

@@ -1,246 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Formal local fleet adapter: produces the same fleet view as the in-process adapter.
- * Extension writes input to a predefined path and sets env AGENTIDE_FLEET_LOCAL_INPUT_PATH;
- * this script reads from that path. Fallback: stdin (for testing).
- * Input JSON: { source, filters, duckdbPath, duckdbBinaryPath?, scheduledRequests }
- * Writes to stdout: { source: 'local', sessions: FleetSessionRow[] }
- */
-
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-const fs = require('fs');
-const path = require('path');
-
-const execFileAsync = promisify(execFile);
-
-const SOURCE_ID = 'local';
-const FLEET_LIMIT = 500;
-
-function sqlLiteral(s) {
-	if (s == null || s === '') return "''";
-	const str = String(s);
-	return "'" + str.replace(/\\/g, '\\\\').replace(/'/g, "''") + "'";
-}
-
-function buildWhereConditions(filters) {
-	const conditions = ['session_id IS NOT NULL'];
-	const scope = (filters && filters.scope) || 'global';
-	const projectId = filters && filters.projectId;
-	const agentId = filters && filters.agentId;
-	if (scope === 'workspace') {
-		if (!projectId) {
-			conditions.push('1 = 0');
-		} else {
-			conditions.push(`(project_id = ${sqlLiteral(projectId)} OR project_id IS NULL)`);
-		}
-	}
-	if (agentId) {
-		conditions.push(`agent_id = ${sqlLiteral(agentId)}`);
-	}
-	return conditions.join(' AND ');
-}
-
-function normalizeStatus(session) {
-	const now = Date.now();
-	const startedMs = session.startedAt ? new Date(session.startedAt).getTime() : NaN;
-	const endedMs = session.endedAt ? new Date(session.endedAt).getTime() : NaN;
-	if (Number.isFinite(startedMs) && startedMs > now + 60_000) return 'scheduled';
-	if (!Number.isFinite(endedMs) || endedMs <= 0 || (Number.isFinite(startedMs) && endedMs < startedMs)) return 'in_progress';
-	if (endedMs > now - 90_000) return 'in_progress';
-	return 'done';
-}
-
-function toRow(sessionId, agentId, startedAt, endedAt, status, taskTitle, model, engine, turns, totalTokens) {
-	const now = new Date().toISOString();
-	return {
-		source: SOURCE_ID,
-		sessionId,
-		agentId,
-		status,
-		startedAt: startedAt || '',
-		endedAt: endedAt || '',
-		taskTitle: taskTitle || 'Task',
-		model: model || 'unknown',
-		engine: engine || '',
-		channelType: 'none',
-		channelTarget: '',
-		turns: Number.isFinite(turns) ? turns : 0,
-		totalTokens: Number.isFinite(totalTokens) ? totalTokens : 0,
-		disconnectCapable: false,
-		updatedAt: now,
-	};
-}
-
-async function queryFleetSessions(duckdbPath, duckdbBinary, conditions) {
-	const limit = Math.min(Math.max(1, FLEET_LIMIT), 10000);
-	const sqlWithEngine = `
-SELECT
-	session_id as sessionId,
-	agent_id as agentId,
-	MIN(to_timestamp(start_ms / 1000)) as startedAt,
-	MAX(to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000)) as endedAt,
-	COUNT(*) as turns,
-	COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) as totalTokens,
-	COALESCE(arg_max(COALESCE(model, 'unknown'), start_ms), 'unknown') as model,
-	COALESCE(arg_max(COALESCE(engine, ''), start_ms), '') as engine
-FROM spans
-WHERE ${conditions}
-GROUP BY session_id, agent_id
-ORDER BY MAX(start_ms) DESC
-LIMIT ${limit}`;
-	const sqlWithoutEngine = `
-SELECT
-	session_id as sessionId,
-	agent_id as agentId,
-	MIN(to_timestamp(start_ms / 1000)) as startedAt,
-	MAX(to_timestamp((start_ms + COALESCE(duration_ms, 0)) / 1000)) as endedAt,
-	COUNT(*) as turns,
-	COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) as totalTokens,
-	COALESCE(arg_max(COALESCE(model, 'unknown'), start_ms), 'unknown') as model
-FROM spans
-WHERE ${conditions}
-GROUP BY session_id, agent_id
-ORDER BY MAX(start_ms) DESC
-LIMIT ${limit}`;
-	const binary = duckdbBinary || 'duckdb';
-	try {
-		const { stdout } = await execFileAsync(binary, [duckdbPath, '-json', '-c', sqlWithEngine], {
-			timeout: 30_000,
-			maxBuffer: 5 * 1024 * 1024,
-		});
-		const rows = stdout.trim() ? JSON.parse(stdout) : [];
-		return Array.isArray(rows) ? rows.map((r) => ({ ...r, engine: r.engine != null ? r.engine : '' })) : [];
-	} catch (err) {
-		const msg = (err && err.message) || String(err);
-		if (/engine|column|referenced/.test(msg)) {
-			const { stdout } = await execFileAsync(binary, [duckdbPath, '-json', '-c', sqlWithoutEngine], {
-				timeout: 30_000,
-				maxBuffer: 5 * 1024 * 1024,
-			});
-			const rows = stdout.trim() ? JSON.parse(stdout) : [];
-			return Array.isArray(rows) ? rows.map((r) => ({ ...r, engine: '' })) : [];
-		}
-		throw err;
-	}
-}
-
-function readStdin() {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		process.stdin.setEncoding('utf8');
-		process.stdin.on('data', (chunk) => chunks.push(chunk));
-		process.stdin.on('end', () => resolve(chunks.join('')));
-		process.stdin.on('error', reject);
-	});
-}
-
-function readInput() {
-	const inputPath = process.env.AGENTIDE_FLEET_LOCAL_INPUT_PATH;
-	if (inputPath && typeof inputPath === 'string') {
-		try {
-			return Promise.resolve(fs.readFileSync(inputPath, 'utf-8'));
-		} catch (e) {
-			process.stderr.write(`fleet-local-adapter: failed to read ${inputPath}: ${(e && e.message) || e}\n`);
-			process.exit(1);
-		}
-	}
-	return readStdin();
-}
-
-async function main() {
-	const raw = await readInput();
-	let input;
-	try {
-		input = JSON.parse(raw);
-	} catch (_) {
-		process.stderr.write('fleet-local-adapter: invalid JSON\n');
-		process.exit(1);
-	}
-	const duckdbPath = input.duckdbPath;
-	const duckdbBinaryPath = input.duckdbBinaryPath;
-	const filters = input.filters || {};
-	const scheduledRequests = Array.isArray(input.scheduledRequests) ? input.scheduledRequests : [];
-	if (!duckdbPath || typeof duckdbPath !== 'string') {
-		process.stderr.write('fleet-local-adapter: missing duckdbPath\n');
-		process.exit(1);
-	}
-	const conditions = buildWhereConditions(filters);
-	let sessions = [];
-	try {
-		sessions = await queryFleetSessions(duckdbPath, duckdbBinaryPath, conditions);
-	} catch (err) {
-		process.stderr.write(`fleet-local-adapter: DuckDB query failed: ${(err && err.message) || err}\n`);
-		// Continue with scheduled only
-	}
-	const now = Date.now();
-	const sessionsById = new Map();
-
-	for (const session of sessions) {
-		const status = normalizeStatus(session);
-		const taskTitle = session.agentPack != null ? session.agentPack : (session.agentId != null ? session.agentId : (session.sessionId != null ? session.sessionId : 'Task'));
-		sessionsById.set(session.sessionId, toRow(
-			session.sessionId,
-			session.agentId,
-			session.startedAt,
-			session.endedAt,
-			status,
-			taskTitle,
-			session.model,
-			session.engine != null ? session.engine : '',
-			session.turns,
-			session.totalTokens,
-		));
-	}
-
-	for (const s of scheduledRequests) {
-		const runAtIso = s.runAt != null ? new Date(Number(s.runAt)).toISOString() : new Date().toISOString();
-		const messageText = (s.messageText != null && typeof s.messageText === 'string') ? s.messageText : '';
-		const messagePreview = messageText.length > 80 ? messageText.slice(0, 77) + '...' : messageText;
-		const sessionId = (s.sessionId != null && typeof s.sessionId === 'string') ? s.sessionId.trim() : '';
-		if (!sessionId) continue;
-		const existing = sessionsById.get(sessionId);
-		if (existing) {
-			if (existing.status === 'done' && Number(s.runAt) >= now - 2 * 60_000) {
-				existing.status = 'scheduled';
-				existing.startedAt = runAtIso;
-				existing.endedAt = '';
-			}
-			if (!existing.taskTitle || existing.taskTitle === existing.sessionId || existing.taskTitle === (existing.agentId || '')) {
-				existing.taskTitle = messagePreview || existing.taskTitle;
-			}
-			if (!existing.agentId && s.agentId) existing.agentId = s.agentId;
-			continue;
-		}
-		sessionsById.set(sessionId, toRow(
-			sessionId,
-			s.agentId,
-			runAtIso,
-			'',
-			'scheduled',
-			messagePreview || s.agentId || sessionId || 'Scheduled task',
-			s.model != null ? s.model : 'scheduled',
-			s.engine != null ? s.engine : '',
-			0,
-			0,
-		));
-	}
-
-	const rows = Array.from(sessionsById.values()).sort((a, b) => {
-		const order = (st) => (st === 'in_progress' ? 0 : st === 'scheduled' ? 1 : 2);
-		const d = order(a.status) - order(b.status);
-		if (d !== 0) return d;
-		const aStart = (a.startedAt && new Date(a.startedAt).getTime()) || 0;
-		const bStart = (b.startedAt && new Date(b.startedAt).getTime()) || 0;
-		return bStart - aStart;
-	});
-
-	const out = { source: SOURCE_ID, sessions: rows };
-	process.stdout.write(JSON.stringify(out));
-}
-
-main().catch((err) => {
-	process.stderr.write(`fleet-local-adapter: ${(err && err.message) || err}\n`);
-	process.exit(1);
-});