@xenosystem/agent-interface-host 0.1.3

package/dist/cli/CliControlPlaneService.js

@@ -0,0 +1,1874 @@
+import { spawn } from 'child_process';
+import { asRecord, denyWithPolicy, evaluateIpcPolicy } from '../policy/policyGuard.js';
+import { getRuntimeEventStore, RuntimeEventStore } from '../runtime/RuntimeEventStore.js';
+const SECRET_KEY_PATTERN = /(authorization|bearer|token|secret|password|credential|cookie|api[-_]?key|access[-_]?key|refresh[-_]?token|private[-_]?key)/i;
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+const HTTP_OPENAPI_METHOD_PATTERN = /^(get|put|post|delete|patch|options|head|trace)$/i;
+const READ_ONLY_OPERATION_METHODS = new Set(['GET', 'HEAD']);
+const activeCliThreadRuns = new Map();
+const activeCliRemoteRuns = new Map();
+const CLI_WORKFLOW_DEFINITIONS = [
+    {
+        id: 'runs',
+        label: 'Runs',
+        keywords: ['run', 'runs', 'session', 'sessions', 'attach', 'stop', 'cancel', 'event', 'events', 'stream'],
+        excludeKeywords: ['remote'],
+        expected: [
+            { id: 'run-lifecycle', label: 'run lifecycle', keywords: ['run', 'runs', 'session', 'sessions'] },
+            { id: 'stream-attach', label: 'stream or attach', keywords: ['attach', 'event', 'events', 'stream'] },
+            { id: 'stop-cancel', label: 'stop or cancel', keywords: ['stop', 'cancel'] },
+        ],
+    },
+    {
+        id: 'evals',
+        label: 'Evals',
+        keywords: ['eval', 'evals', 'evaluation', 'evaluations', 'compare', 'report', 'reports', 'artifact', 'artifacts', 'score'],
+        expected: [
+            { id: 'evaluation-runs', label: 'evaluation runs', keywords: ['eval', 'evals', 'evaluation', 'evaluations'] },
+            { id: 'reports-compare', label: 'reports or compare', keywords: ['report', 'reports', 'compare'] },
+            { id: 'artifacts', label: 'artifacts', keywords: ['artifact', 'artifacts'] },
+        ],
+    },
+    {
+        id: 'shareReplay',
+        label: 'Share/replay',
+        keywords: ['share', 'replay', 'bundle', 'bundles', 'snapshot', 'export', 'import'],
+        expected: [
+            { id: 'share-export', label: 'share or export', keywords: ['share', 'export'] },
+            { id: 'replay-import', label: 'replay or import', keywords: ['replay', 'import'] },
+            { id: 'bundle', label: 'bundle', keywords: ['bundle', 'bundles'] },
+        ],
+    },
+    {
+        id: 'remoteRuns',
+        label: 'Remote runs',
+        keywords: ['remote', 'probe', 'probes', 'validate', 'attach', 'event', 'events'],
+        expected: [
+            { id: 'remote-targets', label: 'remote targets', keywords: ['remote'] },
+            { id: 'probe-validate', label: 'probe or validate', keywords: ['probe', 'probes', 'validate'] },
+            { id: 'attach-events', label: 'attach or events', keywords: ['attach', 'event', 'events'] },
+        ],
+    },
+    {
+        id: 'mcpAuth',
+        label: 'MCP auth',
+        keywords: ['mcp', 'auth', 'login', 'logout', 'device', 'status'],
+        expected: [
+            { id: 'mcp-surface', label: 'mcp surface', keywords: ['mcp'] },
+            { id: 'auth-lifecycle', label: 'auth lifecycle', keywords: ['auth', 'login', 'logout', 'device'] },
+            { id: 'status', label: 'status', keywords: ['status'] },
+        ],
+    },
+    {
+        id: 'orgMetadata',
+        label: 'Org metadata',
+        keywords: ['org', 'organization', 'knowledge', 'playbook', 'playbooks', 'serviceuser', 'serviceusers', 'secret', 'secrets'],
+        expected: [
+            { id: 'org-surface', label: 'org surface', keywords: ['org', 'organization'] },
+            { id: 'knowledge-playbooks', label: 'knowledge or playbooks', keywords: ['knowledge', 'playbook', 'playbooks'] },
+            { id: 'service-users-metadata', label: 'service users or protected metadata', keywords: ['serviceuser', 'serviceusers', 'secret', 'secrets'] },
+        ],
+    },
+    {
+        id: 'githubApp',
+        label: 'GitHub app',
+        keywords: ['github', 'webhook', 'webhooks', 'plan', 'verify', 'installation', 'installations'],
+        expected: [
+            { id: 'github-surface', label: 'github surface', keywords: ['github'] },
+            { id: 'webhooks', label: 'webhooks', keywords: ['webhook', 'webhooks'] },
+            { id: 'plan-verify', label: 'plan or verify', keywords: ['plan', 'verify'] },
+        ],
+    },
+];
+const CLI_PRODUCT_DASHBOARD_DETAILS = {
+    runs: {
+        label: 'Run control dashboard',
+        description: 'Local CLI run list, start, attach, stop, and event contracts.',
+        nextStep: 'Inspect run list/events first; mutation actions stay guarded until typed run-control calls are approved.',
+    },
+    evals: {
+        label: 'Eval dashboard',
+        description: 'Eval list, inspect, run, compare, reports, and artifact contracts.',
+        nextStep: 'Probe report/artifact reads before enabling eval run or compare actions.',
+    },
+    shareReplay: {
+        label: 'Share/replay dashboard',
+        description: 'Share export, replay bundle inspection, and redacted bundle contracts.',
+        nextStep: 'Use read-only bundle inspection before enabling export/import mutations.',
+    },
+    remoteRuns: {
+        label: 'Remote run dashboard',
+        description: 'Remote readiness, probe, validate, start, attach, events, and stop contracts.',
+        nextStep: 'Verify remote readiness/probe metadata before showing attach/start/stop actions.',
+    },
+    mcpAuth: {
+        label: 'MCP auth dashboard',
+        description: 'MCP auth status, login, no-browser/device flow, and logout contracts.',
+        nextStep: 'Show auth status and device-flow instructions before exposing login/logout actions.',
+    },
+    orgMetadata: {
+        label: 'Org metadata dashboard',
+        description: 'Knowledge, playbooks, secrets metadata, and service-user list contracts.',
+        nextStep: 'List metadata only; never render token, key, secret, or credential values.',
+    },
+    githubApp: {
+        label: 'GitHub app dashboard',
+        description: 'GitHub app plan, verify, and webhook fixture inspection contracts.',
+        nextStep: 'Inspect plan/verify output before enabling webhook or installation mutations.',
+    },
+};
+export function normalizeLocalCliAppServerEndpoint(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        const host = url.hostname.toLowerCase();
+        if (!LOCAL_HOSTS.has(host) && !host.endsWith('.localhost'))
+            return null;
+        return `${url.protocol}//${url.host}`;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeCliAppServerTokenEnvKey(value) {
+    if (typeof value !== 'string')
+        return null;
+    const key = value.trim().slice(0, 128);
+    if (/^(sk|xox[baprs]|gh[pousr])_[A-Za-z0-9_=-]{8,}$/i.test(key))
+        return null;
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ? key : null;
+}
+export function redactCliControlPlaneText(value, maxLength = 220) {
+    if (typeof value !== 'string')
+        return '';
+    const redacted = value
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [redacted]')
+        .replace(/(sk|xox[baprs]|gh[pousr])_[A-Za-z0-9_=-]{8,}/gi, '$1_[redacted]')
+        .replace(/([?&#](?:token|key|secret|password|bearer|api_key|access_token)=)[^&#\s]+/gi, '$1[redacted]')
+        .replace(/\/\/([^:/\s]+):([^@/\s]+)@/g, '//[redacted]@[redacted]@');
+    return redacted.slice(0, maxLength);
+}
+export function emptyManifestSummary(error) {
+    return { ok: false, status: 0, capabilities: [], ...(error ? { error: redactCliControlPlaneText(error) } : {}) };
+}
+export function emptyOpenApiSummary(error) {
+    return { ok: false, status: 0, operationCount: 0, paths: [], ...(error ? { error: redactCliControlPlaneText(error) } : {}) };
+}
+export function emptyOperationResponseSummary(error) {
+    return {
+        ok: false,
+        status: 0,
+        bodyType: 'null',
+        keys: [],
+        ...(error ? { error: redactCliControlPlaneText(error) } : {}),
+    };
+}
+function isSafeOpenApiPath(path) {
+    return path.startsWith('/') && !SECRET_KEY_PATTERN.test(path);
+}
+export function normalizeCliWorkflowOperationPath(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > 400)
+        return null;
+    if (!trimmed.startsWith('/') || trimmed.startsWith('//'))
+        return null;
+    if (/[\\\r\n\t]/.test(trimmed) || SECRET_KEY_PATTERN.test(trimmed))
+        return null;
+    try {
+        const normalized = new URL(trimmed, 'http://localhost').pathname;
+        return normalized === trimmed.split(/[?#]/, 1)[0] ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readString(record, keys, maxLength = 120) {
+    for (const key of keys) {
+        if (SECRET_KEY_PATTERN.test(key))
+            continue;
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            return redactCliControlPlaneText(value.trim(), maxLength);
+    }
+    return undefined;
+}
+function readSafeDescriptor(record, keys, maxLength = 120) {
+    const value = readString(record, keys, maxLength);
+    if (!value || SECRET_KEY_PATTERN.test(value))
+        return undefined;
+    return value;
+}
+function readSafeHttpUrlArgument(record, keys, maxLength = 500) {
+    let provided = false;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            provided = true;
+    }
+    if (!provided)
+        return {};
+    const value = readSafeDescriptor(record, keys, maxLength);
+    if (!value)
+        return { error: 'GitHub app backend URL must be a safe http(s) URL.' };
+    try {
+        const parsed = new URL(value);
+        if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:') || parsed.username || parsed.password || SECRET_KEY_PATTERN.test(parsed.search)) {
+            return { error: 'GitHub app backend URL must be a safe http(s) URL.' };
+        }
+        return { value };
+    }
+    catch {
+        return { error: 'GitHub app backend URL must be a safe http(s) URL.' };
+    }
+}
+function readSafePathArgument(record, keys, maxLength = 2000) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value !== 'string')
+            continue;
+        const trimmed = value.trim().slice(0, maxLength);
+        if (!trimmed || /[\0\r\n]/.test(trimmed) || SECRET_KEY_PATTERN.test(trimmed))
+            continue;
+        return trimmed;
+    }
+    return undefined;
+}
+function safePathLabel(value) {
+    if (!value)
+        return undefined;
+    const parts = value.split(/[\\/]+/).filter(Boolean);
+    return redactCliControlPlaneText(parts.at(-1) || value, 160);
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function readThreadRunText(messages, bodyRecord) {
+    for (const message of messages) {
+        const messageRecord = readRecord(message);
+        const resultRecord = readRecord(messageRecord.result);
+        const text = readString(resultRecord, ['text', 'content', 'output', 'message', 'summary'], 4000)
+            || readString(messageRecord, ['text', 'content', 'output', 'message', 'summary'], 4000);
+        if (text)
+            return text;
+    }
+    return readString(bodyRecord, ['text', 'content', 'output', 'message', 'summary'], 4000);
+}
+function appendCliThreadRuntimeEvent(store, record, event) {
+    const conversationId = readSafeDescriptor(record, ['conversationId', 'targetConversationId'], 200);
+    const requestId = readSafeDescriptor(record, ['requestId'], 100);
+    if (!conversationId || !requestId)
+        return;
+    const callerRecord = asRecord(record.caller);
+    store.append({
+        conversationId,
+        requestId,
+        caller: {
+            workspaceId: readSafeDescriptor(callerRecord, ['workspaceId'], 200),
+            teamId: readSafeDescriptor(callerRecord, ['teamId'], 200),
+            agentId: readSafeDescriptor(callerRecord, ['agentId'], 200),
+        },
+        source: 'cli',
+        redactionState: 'redacted',
+        event,
+    });
+}
+function appendCliRemoteRuntimeEvent(store, record, event) {
+    const conversationId = readSafeDescriptor(record, ['conversationId', 'targetConversationId'], 200);
+    const requestId = readSafeDescriptor(record, ['requestId'], 100);
+    if (!conversationId || !requestId)
+        return;
+    const callerRecord = asRecord(record.caller);
+    store.append({
+        conversationId,
+        requestId,
+        caller: {
+            workspaceId: readSafeDescriptor(callerRecord, ['workspaceId'], 200),
+            teamId: readSafeDescriptor(callerRecord, ['teamId'], 200),
+            agentId: readSafeDescriptor(callerRecord, ['agentId'], 200),
+        },
+        source: 'remote',
+        redactionState: 'redacted',
+        event,
+    });
+}
+function readCliRemoteCwd(record) {
+    const direct = typeof record.cwd === 'string' && record.cwd.trim()
+        ? record.cwd.trim().slice(0, 2000)
+        : undefined;
+    if (direct)
+        return direct;
+    const caller = asRecord(record.caller);
+    if (!Array.isArray(caller.allowedDirectories))
+        return undefined;
+    const first = caller.allowedDirectories.find((entry) => typeof entry === 'string' && !!entry.trim());
+    return first?.trim().slice(0, 2000);
+}
+const MAX_CLI_REMOTE_OUTPUT_CHARS = 2_000_000;
+function appendBoundedOutput(current, chunk) {
+    if (current.length >= MAX_CLI_REMOTE_OUTPUT_CHARS)
+        return current;
+    return (current + chunk.toString('utf8')).slice(0, MAX_CLI_REMOTE_OUTPUT_CHARS);
+}
+function runXenoCliCommand(args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.platform === 'win32' ? 'xeno.cmd' : 'xeno', args, {
+            cwd: options.cwd,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        options.activeRun.child = child;
+        let stdout = '';
+        let stderr = '';
+        const timeout = setTimeout(() => {
+            options.activeRun.cancelled = true;
+            child.kill();
+        }, options.timeoutMs);
+        child.stdout.on('data', (chunk) => { stdout = appendBoundedOutput(stdout, chunk); });
+        child.stderr.on('data', (chunk) => { stderr = appendBoundedOutput(stderr, chunk); });
+        child.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.on('close', (exitCode) => {
+            clearTimeout(timeout);
+            resolve({ exitCode, stdout, stderr });
+        });
+    });
+}
+function parseCliRemoteReport(stdout) {
+    try {
+        const parsed = JSON.parse(stdout.trim());
+        return readRecord(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeCliJsonCommandResult(result) {
+    const body = parseCliRemoteReport(result.stdout);
+    const ok = result.exitCode === 0 && Boolean(body);
+    return {
+        body,
+        response: summarizeOperationResponse({
+            ok,
+            status: ok ? 200 : result.exitCode ?? 0,
+            contentType: body ? 'application/json' : undefined,
+            body: body || null,
+            error: ok ? undefined : redactCliControlPlaneText(result.stderr || 'CLI command did not return JSON.', 400),
+        }),
+    };
+}
+function cliRemoteStatus(report, exitCode, cancelled) {
+    if (cancelled)
+        return 'cancelled';
+    if (report?.ok === true)
+        return 'available';
+    const code = readSafeDescriptor(report || {}, ['code'], 120) || '';
+    if (/not_ready|capability|budget|denied|unauthorized/i.test(code))
+        return 'blocked';
+    return exitCode === null ? 'offline' : 'degraded';
+}
+function remoteRunStartedText(runId) {
+    return runId ? `Remote run started: ${runId}` : 'Remote run started.';
+}
+function readCapabilities(value) {
+    const out = [];
+    const seen = new Set();
+    const push = (entry) => {
+        if (typeof entry !== 'string')
+            return;
+        const cleaned = redactCliControlPlaneText(entry.trim(), 80);
+        if (!cleaned || SECRET_KEY_PATTERN.test(cleaned) || seen.has(cleaned))
+            return;
+        seen.add(cleaned);
+        out.push(cleaned);
+    };
+    if (Array.isArray(value)) {
+        for (const item of value)
+            push(item);
+    }
+    else if (value && typeof value === 'object' && !Array.isArray(value)) {
+        for (const [key, enabled] of Object.entries(value)) {
+            if (enabled === false || SECRET_KEY_PATTERN.test(key))
+                continue;
+            push(key);
+        }
+    }
+    return out.slice(0, 40);
+}
+function countOpenApiOperations(paths) {
+    let count = 0;
+    for (const [path, value] of Object.entries(paths)) {
+        if (!isSafeOpenApiPath(path))
+            continue;
+        const pathItem = readRecord(value);
+        for (const method of Object.keys(pathItem)) {
+            if (HTTP_OPENAPI_METHOD_PATTERN.test(method))
+                count += 1;
+        }
+    }
+    return count;
+}
+function addWorkflowTokens(target, value) {
+    if (typeof value !== 'string' || SECRET_KEY_PATTERN.test(value))
+        return;
+    const expanded = value.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
+    for (const segment of expanded.split(/[/?#&=]+/)) {
+        const compact = segment.replace(/[^a-z0-9]+/g, '');
+        if (compact)
+            target.add(compact);
+        for (const token of segment.split(/[^a-z0-9]+/)) {
+            if (token)
+                target.add(token);
+        }
+    }
+}
+function workflowTokensMatch(tokens, keywords) {
+    return keywords.some((keyword) => tokens.has(keyword.toLowerCase().replace(/[^a-z0-9]+/g, '')));
+}
+function readOperationTokens(path, method, operation) {
+    const tokens = new Set();
+    addWorkflowTokens(tokens, path);
+    addWorkflowTokens(tokens, method);
+    addWorkflowTokens(tokens, operation.operationId);
+    addWorkflowTokens(tokens, operation.summary);
+    addWorkflowTokens(tokens, operation.description);
+    if (Array.isArray(operation.tags)) {
+        for (const tag of operation.tags)
+            addWorkflowTokens(tokens, tag);
+    }
+    return tokens;
+}
+export function deriveCliWorkflowReadiness(pathsValue) {
+    const paths = readRecord(pathsValue);
+    const summaries = CLI_WORKFLOW_DEFINITIONS.map((definition) => ({
+        id: definition.id,
+        label: definition.label,
+        available: false,
+        operationCount: 0,
+        pathSet: new Set(),
+        operations: [],
+        actions: definition.expected.map((action) => ({
+            id: action.id,
+            label: action.label,
+            available: false,
+            operationCount: 0,
+            methodSet: new Set(),
+            pathSet: new Set(),
+            inspectableOperationIds: new Set(),
+        })),
+        matchedKeywords: new Set(),
+    }));
+    for (const [path, value] of Object.entries(paths)) {
+        if (!isSafeOpenApiPath(path))
+            continue;
+        const pathItem = readRecord(value);
+        for (const [method, operationValue] of Object.entries(pathItem)) {
+            if (!HTTP_OPENAPI_METHOD_PATTERN.test(method))
+                continue;
+            const operation = readRecord(operationValue);
+            const tokens = readOperationTokens(path, method, operation);
+            for (const [index, definition] of CLI_WORKFLOW_DEFINITIONS.entries()) {
+                const excludeKeywords = 'excludeKeywords' in definition ? definition.excludeKeywords : [];
+                if (excludeKeywords.length && workflowTokensMatch(tokens, excludeKeywords))
+                    continue;
+                if (!workflowTokensMatch(tokens, definition.keywords))
+                    continue;
+                const methodUpper = method.toUpperCase();
+                const operationSummary = {
+                    id: `${methodUpper} ${path}`,
+                    method: methodUpper,
+                    path,
+                    operationId: readSafeDescriptor(operation, ['operationId'], 100),
+                    summary: readSafeDescriptor(operation, ['summary'], 140),
+                    tags: readCapabilities(operation.tags).slice(0, 8),
+                    inspectable: READ_ONLY_OPERATION_METHODS.has(methodUpper) && !/[{}]/.test(path),
+                };
+                const summary = summaries[index];
+                summary.available = true;
+                summary.operationCount += 1;
+                summary.pathSet.add(path);
+                if (!summary.operations.some((existing) => existing.id === operationSummary.id)) {
+                    summary.operations.push(operationSummary);
+                }
+                for (const [actionIndex, action] of definition.expected.entries()) {
+                    if (!workflowTokensMatch(tokens, action.keywords))
+                        continue;
+                    const actionSummary = summary.actions[actionIndex];
+                    actionSummary.available = true;
+                    actionSummary.operationCount += 1;
+                    actionSummary.methodSet.add(operationSummary.method);
+                    actionSummary.pathSet.add(operationSummary.path);
+                    if (operationSummary.inspectable)
+                        actionSummary.inspectableOperationIds.add(operationSummary.id);
+                }
+                for (const keyword of definition.keywords) {
+                    if (workflowTokensMatch(tokens, [keyword]))
+                        summary.matchedKeywords.add(keyword);
+                }
+            }
+        }
+    }
+    return summaries.map((summary, index) => {
+        const definition = CLI_WORKFLOW_DEFINITIONS[index];
+        return {
+            id: summary.id,
+            label: summary.label,
+            available: summary.available,
+            operationCount: summary.operationCount,
+            paths: Array.from(summary.pathSet).slice(0, 12),
+            operations: summary.operations.slice(0, 12),
+            actions: summary.actions.map((action) => ({
+                id: action.id,
+                label: action.label,
+                available: action.available,
+                operationCount: action.operationCount,
+                methods: Array.from(action.methodSet).slice(0, 8),
+                paths: Array.from(action.pathSet).slice(0, 8),
+                inspectableOperationIds: Array.from(action.inspectableOperationIds).slice(0, 8),
+            })),
+            missing: definition.expected
+                .filter((expectation) => !workflowTokensMatch(summary.matchedKeywords, expectation.keywords))
+                .map((expectation) => expectation.label),
+        };
+    });
+}
+export function deriveCliProductDashboards(workflows) {
+    return workflows.map((workflow) => {
+        const details = CLI_PRODUCT_DASHBOARD_DETAILS[workflow.id] || {
+            label: `${workflow.label} dashboard`,
+            description: `${workflow.label} CLI workflow contract.`,
+            nextStep: 'Inspect safe read-only operations before enabling mutations.',
+        };
+        const readOnlyProbeCount = workflow.operations.filter((operation) => operation.inspectable).length;
+        const mutatingOperationCount = workflow.operations.filter((operation) => !READ_ONLY_OPERATION_METHODS.has(operation.method)).length;
+        const availableActionCount = workflow.actions.filter((action) => action.available).length;
+        const requiredActionCount = workflow.actions.length;
+        const status = !workflow.available
+            ? 'missing'
+            : workflow.missing.length > 0
+                ? 'partial'
+                : 'ready';
+        return {
+            id: workflow.id,
+            label: details.label,
+            description: details.description,
+            nextStep: details.nextStep,
+            status,
+            operationCount: workflow.operationCount,
+            availableActionCount,
+            requiredActionCount,
+            readOnlyProbeCount,
+            mutatingOperationCount,
+            paths: workflow.paths,
+            missing: workflow.missing,
+            actions: workflow.actions.map((action) => ({
+                id: action.id,
+                label: action.label,
+                available: action.available,
+                operationCount: action.operationCount,
+                methods: action.methods,
+                paths: action.paths,
+                probeablePathCount: action.inspectableOperationIds.length,
+                mutatingOperationCount: action.methods.filter((method) => !READ_ONLY_OPERATION_METHODS.has(method)).length,
+            })),
+        };
+    });
+}
+async function fetchJson(endpoint, path, timeoutMs, method = 'GET', token) {
+    try {
+        const headers = { Accept: 'application/json' };
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        const response = await fetch(`${endpoint}${path}`, {
+            method,
+            headers,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const contentType = response.headers.get('content-type') || undefined;
+        const text = method === 'HEAD' ? '' : await response.text();
+        let body = null;
+        try {
+            body = text ? JSON.parse(text) : null;
+        }
+        catch {
+            return { ok: false, status: response.status, contentType, body: null, error: 'Invalid JSON response.' };
+        }
+        return { ok: response.ok, status: response.status, contentType, body, error: response.ok ? undefined : `HTTP ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, status: 0, body: null, error: error instanceof Error ? error.message : 'Network request failed.' };
+    }
+}
+function summarizeOperationResponse(result) {
+    const body = result.body;
+    const base = {
+        ok: result.ok,
+        status: result.status,
+        contentType: result.contentType,
+        error: result.error ? redactCliControlPlaneText(result.error) : undefined,
+    };
+    if (Array.isArray(body)) {
+        const first = readRecord(body[0]);
+        return {
+            ...base,
+            bodyType: 'array',
+            itemCount: body.length,
+            keys: Object.keys(first).filter((key) => !SECRET_KEY_PATTERN.test(key)).slice(0, 24),
+        };
+    }
+    if (body && typeof body === 'object') {
+        return {
+            ...base,
+            bodyType: 'object',
+            keys: Object.keys(readRecord(body)).filter((key) => !SECRET_KEY_PATTERN.test(key)).slice(0, 24),
+        };
+    }
+    if (typeof body === 'string') {
+        return {
+            ...base,
+            bodyType: 'string',
+            keys: [],
+            preview: redactCliControlPlaneText(body, 160),
+        };
+    }
+    if (typeof body === 'number')
+        return { ...base, bodyType: 'number', keys: [], preview: String(body).slice(0, 80) };
+    if (typeof body === 'boolean')
+        return { ...base, bodyType: 'boolean', keys: [], preview: String(body) };
+    return { ...base, bodyType: 'null', keys: [] };
+}
+function normalizeReadOnlyOperationMethod(value) {
+    if (typeof value !== 'string')
+        return null;
+    const method = value.trim().toUpperCase();
+    return method === 'GET' || method === 'HEAD' ? method : null;
+}
+function normalizeRemoteRunOperationAction(value) {
+    if (value === 'list' || value === 'get' || value === 'events' || value === 'stop')
+        return value;
+    return null;
+}
+function defaultRemoteRunOperationPath(action, runId) {
+    if (action === 'list')
+        return '/v1/remote-runs';
+    if (!runId)
+        return null;
+    const encoded = encodeURIComponent(runId);
+    if (action === 'get')
+        return `/v1/remote-runs/${encoded}`;
+    if (action === 'events')
+        return `/v1/remote-runs/${encoded}/events`;
+    return `/v1/remote-runs/${encoded}/stop`;
+}
+function remoteRunOperationPath(record, action, runId) {
+    const override = normalizeCliWorkflowOperationPath(record.path);
+    if (!override)
+        return defaultRemoteRunOperationPath(action, runId);
+    const encoded = runId ? encodeURIComponent(runId) : '';
+    const resolved = override
+        .replace(/\{runId\}/g, encoded)
+        .replace(/\{run_id\}/g, encoded);
+    return resolved.includes('{') || resolved.includes('}') ? null : normalizeCliWorkflowOperationPath(resolved);
+}
+function summarizeManifest(result) {
+    const body = readRecord(result.body);
+    const client = readRecord(body.client);
+    const metadata = readRecord(body.metadata);
+    return {
+        ok: result.ok,
+        status: result.status,
+        contentType: result.contentType,
+        error: result.error ? redactCliControlPlaneText(result.error) : undefined,
+        name: readString(body, ['name', 'app', 'serviceName']),
+        service: readString(body, ['service', 'id']),
+        version: readString(body, ['version']),
+        cliVersion: readString(body, ['cliVersion', 'cli_version']),
+        appVersion: readString(body, ['appVersion', 'app_version']),
+        clientName: readString(client, ['name']) || readString(metadata, ['clientName', 'client']),
+        capabilities: readCapabilities(body.capabilities || metadata.capabilities),
+    };
+}
+function summarizeOpenApi(result) {
+    const body = readRecord(result.body);
+    const info = readRecord(body.info);
+    const paths = readRecord(body.paths);
+    return {
+        ok: result.ok,
+        status: result.status,
+        contentType: result.contentType,
+        error: result.error ? redactCliControlPlaneText(result.error) : undefined,
+        title: readString(info, ['title']),
+        version: readString(info, ['version']),
+        operationCount: countOpenApiOperations(paths),
+        paths: Object.keys(paths)
+            .filter(isSafeOpenApiPath)
+            .slice(0, 40),
+    };
+}
+function versionSkewWarning(manifest, openapi) {
+    const manifestVersion = manifest.cliVersion || manifest.appVersion || manifest.version;
+    if (!manifestVersion || !openapi.version || manifestVersion === openapi.version)
+        return undefined;
+    return `CLI manifest version ${manifestVersion} differs from OpenAPI version ${openapi.version}.`;
+}
+export async function inspectCliAppServer(params) {
+    const record = asRecord(params);
+    const endpoint = normalizeLocalCliAppServerEndpoint(record.endpoint);
+    const checkedAt = Date.now();
+    if (!endpoint) {
+        return {
+            success: false,
+            endpoint: null,
+            checkedAt,
+            status: 'blocked',
+            manifest: emptyManifestSummary('CLI app-server endpoint must be a local http(s) origin.'),
+            openapi: emptyOpenApiSummary('CLI app-server endpoint must be a local http(s) origin.'),
+            workflows: deriveCliWorkflowReadiness({}),
+            dashboards: deriveCliProductDashboards(deriveCliWorkflowReadiness({})),
+            error: 'CLI app-server endpoint must be a local http(s) origin.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, endpoint }, {
+        action: 'read',
+        kind: 'tool',
+        id: 'cliControlPlane:inspectAppServer',
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            manifest: emptyManifestSummary('Policy denied.'),
+            openapi: emptyOpenApiSummary('Policy denied.'),
+            workflows: deriveCliWorkflowReadiness({}),
+            dashboards: deriveCliProductDashboards(deriveCliWorkflowReadiness({})),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(15000, Math.floor(record.timeoutMs)))
+        : 5000;
+    const [manifestResult, openapiResult] = await Promise.all([
+        fetchJson(endpoint, '/manifest', timeoutMs),
+        fetchJson(endpoint, '/openapi.json', timeoutMs),
+    ]);
+    const manifest = summarizeManifest(manifestResult);
+    const openapi = summarizeOpenApi(openapiResult);
+    const workflows = deriveCliWorkflowReadiness(readRecord(readRecord(openapiResult.body).paths));
+    const dashboards = deriveCliProductDashboards(workflows);
+    const warning = versionSkewWarning(manifest, openapi);
+    const success = manifest.ok && openapi.ok;
+    const status = success
+        ? (warning ? 'degraded' : 'available')
+        : (manifest.status === 0 && openapi.status === 0 ? 'offline' : 'degraded');
+    return {
+        success,
+        endpoint,
+        checkedAt,
+        status,
+        manifest,
+        openapi,
+        workflows,
+        dashboards,
+        versionSkewWarning: warning,
+        error: success ? undefined : [manifest.error, openapi.error].filter(Boolean).join(' / ') || 'CLI app-server inspection failed.',
+    };
+}
+export async function inspectCliWorkflowOperation(params) {
+    const record = asRecord(params);
+    const endpoint = normalizeLocalCliAppServerEndpoint(record.endpoint);
+    const method = normalizeReadOnlyOperationMethod(record.method);
+    const path = normalizeCliWorkflowOperationPath(record.path);
+    const operationId = readSafeDescriptor(record, ['operationId'], 100);
+    const checkedAt = Date.now();
+    if (!endpoint) {
+        return {
+            success: false,
+            endpoint: null,
+            checkedAt,
+            status: 'blocked',
+            method: method || 'GET',
+            path,
+            operationId,
+            response: emptyOperationResponseSummary('CLI app-server endpoint must be a local http(s) origin.'),
+            error: 'CLI app-server endpoint must be a local http(s) origin.',
+        };
+    }
+    if (!method) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method: 'GET',
+            path,
+            operationId,
+            response: emptyOperationResponseSummary('Only read-only GET/HEAD CLI workflow operations can be inspected.'),
+            error: 'Only read-only GET/HEAD CLI workflow operations can be inspected.',
+        };
+    }
+    if (!path || /[{}]/.test(path)) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method,
+            path: path || null,
+            operationId,
+            response: emptyOperationResponseSummary('CLI workflow operation path must be a safe resolved app-server path.'),
+            error: 'CLI workflow operation path must be a safe resolved app-server path.',
+        };
+    }
+    const policyRecord = { ...record };
+    delete policyRecord.path;
+    const policy = evaluateIpcPolicy({ ...policyRecord, endpoint, operationPath: path, method }, {
+        action: 'read',
+        kind: 'tool',
+        id: `cliControlPlane:inspectWorkflowOperation:${method}:${path.slice(0, 160)}`,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method,
+            path,
+            operationId,
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(15000, Math.floor(record.timeoutMs)))
+        : 5000;
+    const responseResult = await fetchJson(endpoint, path, timeoutMs, method);
+    const response = summarizeOperationResponse(responseResult);
+    const success = response.ok;
+    const status = success ? 'available' : (response.status === 0 ? 'offline' : 'degraded');
+    return {
+        success,
+        endpoint,
+        checkedAt,
+        status,
+        method,
+        path,
+        operationId,
+        response,
+        error: success ? undefined : response.error || 'CLI workflow operation inspection failed.',
+    };
+}
+export async function runCliRemoteRunOperation(params) {
+    const record = asRecord(params);
+    const endpoint = normalizeLocalCliAppServerEndpoint(record.endpoint);
+    const action = normalizeRemoteRunOperationAction(record.action) || 'list';
+    const runId = readSafeDescriptor(record, ['runId', 'id'], 160);
+    const method = action === 'stop' ? 'POST' : 'GET';
+    const path = remoteRunOperationPath(record, action, runId);
+    const checkedAt = Date.now();
+    if (!endpoint) {
+        return {
+            success: false,
+            endpoint: null,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            path,
+            runId,
+            response: emptyOperationResponseSummary('CLI app-server endpoint must be a local http(s) origin.'),
+            error: 'CLI app-server endpoint must be a local http(s) origin.',
+        };
+    }
+    if (!path || (action !== 'list' && !runId)) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            path,
+            runId,
+            response: emptyOperationResponseSummary('Remote run operation requires a safe resolved path and runId.'),
+            error: 'Remote run operation requires a safe resolved path and runId.',
+        };
+    }
+    const tokenEnvKey = normalizeCliAppServerTokenEnvKey(record.tokenEnvKey || record.cliAppServerTokenEnvKey);
+    const token = tokenEnvKey ? process.env[tokenEnvKey]?.trim() : undefined;
+    if (action === 'stop' && !token) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            path,
+            runId,
+            response: emptyOperationResponseSummary('CLI app-server token env reference is required before remote stop.'),
+            error: 'CLI app-server token env reference is required before remote stop.',
+        };
+    }
+    const policyRecord = { ...record };
+    delete policyRecord.path;
+    const policy = evaluateIpcPolicy({ ...policyRecord, endpoint, operationPath: path, method, tokenEnvKey }, {
+        action: action === 'stop' ? 'execute' : 'read',
+        kind: 'tool',
+        id: `cliControlPlane:remoteRun.${action}`,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            path,
+            runId,
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(15000, Math.floor(record.timeoutMs)))
+        : 5000;
+    const response = summarizeOperationResponse(await fetchJson(endpoint, path, timeoutMs, method, token));
+    const success = response.ok;
+    const status = success ? 'available' : (response.status === 0 ? 'offline' : response.status === 401 || response.status === 403 ? 'blocked' : 'degraded');
+    if (action === 'events' && runId) {
+        appendCliRemoteRuntimeEvent(getRuntimeEventStore(), record, {
+            id: `${runId}:remote-events-attached`,
+            type: 'remote.run.events.attached',
+            method: 'remoteRun.events',
+            status,
+            runId,
+            ...(typeof response.itemCount === 'number' ? { eventCount: response.itemCount } : {}),
+        });
+    }
+    if (action === 'stop' && runId) {
+        appendCliRemoteRuntimeEvent(getRuntimeEventStore(), record, {
+            id: `${runId}:remote-stop`,
+            type: success ? 'turn.cancelled' : 'turn.failed',
+            method: 'remoteRun.stop',
+            status,
+            runId,
+            ...(response.error ? { error: response.error } : {}),
+        });
+    }
+    return {
+        success,
+        endpoint,
+        checkedAt,
+        status,
+        action,
+        method,
+        path,
+        runId,
+        response,
+        error: success ? undefined : response.error || 'CLI remote run operation failed.',
+    };
+}
+function normalizeShareReplayOperationAction(value) {
+    return value === 'export' || value === 'inspect' ? value : null;
+}
+function normalizeEvalOperationAction(value) {
+    return value === 'list' || value === 'inspect' || value === 'run' || value === 'compare' ? value : null;
+}
+function normalizeOrgMetadataOperationAction(value) {
+    if (value === 'knowledge' || value === 'playbooks' || value === 'secrets' || value === 'serviceUsers')
+        return value;
+    if (value === 'service-users' || value === 'service_users')
+        return 'serviceUsers';
+    return null;
+}
+function normalizeMcpAuthOperationAction(value) {
+    if (value === 'status' || value === 'login' || value === 'logout')
+        return value;
+    return null;
+}
+function normalizeGithubAppOperationAction(value) {
+    if (value === 'plan' || value === 'verify' || value === 'mapWebhook')
+        return value;
+    if (value === 'map-webhook' || value === 'map_webhook')
+        return 'mapWebhook';
+    return null;
+}
+function orgMetadataOperationMethod(action) {
+    if (action === 'playbooks')
+        return 'xeno org playbooks list';
+    if (action === 'secrets')
+        return 'xeno org secrets list';
+    if (action === 'serviceUsers')
+        return 'xeno org service-users list';
+    return 'xeno org knowledge list';
+}
+function githubAppOperationMethod(action) {
+    if (action === 'verify')
+        return 'xeno github app verify';
+    if (action === 'mapWebhook')
+        return 'xeno github app map-webhook';
+    return 'xeno github app plan';
+}
+function mcpAuthOperationMethod(action) {
+    if (action === 'login')
+        return 'xeno mcp login';
+    if (action === 'logout')
+        return 'xeno mcp logout';
+    return 'xeno mcp auth status';
+}
+function orgMetadataOperationArgs(action) {
+    if (action === 'playbooks')
+        return ['org', 'playbooks', 'list', '--json'];
+    if (action === 'secrets')
+        return ['org', 'secrets', 'list', '--json'];
+    if (action === 'serviceUsers')
+        return ['org', 'service-users', 'list', '--json'];
+    return ['org', 'knowledge', 'list', '--json'];
+}
+function evalOperationMethod(action) {
+    if (action === 'inspect')
+        return 'xeno eval inspect';
+    if (action === 'run')
+        return 'xeno eval run';
+    if (action === 'compare')
+        return 'xeno eval compare';
+    return 'xeno eval list';
+}
+function buildEvalOperationArgs(record, action) {
+    const suite = readSafePathArgument(record, ['suite', 'suiteId', 'id'], 400);
+    const reportPath = readSafePathArgument(record, ['reportPath', 'report']);
+    const before = readSafePathArgument(record, ['before', 'runA', 'baseline']);
+    const after = readSafePathArgument(record, ['after', 'runB', 'candidate']);
+    if (action === 'list')
+        return { args: ['eval', 'list', '--json'] };
+    if (action === 'inspect') {
+        return suite
+            ? { args: ['eval', 'inspect', suite, '--json'], suite, targetPath: suite }
+            : { args: null, error: 'Eval inspect requires a suite reference.' };
+    }
+    if (action === 'run') {
+        if (!suite)
+            return { args: null, error: 'Eval run requires a suite reference.' };
+        const args = ['eval', 'run', suite, '--json'];
+        if (reportPath)
+            args.push('--report', reportPath);
+        if (record.allowFailures === true)
+            args.push('--allow-failures');
+        return { args, suite, targetPath: reportPath || suite };
+    }
+    if (!before || !after)
+        return { args: null, error: 'Eval compare requires before and after report references.' };
+    return { args: ['eval', 'compare', before, after, '--json'], targetPath: before };
+}
+function buildMcpAuthOperationArgs(record, action) {
+    const server = readSafeDescriptor(record, ['server', 'serverName', 'name'], 160);
+    const tokenEnvProvided = ['tokenEnv', 'tokenEnvKey', 'bearerTokenEnv'].some((key) => {
+        const value = record[key];
+        return typeof value === 'string' && Boolean(value.trim());
+    });
+    const tokenEnv = normalizeCliAppServerTokenEnvKey(record.tokenEnv || record.tokenEnvKey || record.bearerTokenEnv);
+    if (tokenEnvProvided && !tokenEnv)
+        return { args: null, server, error: 'MCP token env reference must be a safe environment variable name.' };
+    if (action === 'status')
+        return { args: ['mcp', 'auth', 'status', '--json'] };
+    if (!server)
+        return { args: null, error: `MCP auth ${action} requires a server name.` };
+    if (action === 'logout')
+        return { args: ['mcp', 'logout', server, '--json'], server };
+    const args = ['mcp', 'login', server, '--json'];
+    if (tokenEnv)
+        args.push('--token-env', tokenEnv);
+    if (record.noBrowser !== false)
+        args.push('--no-browser');
+    return { args, server };
+}
+function buildGithubAppOperationArgs(record, action) {
+    const fixturePath = readSafePathArgument(record, ['fixturePath', 'fixture', 'path']);
+    const backendUrl = readSafeHttpUrlArgument(record, ['backendUrl', 'backend']);
+    if (backendUrl.error)
+        return { args: null, fixturePath, error: backendUrl.error };
+    const appendBackendUrl = (args) => {
+        if (backendUrl.value)
+            args.push('--backend-url', backendUrl.value);
+        return args;
+    };
+    if (action === 'plan')
+        return { args: appendBackendUrl(['github', 'app', 'plan', '--json']), backendUrl: backendUrl.value };
+    if (action === 'verify') {
+        const args = ['github', 'app', 'verify', '--json'];
+        if (fixturePath)
+            args.push('--fixture', fixturePath);
+        return { args: appendBackendUrl(args), fixturePath, backendUrl: backendUrl.value, targetPath: fixturePath };
+    }
+    if (!fixturePath) {
+        return { args: null, error: 'GitHub app webhook mapping requires a fixture path.' };
+    }
+    return {
+        args: ['github', 'app', 'map-webhook', fixturePath, '--json'],
+        fixturePath,
+        targetPath: fixturePath,
+    };
+}
+export async function runCliEvalOperation(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const action = normalizeEvalOperationAction(record.action) || 'list';
+    const method = evalOperationMethod(action);
+    const cwd = readCliRemoteCwd(record);
+    const built = buildEvalOperationArgs(record, action);
+    if (!built.args) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            suite: built.suite,
+            pathLabel: safePathLabel(built.targetPath),
+            response: emptyOperationResponseSummary(built.error || 'CLI eval operation is incomplete.'),
+            error: built.error || 'CLI eval operation is incomplete.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, cwd, path: built.targetPath }, {
+        action: action === 'run' ? 'execute' : 'read',
+        kind: 'tool',
+        id: `cliControlPlane:eval.${action}`,
+        path: built.targetPath,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            suite: built.suite,
+            pathLabel: safePathLabel(built.targetPath),
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(300_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const activeRun = { cancelled: false };
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(built.args, { cwd, timeoutMs, activeRun });
+        const { body, response } = summarizeCliJsonCommandResult(result);
+        const commandError = body ? readSafeDescriptor(body, ['error'], 400) : undefined;
+        const success = result.exitCode === 0 && response.ok;
+        return {
+            success,
+            checkedAt,
+            status: success ? 'available' : (result.exitCode === null ? 'offline' : 'degraded'),
+            action,
+            method,
+            suite: built.suite,
+            pathLabel: safePathLabel(built.targetPath),
+            response,
+            error: success ? undefined : commandError || response.error || 'CLI eval operation failed.',
+        };
+    }
+    catch (error) {
+        const message = redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI eval operation failed.', 400);
+        return {
+            success: false,
+            checkedAt,
+            status: 'offline',
+            action,
+            method,
+            suite: built.suite,
+            pathLabel: safePathLabel(built.targetPath),
+            response: emptyOperationResponseSummary(message),
+            error: message,
+        };
+    }
+}
+export async function runCliOrgMetadataOperation(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const action = normalizeOrgMetadataOperationAction(record.action) || 'knowledge';
+    const method = orgMetadataOperationMethod(action);
+    const cwd = readCliRemoteCwd(record);
+    const policy = evaluateIpcPolicy({ ...record, cwd, path: cwd }, {
+        action: 'read',
+        kind: 'tool',
+        id: `cliControlPlane:orgMetadata.${action}`,
+        path: cwd,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            workspaceLabel: safePathLabel(cwd),
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(120_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const activeRun = { cancelled: false };
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(orgMetadataOperationArgs(action), { cwd, timeoutMs, activeRun });
+        const { body, response } = summarizeCliJsonCommandResult(result);
+        const commandError = body ? readSafeDescriptor(body, ['error'], 400) : undefined;
+        const success = result.exitCode === 0 && response.ok;
+        return {
+            success,
+            checkedAt,
+            status: success ? 'available' : (result.exitCode === null ? 'offline' : 'degraded'),
+            action,
+            method,
+            workspaceLabel: safePathLabel(cwd),
+            response,
+            error: success ? undefined : commandError || response.error || 'CLI org metadata operation failed.',
+        };
+    }
+    catch (error) {
+        const message = redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI org metadata operation failed.', 400);
+        return {
+            success: false,
+            checkedAt,
+            status: 'offline',
+            action,
+            method,
+            workspaceLabel: safePathLabel(cwd),
+            response: emptyOperationResponseSummary(message),
+            error: message,
+        };
+    }
+}
+export async function runCliMcpAuthOperation(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const action = normalizeMcpAuthOperationAction(record.action) || 'status';
+    const method = mcpAuthOperationMethod(action);
+    const cwd = readCliRemoteCwd(record);
+    const built = buildMcpAuthOperationArgs(record, action);
+    if (!built.args) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            server: built.server,
+            response: emptyOperationResponseSummary(built.error || 'CLI MCP auth operation is incomplete.'),
+            error: built.error || 'CLI MCP auth operation is incomplete.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, cwd, path: cwd }, {
+        action: action === 'status' ? 'read' : 'execute',
+        kind: 'tool',
+        id: `cliControlPlane:mcpAuth.${action}`,
+        path: cwd,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            server: built.server,
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(120_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const activeRun = { cancelled: false };
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(built.args, { cwd, timeoutMs, activeRun });
+        const { body, response } = summarizeCliJsonCommandResult(result);
+        const commandError = body ? readSafeDescriptor(body, ['error'], 400) : undefined;
+        const success = result.exitCode === 0 && response.ok;
+        return {
+            success,
+            checkedAt,
+            status: success ? 'available' : (result.exitCode === null ? 'offline' : 'degraded'),
+            action,
+            method,
+            server: built.server,
+            response,
+            error: success ? undefined : commandError || response.error || 'CLI MCP auth operation failed.',
+        };
+    }
+    catch (error) {
+        const message = redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI MCP auth operation failed.', 400);
+        return {
+            success: false,
+            checkedAt,
+            status: 'offline',
+            action,
+            method,
+            server: built.server,
+            response: emptyOperationResponseSummary(message),
+            error: message,
+        };
+    }
+}
+export async function runCliGithubAppOperation(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const action = normalizeGithubAppOperationAction(record.action) || 'plan';
+    const method = githubAppOperationMethod(action);
+    const cwd = readCliRemoteCwd(record);
+    const built = buildGithubAppOperationArgs(record, action);
+    const targetPath = built.targetPath || cwd;
+    if (!built.args) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            fixtureLabel: safePathLabel(built.fixturePath),
+            backendUrl: built.backendUrl,
+            response: emptyOperationResponseSummary(built.error || 'CLI GitHub app operation is incomplete.'),
+            error: built.error || 'CLI GitHub app operation is incomplete.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, cwd, path: targetPath }, {
+        action: 'read',
+        kind: 'tool',
+        id: `cliControlPlane:githubApp.${action}`,
+        path: targetPath,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            fixtureLabel: safePathLabel(built.fixturePath),
+            backendUrl: built.backendUrl,
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(120_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const activeRun = { cancelled: false };
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(built.args, { cwd, timeoutMs, activeRun });
+        const { body, response } = summarizeCliJsonCommandResult(result);
+        const commandError = body ? readSafeDescriptor(body, ['error'], 400) : undefined;
+        const success = result.exitCode === 0 && response.ok;
+        return {
+            success,
+            checkedAt,
+            status: success ? 'available' : (result.exitCode === null ? 'offline' : 'degraded'),
+            action,
+            method,
+            fixtureLabel: safePathLabel(built.fixturePath),
+            backendUrl: built.backendUrl,
+            response,
+            error: success ? undefined : commandError || response.error || 'CLI GitHub app operation failed.',
+        };
+    }
+    catch (error) {
+        const message = redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI GitHub app operation failed.', 400);
+        return {
+            success: false,
+            checkedAt,
+            status: 'offline',
+            action,
+            method,
+            fixtureLabel: safePathLabel(built.fixturePath),
+            backendUrl: built.backendUrl,
+            response: emptyOperationResponseSummary(message),
+            error: message,
+        };
+    }
+}
+export async function runCliShareReplayOperation(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const action = normalizeShareReplayOperationAction(record.action) || 'inspect';
+    const method = action === 'export' ? 'xeno share export' : 'xeno share inspect';
+    const cwd = readCliRemoteCwd(record);
+    const sourceId = readSafeDescriptor(record, ['sourceId', 'runId', 'sessionId', 'id'], 180);
+    const bundlePath = readSafePathArgument(record, ['bundlePath', 'path']);
+    const outputPath = readSafePathArgument(record, ['outputPath', 'out']);
+    const targetPath = action === 'export' ? outputPath : bundlePath;
+    if (action === 'export' && (!sourceId || !outputPath)) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            sourceId,
+            pathLabel: safePathLabel(outputPath),
+            response: emptyOperationResponseSummary('Share export requires a source id and output path.'),
+            error: 'Share export requires a source id and output path.',
+        };
+    }
+    if (action === 'inspect' && !bundlePath) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            pathLabel: safePathLabel(bundlePath),
+            response: emptyOperationResponseSummary('Share inspect requires a bundle path.'),
+            error: 'Share inspect requires a bundle path.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, cwd, path: targetPath }, {
+        action: action === 'export' ? 'execute' : 'read',
+        kind: 'tool',
+        id: `cliControlPlane:shareReplay.${action}`,
+        path: targetPath,
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            action,
+            method,
+            sourceId,
+            pathLabel: safePathLabel(targetPath),
+            response: emptyOperationResponseSummary('Policy denied.'),
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(120_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const args = action === 'export'
+        ? ['share', 'export', sourceId, '--out', outputPath, '--json']
+        : ['share', 'inspect', bundlePath, '--json'];
+    const activeRun = { cancelled: false };
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(args, { cwd, timeoutMs, activeRun });
+        const { body, response } = summarizeCliJsonCommandResult(result);
+        const commandError = body ? readSafeDescriptor(body, ['error'], 400) : undefined;
+        const success = result.exitCode === 0 && response.ok;
+        return {
+            success,
+            checkedAt,
+            status: success ? 'available' : (result.exitCode === null ? 'offline' : 'degraded'),
+            action,
+            method,
+            sourceId,
+            pathLabel: safePathLabel(targetPath),
+            response,
+            error: success ? undefined : commandError || response.error || 'CLI share/replay operation failed.',
+        };
+    }
+    catch (error) {
+        const message = redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI share/replay operation failed.', 400);
+        return {
+            success: false,
+            checkedAt,
+            status: 'offline',
+            action,
+            method,
+            sourceId,
+            pathLabel: safePathLabel(targetPath),
+            response: emptyOperationResponseSummary(message),
+            error: message,
+        };
+    }
+}
+/**
+ * The permission modes `xeno run` accepts on its command line. Narrower than the
+ * hosted API's enum (no `plan`, no `dontAsk`) — the CLI exits(1) on anything
+ * else, so an unrecognised value must be rejected here rather than turned into
+ * argv, and must NOT be silently dropped: a dropped permission field is
+ * indistinguishable from a deliberate default.
+ */
+const CLI_RUN_PERMISSION_MODES = new Set(['default', 'auto', 'acceptEdits', 'bypassPermissions']);
+export async function runCliRemoteTurn(params, options = {}) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const requestId = readSafeDescriptor(record, ['requestId'], 100) || `hub-remote-run-${checkedAt}`;
+    const prompt = typeof record.prompt === 'string' ? record.prompt.trim().slice(0, 200_000) : '';
+    const remoteBackendId = readSafeDescriptor(record, ['remoteBackendId', 'providerId'], 200);
+    const cwd = readCliRemoteCwd(record);
+    const runtimeStore = options.runtimeStore || getRuntimeEventStore();
+    if (!remoteBackendId) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            method: 'xeno run --remote',
+            requestId,
+            error: 'CLI remote backend reference is required.',
+        };
+    }
+    if (!prompt) {
+        return {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            method: 'xeno run --remote',
+            requestId,
+            error: 'CLI remote prompt is required.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, cwd }, {
+        action: 'execute',
+        kind: 'tool',
+        id: 'cliControlPlane:xeno.run.remote',
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            status: 'blocked',
+            method: 'xeno run --remote',
+            requestId,
+        });
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(300_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const args = ['run', prompt, '--remote', '--json'];
+    const model = readSafeDescriptor(record, ['model'], 160);
+    if (model)
+        args.push('--model', model);
+    const title = readSafeDescriptor(record, ['title'], 180);
+    if (title)
+        args.push('--title', title);
+    // This argv list is an ALLOW-LIST: a flag not pushed here cannot reach the
+    // CLI. `--permission-mode` was never pushed, so every remote turn ran under
+    // the CLI's own `default` — and the hosted server now REFUSES Write/Edit
+    // under `default`. Forward the caller's mode so a read-only run is a choice.
+    const permissionMode = readSafeDescriptor(record, ['permissionMode'], 40);
+    if (permissionMode) {
+        if (!CLI_RUN_PERMISSION_MODES.has(permissionMode)) {
+            return {
+                success: false,
+                checkedAt,
+                status: 'blocked',
+                method: 'xeno run --remote',
+                requestId,
+                error: `Unsupported permissionMode for xeno run --remote: ${permissionMode}. Expected one of ${[...CLI_RUN_PERMISSION_MODES].join(', ')}.`,
+            };
+        }
+        args.push('--permission-mode', permissionMode);
+    }
+    const activeRun = { cancelled: false };
+    activeCliRemoteRuns.set(requestId, activeRun);
+    appendCliRemoteRuntimeEvent(runtimeStore, record, {
+        id: `${requestId}:cli-remote-started`,
+        type: 'turn.started',
+        model: model || 'xeno-agent-cli',
+        method: 'xeno run --remote',
+        providerKind: 'cli-remote',
+        providerId: remoteBackendId,
+    });
+    try {
+        const result = await (options.commandRunner || runXenoCliCommand)(args, { cwd, timeoutMs, activeRun });
+        const report = parseCliRemoteReport(result.stdout);
+        const run = readRecord(report?.run);
+        const runId = readSafeDescriptor(run, ['runId', 'id'], 160);
+        const error = report
+            ? readSafeDescriptor(report, ['error'], 400) || (result.exitCode === 0 ? undefined : `xeno run --remote exited with ${result.exitCode}.`)
+            : redactCliControlPlaneText(result.stderr || 'xeno run --remote did not return JSON.', 400);
+        const status = cliRemoteStatus(report, result.exitCode, activeRun.cancelled);
+        const text = report?.ok === true ? remoteRunStartedText(runId) : undefined;
+        if (text) {
+            appendCliRemoteRuntimeEvent(runtimeStore, record, {
+                id: `${requestId}:cli-remote-text`,
+                type: 'model.text.delta',
+                text,
+                delta: text,
+                method: 'xeno run --remote',
+                providerKind: 'cli-remote',
+                providerId: remoteBackendId,
+                ...(runId ? { runId } : {}),
+            });
+        }
+        appendCliRemoteRuntimeEvent(runtimeStore, record, {
+            id: `${requestId}:cli-remote-terminal`,
+            type: status === 'cancelled' ? 'turn.cancelled' : report?.ok === true ? 'turn.completed' : 'turn.failed',
+            method: 'xeno run --remote',
+            status,
+            providerKind: 'cli-remote',
+            providerId: remoteBackendId,
+            ...(runId ? { runId } : {}),
+            ...(error && report?.ok !== true ? { error: redactCliControlPlaneText(error, 400) } : {}),
+        });
+        return {
+            success: report?.ok === true && status === 'available',
+            checkedAt,
+            status,
+            method: 'xeno run --remote',
+            requestId,
+            ...(runId ? { runId } : {}),
+            ...(text ? { text } : {}),
+            ...(status === 'cancelled' ? { cancelled: true } : {}),
+            ...(error && report?.ok !== true ? { error: redactCliControlPlaneText(error, 400) } : {}),
+        };
+    }
+    catch (error) {
+        const wasCancelled = activeRun.cancelled;
+        const redactedError = wasCancelled
+            ? 'CLI remote run cancelled.'
+            : redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI remote run failed.', 400);
+        appendCliRemoteRuntimeEvent(runtimeStore, record, {
+            id: `${requestId}:cli-remote-terminal`,
+            type: wasCancelled ? 'turn.cancelled' : 'turn.failed',
+            method: 'xeno run --remote',
+            status: wasCancelled ? 'cancelled' : 'offline',
+            providerKind: 'cli-remote',
+            providerId: remoteBackendId,
+            ...(wasCancelled ? { reason: redactedError } : { error: redactedError }),
+        });
+        return {
+            success: false,
+            checkedAt,
+            status: wasCancelled ? 'cancelled' : 'offline',
+            method: 'xeno run --remote',
+            requestId,
+            ...(wasCancelled ? { cancelled: true } : {}),
+            error: redactedError,
+        };
+    }
+    finally {
+        if (activeCliRemoteRuns.get(requestId) === activeRun)
+            activeCliRemoteRuns.delete(requestId);
+    }
+}
+export async function runCliAppServerThread(params, options = {}) {
+    const record = asRecord(params);
+    const endpoint = normalizeLocalCliAppServerEndpoint(record.endpoint);
+    const tokenEnvKey = normalizeCliAppServerTokenEnvKey(record.tokenEnvKey || record.cliAppServerTokenEnvKey);
+    const prompt = typeof record.prompt === 'string' ? record.prompt.trim().slice(0, 200_000) : '';
+    const checkedAt = Date.now();
+    const requestId = readSafeDescriptor(record, ['requestId'], 100) || `hub-thread-run-${checkedAt}`;
+    const runtimeStore = options.runtimeStore || getRuntimeEventStore();
+    if (!endpoint) {
+        return {
+            success: false,
+            endpoint: null,
+            checkedAt,
+            status: 'blocked',
+            method: 'thread.run',
+            messageCount: 0,
+            error: 'CLI app-server endpoint must be a local http(s) origin.',
+        };
+    }
+    if (!tokenEnvKey) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method: 'thread.run',
+            messageCount: 0,
+            error: 'CLI app-server token env reference is required before /rpc execution.',
+        };
+    }
+    if (!prompt) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method: 'thread.run',
+            messageCount: 0,
+            error: 'CLI app-server thread.run prompt is required.',
+        };
+    }
+    const policy = evaluateIpcPolicy({ ...record, endpoint, tokenEnvKey }, {
+        action: 'execute',
+        kind: 'tool',
+        id: 'cliControlPlane:thread.run',
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method: 'thread.run',
+            messageCount: 0,
+        });
+    }
+    const token = process.env[tokenEnvKey]?.trim();
+    if (!token) {
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: 'blocked',
+            method: 'thread.run',
+            messageCount: 0,
+            error: `CLI app-server bearer token is unavailable in env ref ${tokenEnvKey}.`,
+        };
+    }
+    const timeoutMs = typeof record.timeoutMs === 'number' && Number.isFinite(record.timeoutMs)
+        ? Math.max(1000, Math.min(300_000, Math.floor(record.timeoutMs)))
+        : 60_000;
+    const activeRun = { controller: new AbortController(), cancelled: false };
+    activeCliThreadRuns.set(requestId, activeRun);
+    const timeout = setTimeout(() => activeRun.controller.abort(), timeoutMs);
+    appendCliThreadRuntimeEvent(runtimeStore, record, {
+        id: `${requestId}:cli-thread-started`,
+        type: 'turn.started',
+        model: 'xeno-agent-cli',
+        method: 'thread.run',
+        providerKind: 'cli-app-server',
+        endpoint,
+    });
+    try {
+        const response = await fetch(`${endpoint}/rpc`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'content-type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: requestId,
+                method: 'thread.run',
+                params: { prompt },
+            }),
+            signal: activeRun.controller.signal,
+        });
+        const text = await response.text();
+        const body = text ? JSON.parse(text) : {};
+        const bodyRecord = readRecord(body);
+        const messages = Array.isArray(bodyRecord.messages) ? bodyRecord.messages : [];
+        const responseText = readThreadRunText(messages, bodyRecord);
+        const rpcError = messages
+            .map((message) => readRecord(message).error)
+            .find(Boolean);
+        const error = !response.ok
+            ? readString(bodyRecord, ['error'], 220) || `HTTP ${response.status}`
+            : rpcError
+                ? redactCliControlPlaneText(JSON.stringify(rpcError), 220)
+                : undefined;
+        if (responseText) {
+            appendCliThreadRuntimeEvent(runtimeStore, record, {
+                id: `${requestId}:cli-thread-text`,
+                type: 'model.text.delta',
+                text: responseText,
+                delta: responseText,
+                method: 'thread.run',
+            });
+        }
+        appendCliThreadRuntimeEvent(runtimeStore, record, {
+            id: `${requestId}:cli-thread-terminal`,
+            type: error ? 'turn.failed' : 'turn.completed',
+            method: 'thread.run',
+            status: response.ok ? (error ? 'degraded' : 'available') : (response.status === 401 ? 'blocked' : 'degraded'),
+            messageCount: messages.length,
+            ...(error ? { error } : {}),
+        });
+        return {
+            success: response.ok && !error,
+            endpoint,
+            checkedAt,
+            status: response.ok ? (error ? 'degraded' : 'available') : (response.status === 401 ? 'blocked' : 'degraded'),
+            method: 'thread.run',
+            messageCount: messages.length,
+            ...(responseText ? { text: responseText } : {}),
+            messages,
+            ...(error ? { error } : {}),
+        };
+    }
+    catch (error) {
+        const wasCancelled = activeRun.cancelled;
+        const redactedError = wasCancelled
+            ? 'CLI app-server thread.run cancelled.'
+            : redactCliControlPlaneText(error instanceof Error ? error.message : 'CLI app-server thread.run failed.');
+        appendCliThreadRuntimeEvent(runtimeStore, record, {
+            id: `${requestId}:cli-thread-terminal`,
+            type: wasCancelled ? 'turn.cancelled' : 'turn.failed',
+            method: 'thread.run',
+            status: wasCancelled ? 'cancelled' : 'offline',
+            ...(wasCancelled ? { reason: redactedError } : { error: redactedError }),
+        });
+        return {
+            success: false,
+            endpoint,
+            checkedAt,
+            status: wasCancelled ? 'cancelled' : 'offline',
+            method: 'thread.run',
+            messageCount: 0,
+            ...(wasCancelled ? { cancelled: true } : {}),
+            error: redactedError,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        if (activeCliThreadRuns.get(requestId) === activeRun)
+            activeCliThreadRuns.delete(requestId);
+    }
+}
+export async function cancelCliAppServerThread(params) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const requestId = readSafeDescriptor(record, ['requestId'], 100);
+    if (!requestId) {
+        return { success: false, checkedAt, requestId: null, cancelled: false, error: 'CLI app-server requestId is required.' };
+    }
+    const policy = evaluateIpcPolicy(record, {
+        action: 'execute',
+        kind: 'tool',
+        id: 'cliControlPlane:thread.cancel',
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            requestId,
+            cancelled: false,
+        });
+    }
+    const activeRun = activeCliThreadRuns.get(requestId);
+    if (!activeRun) {
+        return { success: false, checkedAt, requestId, cancelled: false, error: 'No active CLI app-server thread.run found for requestId.' };
+    }
+    activeRun.cancelled = true;
+    activeRun.controller.abort();
+    return { success: true, checkedAt, requestId, cancelled: true };
+}
+export async function cancelCliRemoteTurn(params) {
+    const record = asRecord(params);
+    const checkedAt = Date.now();
+    const requestId = readSafeDescriptor(record, ['requestId'], 100);
+    if (!requestId) {
+        return { success: false, checkedAt, requestId: null, cancelled: false, error: 'CLI remote requestId is required.' };
+    }
+    const policy = evaluateIpcPolicy(record, {
+        action: 'execute',
+        kind: 'tool',
+        id: 'cliControlPlane:remote.cancel',
+    });
+    if (!policy.allowed) {
+        return denyWithPolicy(policy, {
+            success: false,
+            checkedAt,
+            requestId,
+            cancelled: false,
+        });
+    }
+    const activeRun = activeCliRemoteRuns.get(requestId);
+    if (!activeRun) {
+        return { success: false, checkedAt, requestId, cancelled: false, error: 'No active CLI remote run found for requestId.' };
+    }
+    activeRun.cancelled = true;
+    activeRun.child?.kill();
+    return { success: true, checkedAt, requestId, cancelled: true };
+}
+//# sourceMappingURL=CliControlPlaneService.js.map