@xenosystem/agent-interface-host 0.1.3

package/dist/acp/AcpProcessSupervisor.js

@@ -0,0 +1,674 @@
+import { isAbsolute } from 'path';
+import packageJson from '../../package.json' with { type: 'json' };
+import { AgentProcess, createLogger } from '@xenosystem/acp-core';
+import { AcpCancelledError, AcpProcessExitedError, AcpProtocolError, AcpTimeoutError, AcpVersionMismatchError, acpErrorCode, } from './acpErrors.js';
+import { assertAcpProviderVersionReadyAsync } from './AcpProviderVersionReadiness.js';
+import { isAcpShellCommandLine, isAcpShellExecutable } from './acpCommandSafety.js';
+import { FailClosedAcpPermissionBridge, cancelAcpPermissionBridge, handleAcpPermissionRequest, } from './AcpPermissionBridge.js';
+import { FailClosedAcpHostBridge, XENO_ACP_META_KEY, cancelAcpHostBridge, handleAcpHostExtensionRequest, } from './AcpHostBridge.js';
+import { UnavailableCoordinationLaneBridge } from '../coordination/laneBridge.js';
+import { xenoAcpHostRequestAdvertisement } from './AcpHostBridge.js';
+import { boundedPush, redactAcpArgs, redactAcpEnvKeys, redactAcpPath, redactAcpText } from './acpRedaction.js';
+import { normalizeAcpSessionResumeState, XENO_ACP_SESSION_RESUME_META_KEY, } from './acpSessionResume.js';
+export const XENO_ACP_CONTEXT_META_KEY = 'xeno.dev/context';
+/**
+ * What `initialize` actually sends. Exported so the advertisement can be
+ * asserted where it is TRANSMITTED rather than where it is computed — a test
+ * against the helper alone stays green while this object hand-lists something
+ * else, which is exactly how the list fell behind the dispatcher before.
+ */
+export const DEFAULT_CLIENT_CAPABILITIES = {
+    fs: {
+        readTextFile: false,
+        writeTextFile: false,
+    },
+    terminal: false,
+    _meta: {
+        [XENO_ACP_META_KEY]: {
+            chooseDirectory: true,
+            /**
+             * 🔴 DERIVED from the dispatch table, never listed here.
+             *
+             * `initialize` sends this, and it is the whole difference between a
+             * method that is reachable and one that is merely implemented. Hand-listed,
+             * it silently fell behind the dispatcher — exactly the shape this repo has
+             * hit five times. Now a method cannot be dispatched without being
+             * advertised, because both read the same array.
+             */
+            hostRequests: xenoAcpHostRequestAdvertisement(),
+        },
+    },
+};
+// These rules used to be a second, character-for-character copy of the registry
+// service's. They are now one shared rule in ./acpCommandSafety — the launch
+// check and the admission check are still BOTH performed (defence in depth: a
+// config can reach disk without passing through the registry), but they can no
+// longer disagree about what "shell command line" means.
+/**
+ * Hub-facing facade over `@xenosystem/acp-core`.
+ *
+ * Hub owns policy, redacted diagnostics, and UI bridges. Core owns spawning, the official
+ * ACP SDK connection, session lifecycle, cancellation, and transport validation.
+ */
+export class AcpProcessSupervisor {
+    config;
+    runtime = null;
+    sessions = new Map();
+    status = 'stopped';
+    lifecycle = [];
+    stderrTail = [];
+    protocolVersion;
+    agentInfo;
+    agentCapabilities;
+    lastErrorCode;
+    permissionBridge;
+    hostBridge;
+    coordinationBridge;
+    requestTimeoutMs;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.permissionBridge = options.permissionBridge || new FailClosedAcpPermissionBridge();
+        this.hostBridge = options.hostBridge || new FailClosedAcpHostBridge();
+        this.coordinationBridge = options.coordinationBridge || new UnavailableCoordinationLaneBridge();
+        this.requestTimeoutMs = options.requestTimeoutMs || 30_000;
+        this.validateConfig(config);
+    }
+    getStatus() {
+        const coreState = this.runtime?.status().state;
+        if (coreState === 'stopped' && this.status !== 'stopping' && this.status !== 'stopped')
+            return 'exited';
+        return this.status;
+    }
+    async initialize() {
+        if (this.runtime && this.status === 'ready' && this.protocolVersion && this.agentInfo) {
+            return {
+                protocolVersion: this.protocolVersion,
+                agentCapabilities: this.agentCapabilities || {},
+                agentInfo: this.agentInfo,
+                authMethods: [],
+            };
+        }
+        this.validateConfig(this.config);
+        try {
+            await assertAcpProviderVersionReadyAsync(this.config);
+        }
+        catch (error) {
+            this.lastErrorCode = acpErrorCode(error);
+            this.transition('failed', 'ACP provider CLI version blocked.');
+            throw error;
+        }
+        this.transition('starting', 'Starting ACP subprocess through @xenosystem/acp-core.');
+        this.runtime = new AgentProcess({
+            def: {
+                id: this.config.id,
+                name: this.config.name,
+                cmd: this.config.command,
+                args: [...this.config.args],
+                ...(this.config.env ? { env: { ...this.config.env } } : {}),
+                ...(this.config.cwd ? { cwd: this.config.cwd } : {}),
+                initTimeoutMs: this.requestTimeoutMs,
+                permission: 'deny',
+            },
+            workspaceRoot: this.config.cwd || process.cwd(),
+            keepWorkspaces: true,
+            logger: createLogger('xeno-hub-acp', 'silent'),
+            clientInfo: {
+                name: 'xeno-hub',
+                title: 'XENO Hub',
+                version: String(packageJson.version || '0.0.0'),
+            },
+            clientCapabilities: DEFAULT_CLIENT_CAPABILITIES,
+            requestPermission: async (request) => handleAcpPermissionRequest(request, this.permissionBridge),
+            extMethod: async (method, params) => handleAcpHostExtensionRequest(method, params, this.hostBridge, this.coordinationBridge),
+            onStderr: (chunk) => this.captureStderr(chunk),
+            skipVersionCheck: true,
+            inheritedEnvKeys: [
+                'APPDATA', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'LOCALAPPDATA', 'PATH', 'PATHEXT',
+                'SystemDrive', 'SystemRoot', 'TEMP', 'TMP', 'USERPROFILE', 'WINDIR',
+            ],
+        });
+        this.transition('initializing', 'Initializing ACP protocol through @xenosystem/acp-core.');
+        try {
+            await this.runtime.ensureReady();
+            const initialization = this.runtime.diagnostics().initialization;
+            if (!initialization)
+                throw new AcpProtocolError('ACP initialize returned an invalid response.');
+            if (initialization.protocolVersion !== 1) {
+                this.lastErrorCode = 'ACP_VERSION_MISMATCH';
+                await this.stop();
+                throw new AcpVersionMismatchError(`Unsupported ACP protocol version: ${initialization.protocolVersion}`, {
+                    diagnostics: { expected: 1, received: initialization.protocolVersion },
+                });
+            }
+            this.protocolVersion = initialization.protocolVersion;
+            this.agentInfo = initialization.agentInfo;
+            this.agentCapabilities = initialization.agentCapabilities;
+            this.transition('ready', 'ACP protocol initialized by @xenosystem/acp-core.');
+            return {
+                protocolVersion: this.protocolVersion,
+                agentCapabilities: this.agentCapabilities || {},
+                agentInfo: this.agentInfo,
+                authMethods: initialization.authMethods || [],
+            };
+        }
+        catch (error) {
+            const classified = this.classifyCoreError(error);
+            this.lastErrorCode = classified.code;
+            this.transition(classified instanceof AcpVersionMismatchError ? 'exited' : 'failed', 'ACP initialization failed.');
+            throw classified;
+        }
+    }
+    async createSession(options = {}) {
+        if (!this.runtime || this.status !== 'ready')
+            await this.initialize();
+        const params = this.buildSessionNewRequest(options);
+        try {
+            const session = await this.runtime.createSession({
+                workspace: params.cwd,
+                mcpServers: params.mcpServers,
+                ...(params.additionalDirectories ? { additionalDirectories: params.additionalDirectories } : {}),
+                ...(params._meta ? { _meta: params._meta } : {}),
+            });
+            this.sessions.set(session.id, session);
+            return { sessionId: session.id };
+        }
+        catch (error) {
+            throw this.classifyCoreError(error);
+        }
+    }
+    supportsResumeSession() {
+        const sessionCapabilities = this.agentCapabilities?.sessionCapabilities;
+        const resume = sessionCapabilities && typeof sessionCapabilities === 'object' && !Array.isArray(sessionCapabilities)
+            ? sessionCapabilities.resume
+            : undefined;
+        return !!resume
+            && typeof resume === 'object'
+            && !Array.isArray(resume)
+            && typeof this.runtime?.resumeSession === 'function';
+    }
+    /**
+     * XENO ACP compatibility path for embedding cores that predate `AgentProcess.resumeSession`.
+     * The provider-native continuation id is rebound to a fresh ACP session via bounded `_meta`.
+     */
+    supportsSessionNewResumeState() {
+        const meta = this.agentCapabilities?._meta;
+        if (!meta || typeof meta !== 'object' || Array.isArray(meta))
+            return false;
+        const xeno = meta[XENO_ACP_META_KEY];
+        if (!xeno || typeof xeno !== 'object' || Array.isArray(xeno))
+            return false;
+        const capability = xeno.sessionResume;
+        return !!capability
+            && typeof capability === 'object'
+            && !Array.isArray(capability)
+            && capability.schemaVersion === 1
+            && capability.sessionNewMetaFallback === true;
+    }
+    async resumeSession(sessionId, options = {}) {
+        if (!this.runtime || this.status !== 'ready')
+            await this.initialize();
+        const runtime = this.runtime;
+        if (!this.supportsResumeSession() || !runtime?.resumeSession) {
+            throw new AcpProtocolError('ACP agent does not support session/resume.');
+        }
+        const params = this.buildSessionNewRequest(options);
+        try {
+            const session = await runtime.resumeSession(sessionId, {
+                workspace: params.cwd,
+                mcpServers: params.mcpServers,
+                additionalDirectories: params.additionalDirectories,
+                _meta: params._meta,
+            });
+            this.sessions.set(session.id, session);
+            return { sessionId: session.id };
+        }
+        catch (error) {
+            throw this.classifyCoreError(error);
+        }
+    }
+    async prompt(sessionId, prompt, options = {}) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !this.runtime)
+            throw new AcpProtocolError(`Unknown ACP session: ${sessionId}`);
+        const updates = [];
+        const cancelInteractiveBridges = () => {
+            cancelAcpPermissionBridge(this.permissionBridge);
+            cancelAcpHostBridge(this.hostBridge);
+        };
+        if (options.signal?.aborted) {
+            cancelInteractiveBridges();
+        }
+        else {
+            options.signal?.addEventListener('abort', cancelInteractiveBridges, { once: true });
+        }
+        this.transition('running', 'Running ACP prompt through @xenosystem/acp-core.');
+        try {
+            const promptOptions = {
+                timeoutMs: options.timeoutMs || this.requestTimeoutMs,
+                signal: options.signal,
+                model: options.model,
+                systemPrompt: options.systemPrompt,
+                execution: options.execution,
+                onUpdate: (notification) => {
+                    const update = this.normalizeSessionUpdate(notification);
+                    if (!update)
+                        return;
+                    updates.push(update);
+                    options.onUpdate?.(update);
+                },
+            };
+            const result = await this.runtime.promptSession(session, [{ type: 'text', text: prompt }], promptOptions);
+            this.transition('ready', 'ACP prompt completed.');
+            const responseMeta = result._meta && typeof result._meta === 'object' && !Array.isArray(result._meta)
+                ? result._meta
+                : undefined;
+            const resumeState = normalizeAcpSessionResumeState(responseMeta?.[XENO_ACP_SESSION_RESUME_META_KEY]);
+            return {
+                result: {
+                    stopReason: result.stopReason,
+                    ...(resumeState ? { resumeState } : {}),
+                },
+                updates,
+            };
+        }
+        catch (error) {
+            if (this.runtime?.diagnostics().exitCode === undefined) {
+                await this.waitForExitDiagnostics();
+            }
+            const classified = this.classifyCoreError(error);
+            this.lastErrorCode = classified.code;
+            if (classified instanceof AcpProcessExitedError)
+                this.transition('exited', 'ACP subprocess exited.');
+            else if (classified instanceof AcpTimeoutError)
+                this.transition('exited', 'ACP prompt timed out; connection invalidated.');
+            else
+                this.transition('ready', 'ACP prompt ended with an error.');
+            throw classified;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', cancelInteractiveBridges);
+        }
+    }
+    async cancelSession(sessionId) {
+        cancelAcpPermissionBridge(this.permissionBridge);
+        cancelAcpHostBridge(this.hostBridge);
+        if (!this.runtime)
+            throw new AcpProtocolError('ACP process is not initialized.');
+        await this.runtime.cancelSession(sessionId);
+        return { cancelled: true };
+    }
+    async restart() {
+        await this.stop();
+        return this.initialize();
+    }
+    /**
+     * Wait, briefly, for a transport that is going away to actually be gone.
+     *
+     * This exists because `getStatus()` is a LIVE READ of a value that is still settling right
+     * after a cancellation, and three separate decisions were each sampling it at one arbitrary
+     * instant: whether to emit `acp.agent.exited` against the cancelled request, whether to discard
+     * the conversation session, and whether the next prompt may reuse the process.
+     *
+     * ⚠️ What that costs is ATTRIBUTION, not the event: a missed sample defers the exit to
+     * `closeConversationSession`, which reports it under the synthetic id `acp-session-close`. The
+     * first draft of this note claimed the event could be lost entirely; it cannot, and the
+     * distinction matters to anyone consuming these events.
+     *
+     * A cancelled prompt aborts the connection mid-flight, so "is it dead yet" is genuinely
+     * unanswerable in that same tick. This gives the answer a bounded chance to arrive instead of
+     * guessing, and returns what was actually established.
+     *
+     * ⚠️ INTERIM, with a named exit condition. The right mechanism is a push: `AgentProcess`
+     * (`@xenosystem/acp-core`, which we own) exposes `onStderr` and `status()` and **no exit
+     * callback**, so there is nothing to subscribe to and polling is the only honest option from
+     * this side. Adding `onExit` upstream and reporting the exit when it is OBSERVED — rather than
+     * when someone thinks to look — removes both the poll and the deadline. Raised as a cross-repo
+     * requirement rather than worked around silently.
+     */
+    async waitForExit(timeoutMs) {
+        const deadline = Date.now() + Math.max(0, timeoutMs);
+        for (;;) {
+            const status = this.getStatus();
+            if (status === 'exited' || status === 'stopped')
+                return true;
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise((resolve) => { setTimeout(resolve, 5); });
+        }
+    }
+    async stop() {
+        if (!this.runtime) {
+            this.sessions.clear();
+            this.transition('stopped', 'ACP process already stopped.');
+            return;
+        }
+        this.transition('stopping', 'Stopping ACP subprocess through @xenosystem/acp-core.');
+        await this.runtime.dispose();
+        this.sessions.clear();
+        this.runtime = null;
+        this.transition('stopped', 'ACP subprocess stopped.');
+    }
+    diagnostics() {
+        const coreStatus = this.runtime?.status();
+        const coreDiagnostics = this.runtime?.diagnostics();
+        return {
+            agentConfigId: this.config.id,
+            command: redactAcpPath(this.config.command) || '[redacted-command]',
+            args: redactAcpArgs(this.config.args),
+            cwd: redactAcpPath(this.config.cwd),
+            envKeys: redactAcpEnvKeys(this.config.env),
+            status: this.getStatus(),
+            pid: coreStatus?.pid,
+            protocolVersion: this.protocolVersion,
+            agentInfo: this.agentInfo,
+            agentCapabilities: this.agentCapabilities,
+            activeSessionCount: coreStatus?.activeSessions || 0,
+            pendingRequestCount: 0,
+            lifecycle: this.lifecycle,
+            stderrTail: this.stderrTail,
+            malformedMessageCount: coreDiagnostics?.malformedMessageCount || 0,
+            unsupportedMethodCount: coreDiagnostics?.unsupportedMethodCount || 0,
+            lastErrorCode: this.lastErrorCode,
+            exitCode: coreDiagnostics?.exitCode,
+            signal: coreDiagnostics?.signal,
+        };
+    }
+    validateConfig(config) {
+        if (!config.id.trim())
+            throw new AcpProtocolError('ACP agent config id is required.');
+        if (!config.name.trim())
+            throw new AcpProtocolError('ACP agent config name is required.');
+        if (!config.command.trim())
+            throw new AcpProtocolError('ACP command must be a non-empty string.');
+        if (!isAbsolute(config.command))
+            throw new AcpProtocolError('ACP command must be an absolute executable path.');
+        if (isAcpShellCommandLine(config.command)) {
+            throw new AcpProtocolError('ACP command must be an executable path, not a shell command line.');
+        }
+        if (isAcpShellExecutable(config.command)) {
+            throw new AcpProtocolError('ACP command cannot be a shell executable.');
+        }
+        if (!config.enabled)
+            throw new AcpProtocolError('ACP agent config must be enabled before launch.');
+        if (config.trustLevel !== 'restricted' && config.trustLevel !== 'workspace') {
+            throw new AcpProtocolError('ACP trustLevel must be restricted or workspace.');
+        }
+        if (!Array.isArray(config.args) || config.args.some((arg) => typeof arg !== 'string')) {
+            throw new AcpProtocolError('ACP args must be an array of strings.');
+        }
+        if (config.cwd !== undefined && (!config.cwd.trim() || !isAbsolute(config.cwd))) {
+            throw new AcpProtocolError('ACP cwd must be an absolute path when provided.');
+        }
+        for (const [key, value] of Object.entries(config.env || {})) {
+            if (typeof value !== 'string')
+                throw new AcpProtocolError(`ACP env value must be a string: ${key}`);
+        }
+    }
+    buildSessionNewRequest(options) {
+        const cwd = options.cwd?.trim() || this.config.cwd?.trim();
+        if (!cwd || !isAbsolute(cwd))
+            throw new AcpProtocolError('ACP session/new cwd must be an absolute path.');
+        if (options.mcpServers !== undefined && !Array.isArray(options.mcpServers)) {
+            throw new AcpProtocolError('ACP session/new mcpServers must be an array.');
+        }
+        if (options._meta !== undefined && (!options._meta || typeof options._meta !== 'object' || Array.isArray(options._meta))) {
+            throw new AcpProtocolError('ACP session/new _meta must be an object when provided.');
+        }
+        if (options.additionalDirectories !== undefined
+            && (!Array.isArray(options.additionalDirectories)
+                || options.additionalDirectories.some((directory) => typeof directory !== 'string' || !isAbsolute(directory)))) {
+            throw new AcpProtocolError('ACP session/new additionalDirectories must contain only absolute paths.');
+        }
+        return {
+            cwd,
+            mcpServers: options.mcpServers ? [...options.mcpServers] : [],
+            ...(options._meta ? { _meta: { ...options._meta } } : {}),
+            ...(options.additionalDirectories ? { additionalDirectories: [...new Set(options.additionalDirectories)] } : {}),
+        };
+    }
+    classifyCoreError(error) {
+        if (error instanceof AcpProtocolError
+            || error instanceof AcpTimeoutError
+            || error instanceof AcpCancelledError
+            || error instanceof AcpProcessExitedError
+            || error instanceof AcpVersionMismatchError)
+            return error;
+        const message = error instanceof Error ? error.message : String(error);
+        if (/unsupported ACP protocol version/i.test(message)) {
+            return new AcpVersionMismatchError(redactAcpText(message), { cause: error });
+        }
+        if (/timed out/i.test(message))
+            return new AcpTimeoutError(redactAcpText(message), { cause: error });
+        if (/cancel/i.test(message))
+            return new AcpCancelledError(redactAcpText(message), { cause: error });
+        if (this.runtime?.status().state === 'stopped' || /process exited|connection.*closed|stream.*closed/i.test(message)) {
+            return new AcpProcessExitedError(redactAcpText(message), { processId: this.runtime?.status().pid, cause: error });
+        }
+        return new AcpProtocolError(redactAcpText(message), { cause: error });
+    }
+    transition(status, message) {
+        this.status = status;
+        this.lifecycle = boundedPush(this.lifecycle, { timestamp: new Date().toISOString(), status, message }, 25);
+    }
+    captureStderr(chunk) {
+        for (const line of chunk.split(/\r?\n/)) {
+            if (!line)
+                continue;
+            this.stderrTail = boundedPush(this.stderrTail, redactAcpText(line, 1000), 50);
+        }
+    }
+    normalizeSessionUpdate(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return undefined;
+        const record = value;
+        if (!record.update || typeof record.update !== 'object' || Array.isArray(record.update))
+            return undefined;
+        const update = this.normalizeUpdate(record.update, typeof record.sessionId === 'string' ? record.sessionId : undefined);
+        if (!update)
+            return undefined;
+        return { ...(typeof record.sessionId === 'string' ? { sessionId: record.sessionId } : {}), update };
+    }
+    normalizeUpdate(value, sessionId) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return undefined;
+        const record = value;
+        const updateType = typeof record.type === 'string'
+            ? record.type
+            : typeof record.sessionUpdate === 'string' ? record.sessionUpdate : undefined;
+        if (!updateType)
+            return undefined;
+        if (updateType === 'plan') {
+            const entries = this.normalizePlanEntries(record.entries);
+            return {
+                type: 'plan',
+                content: typeof record.content === 'string'
+                    ? redactAcpText(record.content, 32_000)
+                    : entries.map((entry) => entry.content).join('\n'),
+                ...(entries.length ? { entries } : {}),
+            };
+        }
+        if (updateType === 'agent_message_chunk') {
+            const content = record.content;
+            const text = typeof content === 'string'
+                ? content
+                : content && typeof content === 'object' && !Array.isArray(content) && typeof content.text === 'string'
+                    ? String(content.text)
+                    : '';
+            return {
+                type: 'agent_message_chunk',
+                messageId: typeof record.messageId === 'string'
+                    ? redactAcpText(record.messageId, 500)
+                    : `${sessionId || 'acp'}-message`,
+                content: text,
+            };
+        }
+        if (updateType === 'tool_call') {
+            const toolCallId = typeof record.toolCallId === 'string'
+                ? redactAcpText(record.toolCallId.trim(), 500)
+                : undefined;
+            if (!toolCallId)
+                return undefined;
+            return {
+                type: 'tool_call',
+                toolCallId,
+                title: typeof record.title === 'string' ? redactAcpText(record.title, 500) : 'ACP Tool',
+                kind: typeof record.kind === 'string' ? redactAcpText(record.kind, 100) : 'unknown',
+                status: this.normalizeToolStatus(record.status),
+                content: this.normalizeToolContent(record.content),
+                locations: this.normalizeToolLocations(record.locations),
+                rawInput: this.normalizeToolPayload(record.rawInput),
+                rawOutput: this.normalizeToolPayload(record.rawOutput),
+            };
+        }
+        if (updateType === 'tool_call_update') {
+            const toolCallId = typeof record.toolCallId === 'string'
+                ? redactAcpText(record.toolCallId.trim(), 500)
+                : undefined;
+            const status = this.normalizeToolStatus(record.status);
+            if (!toolCallId || !status)
+                return undefined;
+            const rawOutput = this.normalizeToolPayload(record.rawOutput);
+            return {
+                type: 'tool_call_update',
+                toolCallId,
+                // Carried, not dropped. The mapper had nothing to name the tool with, so it substituted a
+                // constant — the normalizer is where the information was actually being lost.
+                title: typeof record.title === 'string' ? redactAcpText(record.title, 500) : undefined,
+                status,
+                content: this.normalizeToolContent(record.content),
+                rawOutput,
+                error: typeof record.error === 'string'
+                    ? redactAcpText(record.error, 2_000)
+                    : rawOutput && typeof rawOutput === 'object' && !Array.isArray(rawOutput)
+                        && typeof rawOutput.error === 'string'
+                        ? String(rawOutput.error)
+                        : undefined,
+                _meta: record._meta && typeof record._meta === 'object' && !Array.isArray(record._meta)
+                    ? record._meta
+                    : undefined,
+            };
+        }
+        if (updateType === 'usage_update') {
+            const used = typeof record.used === 'number' && Number.isFinite(record.used) ? record.used : undefined;
+            const meta = record._meta && typeof record._meta === 'object' && !Array.isArray(record._meta)
+                ? record._meta
+                : {};
+            return {
+                type: 'usage_update',
+                inputTokens: typeof record.inputTokens === 'number'
+                    ? record.inputTokens
+                    : typeof meta.inputTokens === 'number' ? meta.inputTokens : undefined,
+                outputTokens: typeof record.outputTokens === 'number'
+                    ? record.outputTokens
+                    : typeof meta.outputTokens === 'number' ? meta.outputTokens : undefined,
+                totalTokens: typeof record.totalTokens === 'number'
+                    ? record.totalTokens
+                    : typeof meta.totalTokens === 'number' ? meta.totalTokens : used,
+            };
+        }
+        return undefined;
+    }
+    normalizeToolStatus(value) {
+        return value === 'pending' || value === 'in_progress' || value === 'completed' || value === 'failed' ? value : undefined;
+    }
+    normalizePlanEntries(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(0, 100).flatMap((entry) => {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+                return [];
+            const record = entry;
+            if (typeof record.content !== 'string' || !record.content.trim())
+                return [];
+            return [{
+                    content: redactAcpText(record.content.trim(), 1_000),
+                    priority: record.priority === 'high' || record.priority === 'low' ? record.priority : 'medium',
+                    status: record.status === 'in_progress' || record.status === 'completed' ? record.status : 'pending',
+                }];
+        });
+    }
+    normalizeToolContent(value) {
+        if (!Array.isArray(value))
+            return undefined;
+        const normalized = value.slice(0, 50).flatMap((entry) => {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+                return [];
+            const outer = entry;
+            const record = outer.type === 'content'
+                && outer.content
+                && typeof outer.content === 'object'
+                && !Array.isArray(outer.content)
+                ? outer.content
+                : outer;
+            if (record.type === 'text' && typeof record.text === 'string') {
+                return [{ type: 'text', text: redactAcpText(record.text, 32_000) }];
+            }
+            if (record.type === 'diff'
+                && typeof record.path === 'string'
+                && typeof record.oldText === 'string'
+                && typeof record.newText === 'string') {
+                return [{
+                        type: 'diff',
+                        path: redactAcpText(record.path, 2_000),
+                        oldText: redactAcpText(record.oldText, 32_000),
+                        newText: redactAcpText(record.newText, 32_000),
+                    }];
+            }
+            if (record.type === 'terminal' && typeof record.terminalId === 'string') {
+                return [{
+                        type: 'terminal',
+                        terminalId: redactAcpText(record.terminalId, 500),
+                        ...(typeof record.text === 'string' ? { text: redactAcpText(record.text, 32_000) } : {}),
+                    }];
+            }
+            return [];
+        });
+        return normalized.length ? normalized : undefined;
+    }
+    normalizeToolLocations(value) {
+        if (!Array.isArray(value))
+            return undefined;
+        const normalized = value.slice(0, 100).flatMap((entry) => {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+                return [];
+            const record = entry;
+            if (typeof record.path !== 'string' || !record.path.trim())
+                return [];
+            return [{
+                    path: redactAcpText(record.path, 2_000),
+                    ...(typeof record.line === 'number' && Number.isFinite(record.line)
+                        ? { line: Math.max(1, Math.trunc(record.line)) }
+                        : {}),
+                    ...(typeof record.column === 'number' && Number.isFinite(record.column)
+                        ? { column: Math.max(1, Math.trunc(record.column)) }
+                        : {}),
+                }];
+        });
+        return normalized.length ? normalized : undefined;
+    }
+    normalizeToolPayload(value) {
+        if (value === undefined)
+            return undefined;
+        try {
+            const serialized = JSON.stringify(value);
+            if (serialized === undefined)
+                return undefined;
+            const redacted = redactAcpText(serialized, 32_000);
+            if (redacted.endsWith('...[truncated]')) {
+                return { truncated: true, preview: redacted };
+            }
+            return JSON.parse(redacted);
+        }
+        catch {
+            return { invalid: true };
+        }
+    }
+    async waitForExitDiagnostics() {
+        for (let attempt = 0; attempt < 10; attempt += 1) {
+            if (this.runtime?.diagnostics().exitCode !== undefined)
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+}
+//# sourceMappingURL=AcpProcessSupervisor.js.map