@peakflo/agent-harness 0.2.9 → 0.2.10-rc.2

package/dist/service.js

@@ -0,0 +1,535 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceManager = void 0;
+exports.permanentServiceExitCode = permanentServiceExitCode;
+exports.permanentStartupFailure = permanentStartupFailure;
+exports.isServiceStart = isServiceStart;
+exports.serviceStartArgs = serviceStartArgs;
+exports.renderLaunchAgent = renderLaunchAgent;
+exports.renderSystemdUnit = renderSystemdUnit;
+exports.recordServiceFailure = recordServiceFailure;
+exports.clearServiceFailure = clearServiceFailure;
+exports.runServiceCommand = runServiceCommand;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_net_1 = require("node:net");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const credential_store_1 = require("./credential-store");
+const node_floor_1 = require("./node-floor");
+const options_1 = require("./options");
+const vendor_backends_1 = require("./vendor-backends");
+const version_1 = require("./version");
+const LABEL = 'ai.peakflo.agent-harness';
+const UNIT = 'pf-agent-harness.service';
+const VALUE_FLAGS = new Set([
+    '--control-plane',
+    '--app-url',
+    '--label',
+    '--health-port',
+    '--github-proxy-port',
+    '--worktree-wip-commit',
+    '--heartbeat-interval-ms',
+    '--workspace-root',
+    '--runtime',
+    '--max-sessions',
+    '--labels',
+    '--vendor-harnesses'
+]);
+const SWITCH_FLAGS = new Set(['--no-harness-discovery']);
+const LAST_ERROR_FILE = 'service-last-error';
+function permanentServiceExitCode(platform, linuxCode) {
+    return platform === 'darwin' ? 0 : linuxCode;
+}
+/** Only failures that a restart cannot repair belong in this list. */
+function permanentStartupFailure(error) {
+    const failure = error;
+    const code = failure?.code;
+    if (code === 'EADDRINUSE')
+        return 'local port already in use';
+    if (code === 'EACCES' && failure?.syscall === 'listen')
+        return 'local port access denied';
+    if (code === 'ERR_INVALID_URL')
+        return 'invalid service URL';
+    return null;
+}
+/** Existing service files use --stored-credential; new ones also use --service. */
+function isServiceStart(argv) {
+    return (argv[0] === 'start' &&
+        (argv.slice(1).includes('--service') ||
+            argv.slice(1).includes('--stored-credential')));
+}
+function portOccupied(port) {
+    return new Promise((resolve, reject) => {
+        const server = (0, node_net_1.createServer)();
+        server.once('error', (error) => {
+            if (error.code === 'EADDRINUSE')
+                resolve(true);
+            else
+                reject(error);
+        });
+        server.listen(port, '127.0.0.1', () => server.close(() => resolve(false)));
+    });
+}
+function safe(value) {
+    if (/[\r\n\0]/.test(value))
+        throw new Error('Service values cannot contain line breaks or NUL.');
+    return value;
+}
+function xml(value) {
+    return safe(value)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function systemd(value) {
+    return `"${safe(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '$$$$').replace(/%/g, '%%')}"`;
+}
+function systemdEnvironment(value) {
+    // systemd does not expand $ in Environment= values.
+    return `"${safe(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"`;
+}
+function argValue(args, flag) {
+    const at = args.indexOf(flag);
+    return at >= 0 ? args[at + 1] : undefined;
+}
+/** Parse only documented start options. A token can never enter service state. */
+function serviceStartArgs(input, env, home) {
+    const values = new Map();
+    const switches = new Set();
+    for (let index = 0; index < input.length; index++) {
+        const raw = input[index];
+        const equals = raw.indexOf('=');
+        const flag = equals >= 0 ? raw.slice(0, equals) : raw;
+        if (SWITCH_FLAGS.has(flag) && equals < 0) {
+            switches.add(flag);
+            continue;
+        }
+        if (!VALUE_FLAGS.has(flag)) {
+            throw new Error(`Unsupported service start option: ${flag}`);
+        }
+        const value = equals >= 0 ? raw.slice(equals + 1) : input[++index];
+        if (!value || value.startsWith('--'))
+            throw new Error(`Missing value for ${flag}.`);
+        values.set(flag, safe(value));
+    }
+    const controlPlane = values.get('--control-plane') ?? env.PF_CONTROL_PLANE_URL;
+    if (!controlPlane)
+        throw new Error('Set --control-plane for service install.');
+    const validateUrl = (value, name) => {
+        let url;
+        try {
+            url = new URL(value);
+        }
+        catch {
+            throw new Error(`The service ${name} URL is invalid.`);
+        }
+        if (url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            (url.protocol !== 'https:' &&
+                !(url.protocol === 'http:' &&
+                    ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)))) {
+            throw new Error(`The service ${name} URL must use HTTPS (or HTTP on loopback) and have no credentials, query, or fragment.`);
+        }
+    };
+    validateUrl(controlPlane, 'control plane');
+    values.set('--control-plane', safe(controlPlane));
+    const appUrl = values.get('--app-url');
+    if (appUrl)
+        validateUrl(appUrl, 'app');
+    const runtime = values.get('--runtime') ?? env.PF_RUNNER_RUNTIME ?? 'desktop';
+    if (runtime !== 'desktop' && runtime !== 'self-hosted') {
+        throw new Error('A user service needs desktop or self-hosted runtime.');
+    }
+    values.set('--runtime', runtime);
+    const root = values.get('--workspace-root') ??
+        env.PF_WORKSPACE_ROOT ??
+        (0, node_path_1.join)(home, '.pf-agent-harness', 'workspaces');
+    values.set('--workspace-root', (0, node_path_1.resolve)(root));
+    if (env.PF_VENDOR_HARNESSES && !values.has('--vendor-harnesses')) {
+        values.set('--vendor-harnesses', safe(env.PF_VENDOR_HARNESSES));
+    }
+    const vendorNames = values.get('--vendor-harnesses');
+    if (vendorNames !== undefined) {
+        const names = vendorNames
+            .split(',')
+            .map((name) => name.trim())
+            .filter(Boolean);
+        if (names.length === 0 || names.some((name) => !(0, vendor_backends_1.isVendorBackend)(name))) {
+            throw new Error('Invalid vendor harness list. Use codex, claude-code, or cursor.');
+        }
+        values.set('--vendor-harnesses', [...new Set(names)].join(','));
+    }
+    // Keep a stable, explicit order so install is repeatable.
+    const result = ['--service', '--stored-credential'];
+    for (const flag of VALUE_FLAGS) {
+        const value = values.get(flag);
+        if (value !== undefined)
+            result.push(flag, value);
+    }
+    for (const flag of SWITCH_FLAGS)
+        if (switches.has(flag))
+            result.push(flag);
+    return result;
+}
+function renderLaunchAgent(config, logDir) {
+    const args = [config.nodePath, config.cliPath, 'start', ...config.startArgs];
+    const array = args
+        .map((arg) => `    <string>${xml(arg)}</string>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key><string>${LABEL}</string>\n  <key>ProgramArguments</key><array>\n${array}\n  </array>\n  <key>RunAtLoad</key><true/>\n  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>\n  <key>ThrottleInterval</key><integer>30</integer>\n  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(config.path)}</string></dict>\n  <key>StandardOutPath</key><string>${xml((0, node_path_1.join)(logDir, 'stdout.log'))}</string>\n  <key>StandardErrorPath</key><string>${xml((0, node_path_1.join)(logDir, 'stderr.log'))}</string>\n</dict>\n</plist>\n`;
+}
+function renderSystemdUnit(config) {
+    const command = [
+        config.nodePath,
+        config.cliPath,
+        'start',
+        ...config.startArgs
+    ]
+        .map(systemd)
+        .join(' ');
+    return `[Unit]\nDescription=Peakflo agent harness\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${command}\nEnvironment=${systemdEnvironment(`PATH=${config.path}`)}\nRestart=always\nRestartSec=30s\nRestartPreventExitStatus=2 78\n\n[Install]\nWantedBy=default.target\n`;
+}
+function defaultRun(file, args) {
+    return (0, node_child_process_1.execFileSync)(file, args, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+}
+function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function writePrivate(file, contents) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file), { recursive: true, mode: 0o700 });
+    const temp = `${file}.${process.pid}.tmp`;
+    try {
+        (0, node_fs_1.writeFileSync)(temp, contents, { encoding: 'utf8', mode: 0o600 });
+        (0, node_fs_1.chmodSync)(temp, 0o600);
+        (0, node_fs_1.renameSync)(temp, file);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(temp, { force: true });
+    }
+}
+function recordServiceFailure(reason, home = (0, node_os_1.homedir)()) {
+    writePrivate((0, node_path_1.join)(home, '.pf-agent-harness', LAST_ERROR_FILE), `${safe(reason)}\n`);
+}
+function clearServiceFailure(home = (0, node_os_1.homedir)()) {
+    (0, node_fs_1.rmSync)((0, node_path_1.join)(home, '.pf-agent-harness', LAST_ERROR_FILE), { force: true });
+}
+class ServiceManager {
+    context;
+    home;
+    platform;
+    run;
+    output;
+    stateFile;
+    serviceFile;
+    logDir;
+    constructor(context) {
+        this.context = context;
+        this.home = context.home ?? (0, node_os_1.homedir)();
+        this.platform = context.platform ?? process.platform;
+        this.run = context.run ?? defaultRun;
+        this.output =
+            context.output ?? ((message) => process.stdout.write(`${message}\n`));
+        this.stateFile = (0, node_path_1.join)(this.home, '.pf-agent-harness', 'service.json');
+        this.logDir = (0, node_path_1.join)(this.home, '.pf-agent-harness', 'logs');
+        this.serviceFile =
+            this.platform === 'darwin'
+                ? (0, node_path_1.join)(this.home, 'Library', 'LaunchAgents', `${LABEL}.plist`)
+                : (0, node_path_1.join)(this.home, '.config', 'systemd', 'user', UNIT);
+    }
+    supported() {
+        if (this.platform !== 'darwin' && this.platform !== 'linux') {
+            throw new Error('Background service is not supported on Windows yet.');
+        }
+    }
+    readConfig() {
+        const config = JSON.parse((0, node_fs_1.readFileSync)(this.stateFile, 'utf8'));
+        if (!Array.isArray(config.startArgs) ||
+            !config.startArgs.includes('--stored-credential') ||
+            !(0, node_path_1.isAbsolute)(config.nodePath) ||
+            !(0, node_path_1.isAbsolute)(config.cliPath) ||
+            typeof config.path !== 'string') {
+            throw new Error('Service settings are invalid. Run service install again.');
+        }
+        config.startArgs = serviceStartArgs(config.startArgs.filter((arg) => arg !== '--stored-credential' && arg !== '--service'), {}, this.home);
+        safe(config.nodePath);
+        safe(config.cliPath);
+        safe(config.path);
+        return config;
+    }
+    checkCredential(args) {
+        const root = argValue(args, '--workspace-root');
+        const stored = new credential_store_1.FileCredentialStore(root ?? '').load();
+        if (!stored ||
+            (stored.credentialExpiresAt &&
+                Date.parse(stored.credentialExpiresAt) <= Date.now())) {
+            throw new Error('No usable saved runner credential. Start the runner once in a terminal, then install the service.');
+        }
+    }
+    writeAndStart(config) {
+        if (!(0, node_fs_1.existsSync)(config.nodePath) || !(0, node_fs_1.existsSync)(config.cliPath)) {
+            throw new Error('Node.js or the harness CLI is missing. Reinstall the package and run service repair.');
+        }
+        (0, node_fs_1.mkdirSync)(this.logDir, { recursive: true, mode: 0o700 });
+        writePrivate(this.stateFile, `${JSON.stringify(config, null, 2)}\n`);
+        if (this.platform === 'darwin') {
+            writePrivate(this.serviceFile, renderLaunchAgent(config, this.logDir));
+            const domain = `gui/${this.context.uid ?? process.getuid?.() ?? (0, node_os_1.userInfo)().uid}`;
+            try {
+                this.run('launchctl', ['bootout', `${domain}/${LABEL}`]);
+            }
+            catch {
+                /* absent */
+            }
+            // launchd can hold the old label for several seconds after bootout.
+            const delays = [250, 500, 1000, 2000, 4000, 2000];
+            for (let attempt = 0; attempt <= delays.length; attempt++) {
+                try {
+                    this.run('launchctl', ['bootstrap', domain, this.serviceFile]);
+                    break;
+                }
+                catch (error) {
+                    if (attempt === delays.length) {
+                        throw new Error('launchd could not start the agent after 10 seconds. Run pf-agent-harness service repair.', { cause: error });
+                    }
+                    (this.context.sleep ?? sleep)(delays[attempt]);
+                }
+            }
+        }
+        else {
+            writePrivate(this.serviceFile, renderSystemdUnit(config));
+            this.run('systemctl', ['--user', 'daemon-reload']);
+            this.run('systemctl', ['--user', 'enable', UNIT]);
+            try {
+                this.run('systemctl', ['--user', 'reset-failed', UNIT]);
+            }
+            catch {
+                // A new unit may have no failed state to clear. Restart gives the
+                // operator the actionable error if systemd cannot start it.
+            }
+            this.run('systemctl', ['--user', 'restart', UNIT]);
+        }
+    }
+    async install(input) {
+        this.supported();
+        this.checkNodeVersion();
+        const startArgs = serviceStartArgs(input, this.context.env, this.home);
+        this.checkCredential(startArgs);
+        const { healthPort } = (0, options_1.parseOptions)(startArgs, {});
+        let occupied;
+        try {
+            occupied = await (this.context.portOccupied ?? portOccupied)(healthPort);
+        }
+        catch (error) {
+            throw new Error(`Health port ${healthPort} could not be checked. Check access to the local port before service install.`, { cause: error });
+        }
+        if (occupied) {
+            let installedServiceOwnsPort = false;
+            try {
+                const prior = this.readConfig();
+                const priorPort = (0, options_1.parseOptions)(prior.startArgs, {}).healthPort;
+                if ((0, node_fs_1.existsSync)(this.serviceFile) && priorPort === healthPort) {
+                    const info = this.platform === 'darwin'
+                        ? this.run('launchctl', [
+                            'print',
+                            `gui/${this.context.uid ?? process.getuid?.() ?? (0, node_os_1.userInfo)().uid}/${LABEL}`
+                        ])
+                        : this.run('systemctl', [
+                            '--user',
+                            'show',
+                            UNIT,
+                            '--property=ActiveState',
+                            '--property=MainPID'
+                        ]);
+                    installedServiceOwnsPort =
+                        this.platform === 'darwin'
+                            ? /\bstate = running\b/.test(info) &&
+                                /\bpid = [1-9]\d*/.test(info)
+                            : /^ActiveState=active$/m.test(info) &&
+                                /^MainPID=[1-9]\d*/m.test(info);
+                }
+            }
+            catch {
+                /* The port is still in use, so refuse unless ownership is clear. */
+            }
+            if (!installedServiceOwnsPort) {
+                throw new Error(`Health port ${healthPort} is in use. Stop the manual runner before service install.`);
+            }
+        }
+        const config = {
+            startArgs,
+            nodePath: this.context.nodePath,
+            cliPath: this.context.cliPath,
+            path: this.context.env.PATH ?? ''
+        };
+        this.writeAndStart(config);
+        this.output(`Service installed. Logs: ${this.logDir}`);
+        if (this.context.cliPath.includes('/_npx/') ||
+            this.context.cliPath.includes('/.npm/_npx/')) {
+            this.output('Warning: this harness is in the npm npx cache. Install it globally, then run service repair.');
+        }
+        if (this.context.nodePath.includes('/.nvm/versions/node/')) {
+            this.output('Warning: this Node.js path can change after an nvm upgrade. Run service repair after upgrades.');
+        }
+        this.output('After a Node.js or harness upgrade, run: pf-agent-harness service repair');
+        if (this.platform === 'linux')
+            this.output('To run after logout, ask your system administrator to run: loginctl enable-linger $USER');
+    }
+    checkNodeVersion() {
+        const floor = (0, node_floor_1.checkNodeFloor)({
+            current: process.versions.node,
+            floor: (0, version_1.getNodeFloor)(),
+            runtime: 'desktop',
+            env: this.context.env
+        });
+        if (floor.action === 'refuse')
+            throw new Error(floor.message);
+    }
+    repair() {
+        this.supported();
+        this.checkNodeVersion();
+        const prior = this.readConfig();
+        this.checkCredential(prior.startArgs);
+        this.writeAndStart({
+            ...prior,
+            nodePath: this.context.nodePath,
+            cliPath: this.context.cliPath,
+            path: this.context.env.PATH ?? prior.path
+        });
+        this.output('Service repaired and restarted.');
+    }
+    assertNoDuplicateRunner(options) {
+        if (!(0, node_fs_1.existsSync)(this.serviceFile) || !(0, node_fs_1.existsSync)(this.stateFile))
+            return;
+        let config;
+        let info;
+        try {
+            config = this.readConfig();
+            info =
+                this.platform === 'darwin'
+                    ? this.run('launchctl', [
+                        'print',
+                        `gui/${this.context.uid ?? process.getuid?.() ?? (0, node_os_1.userInfo)().uid}/${LABEL}`
+                    ])
+                    : this.run('systemctl', [
+                        '--user',
+                        'show',
+                        UNIT,
+                        '--property=ActiveState',
+                        '--property=MainPID'
+                    ]);
+        }
+        catch {
+            return;
+        }
+        const pid = Number(this.platform === 'darwin'
+            ? info.match(/\bpid = (\d+)/)?.[1]
+            : info.match(/^MainPID=(\d+)$/m)?.[1]);
+        if (!pid || pid === process.pid)
+            return;
+        const running = this.platform === 'darwin'
+            ? /\bstate = running\b/.test(info)
+            : /^ActiveState=active$/m.test(info);
+        if (!running)
+            return;
+        const serviceRoot = argValue(config.startArgs, '--workspace-root');
+        const servicePort = Number(argValue(config.startArgs, '--health-port') ?? '7777');
+        if ((serviceRoot &&
+            (0, node_path_1.resolve)(serviceRoot) === (0, node_path_1.resolve)(options.workspaceRoot)) ||
+            servicePort === options.healthPort) {
+            throw new Error('The background service is already running with this workspace or health port. Stop it before a manual start.');
+        }
+    }
+    status() {
+        this.supported();
+        if (!(0, node_fs_1.existsSync)(this.serviceFile)) {
+            this.output('Status: stopped. Service is not installed.');
+            return;
+        }
+        let savedError = '';
+        try {
+            savedError = (0, node_fs_1.readFileSync)((0, node_path_1.join)(this.home, '.pf-agent-harness', LAST_ERROR_FILE), 'utf8').trim();
+        }
+        catch {
+            /* no saved failure */
+        }
+        try {
+            if (this.platform === 'darwin') {
+                const domain = `gui/${this.context.uid ?? process.getuid?.() ?? (0, node_os_1.userInfo)().uid}`;
+                const info = this.run('launchctl', ['print', `${domain}/${LABEL}`]);
+                const running = /\bstate = running\b/.test(info);
+                const exit = info.match(/last exit code = (\d+)/)?.[1];
+                this.output(`Status: ${running ? 'running' : 'stopped'}. Last error: ${!running && savedError ? savedError : exit && exit !== '0' ? `exit ${exit}` : 'none'}.`);
+            }
+            else {
+                const info = this.run('systemctl', [
+                    '--user',
+                    'show',
+                    UNIT,
+                    '--property=ActiveState',
+                    '--property=Result',
+                    '--property=ExecMainStatus'
+                ]);
+                const state = info.match(/^ActiveState=(.*)$/m)?.[1];
+                const result = info.match(/^Result=(.*)$/m)?.[1];
+                const code = info.match(/^ExecMainStatus=(.*)$/m)?.[1];
+                this.output(`Status: ${state === 'active' ? 'running' : 'stopped'}. Last error: ${state !== 'active' && savedError ? savedError : result && result !== 'success' ? `${result}${code && code !== '0' ? ` (exit ${code})` : ''}` : 'none'}.`);
+            }
+        }
+        catch {
+            this.output(`Status: stopped. Last error: ${savedError || 'service manager could not read status'}.`);
+        }
+    }
+    uninstall() {
+        this.supported();
+        if (this.platform === 'darwin') {
+            const domain = `gui/${this.context.uid ?? process.getuid?.() ?? (0, node_os_1.userInfo)().uid}`;
+            try {
+                this.run('launchctl', ['bootout', `${domain}/${LABEL}`]);
+            }
+            catch {
+                /* absent */
+            }
+        }
+        else if ((0, node_fs_1.existsSync)(this.serviceFile)) {
+            this.run('systemctl', ['--user', 'disable', '--now', UNIT]);
+        }
+        (0, node_fs_1.rmSync)(this.serviceFile, { force: true });
+        (0, node_fs_1.rmSync)(this.stateFile, { force: true });
+        clearServiceFailure(this.home);
+        if (this.platform === 'linux')
+            this.run('systemctl', ['--user', 'daemon-reload']);
+        this.output('Service removed. The saved runner credential remains in the workspace.');
+    }
+}
+exports.ServiceManager = ServiceManager;
+async function runServiceCommand(args, context) {
+    const manager = new ServiceManager(context);
+    switch (args[0]) {
+        case 'help':
+        case '--help':
+            (context.output ?? ((message) => process.stdout.write(`${message}\n`)))('Use service install [start options], service status, service repair, or service uninstall.');
+            break;
+        case 'install':
+            await manager.install(args.slice(1));
+            break;
+        case 'status':
+            manager.status();
+            break;
+        case 'repair':
+            manager.repair();
+            break;
+        case 'uninstall':
+            manager.uninstall();
+            break;
+        default:
+            throw new Error('Use service install, status, repair, or uninstall.');
+    }
+}

package/dist/types.d.ts

@@ -95,6 +95,8 @@ export interface HarnessOptions {
      * sandbox runner never runs discovery, whatever this says.
      */
     harnessDiscovery?: boolean;
+    /** Vendor backends the machine owner explicitly enabled. Empty by default. */
+    vendorHarnesses?: string[];
 }
 /**
  * Every request body in this contract carries the protocol version, so the
@@ -203,6 +205,8 @@ export interface RunnerCapabilities {
     hostname: string;
     /** Coding-agent backends found on this host, with the version detected. */
     backends: RunnerBackend[];
+    /** Explicit local consent. An old runner without this field cannot take vendor turns. */
+    vendorHarnesses?: string[];
     /**
      * Flat union of every backend's reported models, deduplicated by id.
      *
@@ -557,6 +561,7 @@ export interface LeasedSession {
      * Space, and for a control plane that predates the capability.
      */
     spaceFiles?: LeasedSpaceFiles;
+    taskFiles?: LeasedTaskFiles;
 }
 export interface LeasedAgent {
     agentId: string;
@@ -646,6 +651,22 @@ export interface LeasedAttachment {
     url: string;
     sizeBytes?: number;
 }
+export interface LeasedTaskFiles {
+    taskId: string;
+    /** API endpoint; authenticated by the lease's MCP token, never a signed URL. */
+    baseUrl: string;
+    files: Array<{
+        index: number;
+        relativePath: string;
+        mimeType: string;
+        sizeBytes: number;
+        revision: string;
+    }>;
+    skipped: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
 /**
  * The Space files manifest (P9). Present only when the runner advertised the
  * `spaceFiles` capability. The control plane decides WHICH files; the harness

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peakflo/agent-harness",
-  "version": "0.2.9",
+  "version": "0.2.10-rc.2",
   "description": "Headless Peakflo coding-agent harness. One codebase, three hosting modes: a Daytona cloud sandbox, a customer VM, and the 20x desktop.",
   "license": "MIT",
   "type": "commonjs",