maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.8.20260830

package/node_modules/@maka/runtime/dist/sandbox/sandbox-manager.js

@@ -128,41 +128,6 @@ export class SandboxManager {
             return false;
         return backend.canEnforceProfile?.(input.profile) ?? true;
     }
-    probe(request) {
-        const selected = this.selectInitial({
-            profile: request.command.profile,
-            preference: request.preference,
-            platform: request.platform,
-        });
-        if (!selected.ok)
-            return selected;
-        if (selected.sandboxType === 'none') {
-            return {
-                ok: true,
-                executable: request.command.program,
-                sandboxType: 'none',
-                requiresSandbox: false,
-                preference: selected.preference,
-            };
-        }
-        const backend = this.backends.get(selected.sandboxType);
-        if (!backend) {
-            return {
-                ok: false,
-                reason: 'backend_not_available',
-                sandboxType: selected.sandboxType,
-                requiresSandbox: selected.requiresSandbox,
-                platform: selected.platform,
-                preference: selected.preference,
-                message: `Sandbox backend ${selected.sandboxType} is not registered.`,
-            };
-        }
-        return backend.probe({
-            ...request,
-            preference: selected.preference,
-            platform: selected.platform,
-        });
-    }
     transform(request) {
         const selected = this.selectInitial({
             profile: request.command.profile,

package/node_modules/@maka/runtime/dist/sandbox/windows-sandbox.js

@@ -70,18 +70,6 @@ export class WindowsBrokerSandboxBackend {
             profile.fileSystem.kind === 'restricted' &&
             profile.network.kind === 'restricted');
     }
-    probe(request) {
-        const plan = this.plan(request);
-        if (!plan.ok)
-            return plan;
-        return {
-            ok: true,
-            executable: this.options.clientPath,
-            sandboxType: 'windows',
-            requiresSandbox: true,
-            preference: plan.preference,
-        };
-    }
     transform(request) {
         const plan = this.plan(request);
         if (!plan.ok)

package/node_modules/@maka/runtime/dist/shell-detect.js

@@ -26,9 +26,9 @@
 // the model is trapped writing `dir /s /b` style commands. This module detects
 // a better shell (pwsh > powershell > cmd) and carries the result to the two
 // places that need it: the spawn call (shell-exec / shell-run-manager) and the
-// prompt surfaces that must DECLARE the dialect to the model (tool description,
-// session environment fragment). Selection without declaration — or the other
-// way round — makes the model guess the dialect, which is the original bug.
+// Bash tool description that declares the dialect to the model. Selection
+// without declaration — or the other way round — makes the model guess the
+// dialect, which is the original bug.
 import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { win32 } from 'node:path';
@@ -87,10 +87,6 @@ export function throwIfShellSetupFailed(shell) {
     if (shell.setupError)
         throw shell.setupError;
 }
-/** Model-facing shell name; a broken preference is declared, not silently hidden. */
-export function turnShellDisplayName(shell) {
-    return shell.setupError ? `Unavailable (${shell.setupError.message})` : shell.plan.displayName;
-}
 /** Rejects a persisted override unless the Host can execute it as GNU Bash. */
 export async function validateShellPreference(settings, input = {}) {
     const plan = resolveShellPlan(settings, input);

package/node_modules/@maka/runtime/dist/shell-run-contract.js

@@ -32,7 +32,6 @@ export const DEFAULT_MAX_LIVE_PTY_RUNS = 8;
 export const DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS = 1_000;
 export const DEFAULT_SHELL_RUN_FLUSH_BYTES = 64 * 1024;
 export const DEFAULT_PIPE_OUTPUT_DRAIN_MS = 2_000;
-export const SHELL_RUN_CONTEXT_SUMMARY_LIMIT = 8;
 export const SHELL_RUN_RESOURCE_PREFIX = 'maka://runtime/background-tasks';
 export const MAX_SHELL_RUN_RESOURCE_REF_CHARS = SHELL_RUN_RESOURCE_PREFIX.length + 1 + SHELL_RUN_ID_MAX_CHARS;
 export { isWellFormedTerminalInput };

package/node_modules/@maka/runtime/dist/shell-run-manager.js

@@ -30,7 +30,7 @@ import { PipeTailCollector } from './pipe-tail-collector.js';
 import { PtyProcessDriver } from './pty-process-driver.js';
 import { PTY_INITIAL_COLS, PTY_INITIAL_ROWS, PtyScreenCollector, } from './pty-screen-collector.js';
 import { loadPtyStack } from './pty-stack.js';
-import { DEFAULT_BASH_TIMEOUT_MS, DEFAULT_MAX_LIVE_PTY_RUNS, DEFAULT_MAX_LIVE_SHELL_RUNS, DEFAULT_PIPE_OUTPUT_DRAIN_MS, DEFAULT_SHELL_RUN_FLUSH_BYTES, DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS, MAX_FOREGROUND_BASH_TIMEOUT_MS, MAX_SHELL_RUN_TIMEOUT_MS, SHELL_RUN_CONTEXT_SUMMARY_LIMIT, ShellRunPtyControlClosedError, parseShellRunResourceRef, shellRunResourceRef, validateWriteStdinInput, } from './shell-run-contract.js';
+import { DEFAULT_BASH_TIMEOUT_MS, DEFAULT_MAX_LIVE_PTY_RUNS, DEFAULT_MAX_LIVE_SHELL_RUNS, DEFAULT_PIPE_OUTPUT_DRAIN_MS, DEFAULT_SHELL_RUN_FLUSH_BYTES, DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS, MAX_FOREGROUND_BASH_TIMEOUT_MS, MAX_SHELL_RUN_TIMEOUT_MS, ShellRunPtyControlClosedError, parseShellRunResourceRef, shellRunResourceRef, validateWriteStdinInput, } from './shell-run-contract.js';
 import { compactShellRunContent, ptyControlOperation, shellRunContent, shellRunUpdate, terminalContent, } from './shell-run-tool-result.js';
 import { CompletionLatch } from './completion-latch.js';
 import { closeChildFdSources } from './child-fd-input.js';
@@ -404,30 +404,6 @@ export class ShellRunProcessManager {
         const record = await this.markObserved(await live.finished.join());
         return shellRunContent(record, { kind: 'stop', applied });
     }
-    async buildContextSummary(sessionId) {
-        const records = (await this.actionableRecords(sessionId)).filter((record) => record.visibility !== 'user');
-        if (records.length === 0)
-            return undefined;
-        const visible = records.slice(0, SHELL_RUN_CONTEXT_SUMMARY_LIMIT);
-        const lines = [
-            'Background tasks for this session:',
-            ...visible.map((record) => {
-                const completed = record.completedAt !== undefined ? ` completedAt=${record.completedAt}` : '';
-                return `- ref=${shellRunResourceRef(record.shellRunId)} mode=${record.output.mode} status=${record.status} cwd=${record.cwd} updatedAt=${record.updatedAt}${completed} command=${JSON.stringify(record.command)}`;
-            }),
-        ];
-        const overflow = records.length - visible.length;
-        if (overflow > 0)
-            lines.push(`- ${overflow} more background task(s) not shown in this turn tail.`);
-        const hasControllablePty = records.some((record) => {
-            const live = this.liveResource(sessionId, record.shellRunId);
-            return live?.mode === 'pty' && isPtyControlOpen(live);
-        });
-        lines.push(hasControllablePty
-            ? 'Use Read on a ref for its bounded output snapshot; use WriteStdin to control a running PTY task.'
-            : 'Use Read on a ref for its bounded output snapshot.');
-        return lines.join('\n');
-    }
     async listSessionUpdates(sessionId) {
         const records = await this.input.store.listSessionShellRuns(sessionId);
         return records.map(shellRunUpdate);
@@ -1483,13 +1459,6 @@ export class ShellRunProcessManager {
             return this.input.store.updateShellRun(current.sessionId, current.shellRunId, buildPatch());
         }
     }
-    async actionableRecords(sessionId) {
-        const records = await this.input.store.listSessionShellRuns(sessionId);
-        return records
-            .filter((record) => isActiveShellRunStatus(record.status) ||
-            (record.observedAt === undefined && isTerminalShellRunStatus(record.status)))
-            .sort(compareActionableShellRuns);
-    }
     notifyShellRunUpdate(record) {
         try {
             this.input.onShellRunUpdate?.(shellRunUpdate(record));
@@ -1679,13 +1648,6 @@ function startupCleanupError(startupError, cleanupFailure) {
     const cleanupError = asError(cleanupFailure, 'Shell process startup cleanup failed');
     return new Error(`Shell process startup failed: ${safeFailureMessage(startupError)}; startup cleanup failed: ${safeFailureMessage(cleanupError)}`, { cause: new AggregateError([startupError, cleanupError]) });
 }
-function compareActionableShellRuns(a, b) {
-    const rank = (record) => (isActiveShellRunStatus(record.status) ? 1 : 0);
-    return (rank(a) - rank(b) ||
-        b.updatedAt - a.updatedAt ||
-        b.startedAt - a.startedAt ||
-        a.shellRunId.localeCompare(b.shellRunId));
-}
 async function racePromiseWithAbort(promise, signal) {
     if (!signal)
         return promise;

package/node_modules/@maka/runtime/dist/shell-tools.js

@@ -211,7 +211,7 @@ export function buildStopBackgroundTaskTool(backgroundTasks) {
     return {
         name: 'StopBackgroundTask',
         activityKind: 'command',
-        description: 'Stop a background task by runtime ref. Currently supports background shell run refs returned by Bash and shown in the turn tail.',
+        description: 'Stop a background task by runtime ref. Currently supports background shell run refs returned by Bash.',
         parameters: z.object({
             ref: z
                 .string()

package/node_modules/@maka/runtime/dist/task-ledger-tools.js

@@ -34,8 +34,8 @@ function buildTaskCreateTool(store, name, updateToolName) {
     return {
         name,
         displayName: 'Task Create',
-        description: 'Add one or more tasks to the session task ledger. The full updated ledger is re-shown each turn, ' +
-            `so use this to record work you plan to do; update status with ${updateToolName} as you progress.`,
+        description: 'Add one or more tasks to the session task ledger. ' +
+            `Use task_list or task_get to read it later, and update status with ${updateToolName} as you progress.`,
         parameters: z.object({
             tasks: z
                 .array(z.object({

package/node_modules/@maka/runtime/package.json

@@ -96,7 +96,6 @@
     "./system-prompt/main-session-prompt": "./dist/system-prompt/main-session-prompt.js",
     "./system-prompt/personalization-prompt": "./dist/system-prompt/personalization-prompt.js",
     "./system-prompt/project-context": "./dist/system-prompt/project-context.js",
-    "./system-prompt/session-environment-prompt": "./dist/system-prompt/session-environment-prompt.js",
     "./system-prompt/workspace-instructions": "./dist/system-prompt/workspace-instructions.js",
     "./task-ledger-tools": "./dist/task-ledger-tools.js",
     "./tavily-search": "./dist/tavily-search.js",

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -32,7 +32,7 @@ import { buildHistoryTools } from '@maka/runtime/history-tools';
 import { createLocalContinuationSafetyInspector } from '@maka/runtime/continuation-safety';
 import { createConfiguredSubagentCatalog } from '@maka/runtime/configured-subagent-catalog';
 import { buildHostCapabilitiesFromBinding } from '@maka/runtime/skills';
-import { createBuiltinSandboxManager, createSandboxDiagnosticsProvider, isBuiltinFilesystemWorkerSandboxAvailable, } from '@maka/runtime/sandbox';
+import { createBuiltinSandboxManager, isBuiltinFilesystemWorkerSandboxAvailable, } from '@maka/runtime/sandbox';
 import { createFilesystemWorkerLaunchSpecProvider, FilesystemWorkerClient, } from '@maka/runtime/filesystem-worker';
 import { isOAuthEnrollmentProviderEnabled } from '@maka/runtime/oauth-provider-contracts';
 import { loadHistoryCompactCheckpointsFromRunLedger, loadLatestHistoryCompactCheckpointFromRunLedger, } from '@maka/runtime/history-compact-ledger';
@@ -224,12 +224,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 resourceLocation: { kind: 'runtime' },
             })
             : undefined;
-        const sandboxDiagnostics = createSandboxDiagnosticsProvider({
-            ...(sandboxManager ? { sandboxManager } : {}),
-            ...(filesystemWorkerLaunchSpecProvider
-                ? { getFilesystemWorkerLaunchSpec: filesystemWorkerLaunchSpecProvider }
-                : {}),
-        });
         const filesystemWorker = sandboxManager && filesystemWorkerLaunchSpecProvider
             ? new FilesystemWorkerClient({
                 sandboxManager,
@@ -478,7 +472,6 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 context: backendContext,
                 runtimePolicy: runtimePolicyStores,
                 oauthCredentials,
-                sandboxDiagnostics,
                 createRunComposer: createInteractiveRunComposerFactory({
                     skills,
                     memory: requireMemory(memory),

package/node_modules/@maka/runtime-host/dist/server/execution-model-composition.js

@@ -195,9 +195,7 @@ export async function createHostAiSdkBackend(input) {
         const resolved = await modelComposition.resolveSystemPrompt({
             sessionId: input.context.sessionId,
             turnId: context.turnId,
-            ...(context.runId ? { runId: context.runId } : {}),
             cwd: input.context.header.cwd,
-            workspaceRoot: input.context.workspaceRoot,
             ...(context.emitSkillCatalogTrace
                 ? { emitSkillCatalogTrace: context.emitSkillCatalogTrace }
                 : {}),
@@ -239,7 +237,6 @@ export async function createHostAiSdkBackend(input) {
             appendMessage: input.context.appendMessage ??
                 ((message) => input.context.store.appendMessage(input.context.sessionId, message)),
             readExecutionBoundary: () => input.context.store.readExecutionBoundary(input.context.sessionId),
-            sandboxDiagnostics: input.sandboxDiagnostics,
             ...(input.context.store.createSandboxBoundaryRequest
                 ? {
                     createSandboxBoundaryRequest: (request) => input.context.store.createSandboxBoundaryRequest(request),
@@ -307,15 +304,12 @@ export async function createHostAiSdkBackend(input) {
             systemPrompt: async (context) => {
                 const resolved = await resolveRunPrompt({
                     turnId: context.turnId,
-                    ...(context.runId ? { runId: context.runId } : {}),
                     ...(context.emitSkillCatalogTrace
                         ? { emitSkillCatalogTrace: context.emitSkillCatalogTrace }
                         : {}),
                 });
                 return resolved.text;
             },
-            turnTailPrompt: modelComposition.turnTailPrompt,
-            shellRunContextSummary: input.context.shellRunContextSummary,
             lookupPricing: pricing,
             recordModelCallAttempt,
             assertModelCallAccountingReady,

package/node_modules/@maka/runtime-host/dist/server/interactive-run-composer.js

@@ -19,7 +19,6 @@
 import { buildSideConversationSystemPromptFragment, isSideConversationSession, } from '@maka/core/side-conversation';
 import { buildDeepResearchSystemPromptFragment, isDeepResearchSession, } from '@maka/core/deep-research';
 import { activePlanExecution } from '@maka/core/plan';
-import { filterModelVisibleTaskLedgerTasks, renderTaskLedgerPromptText, } from '@maka/core/task-ledger';
 import { assembleMainSessionSystemPrompt } from '@maka/runtime/system-prompt/main-session-prompt';
 import { buildAskUserQuestionTool } from '@maka/runtime/ask-user-question-tool';
 import { buildBuiltinTools } from '@maka/runtime/builtin-tools';
@@ -27,17 +26,15 @@ import { buildCancelPlanTool, buildSubmitPlanTool, buildUpdatePlanTool, } from '
 import { buildParentAgentTools } from '@maka/runtime/subagent-tools';
 import { buildPersonalizationPromptFragment } from '@maka/runtime/system-prompt/personalization-prompt';
 import { buildRequestSandboxBoundaryTool } from '@maka/runtime/sandbox-boundary-tool';
-import { buildSessionEnvironmentPromptFragment } from '@maka/runtime/system-prompt/session-environment-prompt';
 import { buildHostCapabilitiesFromBinding, buildSkillAgentToolFromInventory, buildSkillSearchAgentToolFromInventory, buildSkillsPromptFragmentFromInventoryWithReport, SkillShadowSelectionTracker, } from '@maka/runtime/skills';
 import { buildTaskLedgerTools } from '@maka/runtime/task-ledger-tools';
 import { buildWorkspaceInstructionsPromptFragment } from '@maka/runtime/system-prompt/workspace-instructions';
 import { isDeepResearchToolAllowed } from '@maka/runtime/deep-research-tools';
 import { listRunnableBuiltinAgentDefinitions } from '@maka/runtime/agent-catalog';
-import { renderInterruptedPlanContext, renderPlanExecutionPrompt, renderPlanModePrompt, selectCollaborationTools, } from '@maka/runtime/plan-mode';
-import { resolveProjectGitInfo } from '@maka/runtime/system-prompt/project-context';
+import { renderPlanModePrompt, selectCollaborationTools } from '@maka/runtime/plan-mode';
 import { routeWebFetchTools } from '@maka/runtime/web-fetch-tool';
 import { routeWebSearchTools } from '@maka/runtime/native-web-search-tool';
-import { resolveTurnShellPlan, turnShellDisplayName, } from '@maka/runtime/shell-detect';
+import { resolveTurnShellPlan } from '@maka/runtime/shell-detect';
 import { readDuringBackendCreation } from './execution-model-authority.js';
 import { hostedExecutionRunProfile, projectHostedExecutionTools, } from './hosted-execution-tool-profile.js';
 import { shouldResolveHostTavilyWebSearchReadiness } from './web-search-tool.js';
@@ -165,26 +162,6 @@ export function createInteractiveRunComposer(input) {
         tools,
         toolAvailability,
         resolveSystemPrompt,
-        turnTailPrompt: async (context) => {
-            const environment = buildSessionEnvironmentPromptFragment({
-                cwd: context.cwd,
-                projectGit: await resolveProjectGitInfo(context.cwd),
-                ...(input.platform ? { platform: input.platform } : {}),
-                ...(input.shell ? { shell: turnShellDisplayName(input.shell) } : {}),
-                ...(input.now ? { now: input.now() } : {}),
-            });
-            const tasks = filterModelVisibleTaskLedgerTasks(await input.taskLedger.list(context.sessionId, {
-                classifyResumeTrust: true,
-                includeArchived: false,
-            }));
-            return (joinFragments([
-                environment,
-                renderTaskLedgerTail(tasks),
-                input.plan
-                    ? renderPlanTail(input.plan.state, input.plan.mode, input.plan.permissionMode === 'bypass')
-                    : undefined,
-            ]) ?? environment);
-        },
     });
 }
 /** Routes every model-visible tool surface through the same policy and readiness snapshot. */
@@ -372,21 +349,6 @@ function requireDeepResearchTools(tools) {
         throw new Error('Runtime Host Deep Research tools are not composed');
     return tools;
 }
-function renderPlanTail(state, mode, fullAccess) {
-    const active = activePlanExecution(state);
-    const execution = active ??
-        (mode === 'plan'
-            ? [...state.executions].reverse().find((candidate) => candidate.status === 'interrupted')
-            : undefined);
-    if (!execution)
-        return undefined;
-    const proposal = state.proposals.find((candidate) => candidate.proposalId === execution.proposalId);
-    if (!proposal)
-        return undefined;
-    return active
-        ? renderPlanExecutionPrompt({ proposal, execution: active })
-        : renderInterruptedPlanContext({ proposal, execution, fullAccess });
-}
 function filterToolGroups(groups, names) {
     const seenIds = new Set();
     return groups.flatMap((group) => {
@@ -472,24 +434,6 @@ function renderMemoryPrompt(body) {
         '</local-memory>',
     ].join('\n');
 }
-function renderTaskLedgerTail(tasks) {
-    if (tasks.length === 0)
-        return undefined;
-    const rendered = renderTaskLedgerPromptText(tasks);
-    if (!rendered.text)
-        return undefined;
-    return [
-        'Current task ledger (current-turn context only; maintain it with task_create, task_update, task_list, and task_get — activate them via tool_search first when they are not already visible):',
-        '<task-ledger>',
-        rendered.text,
-        ...(rendered.omittedCount > 0
-            ? [
-                `omitted=${rendered.omittedCount} (use task_list/task_get via tool_search for the complete ledger)`,
-            ]
-            : []),
-        '</task-ledger>',
-    ].join('\n');
-}
 function joinFragments(fragments) {
     const present = fragments
         .map((fragment) => fragment?.trim())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maka-agent",
-  "version": "0.2.0-dev.6.20260830",
+  "version": "0.2.0-dev.8.20260830",
   "description": "Apache Maka (Incubating) developer snapshot; not an Apache release.",
   "license": "Apache-2.0",
   "type": "module",

package/node_modules/@maka/runtime/dist/sandbox/diagnostics.js

@@ -1,285 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { constants } from 'node:fs';
-import { access, realpath } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { resolve } from 'node:path';
-import { compilePermissionProfile } from '@maka/core/permission-profile-compiler';
-export function createSandboxDiagnosticsProvider(input) {
-    return {
-        resolve: async (request) => {
-            const canonicalize = input.canonicalizePath ?? canonicalPath;
-            const cwd = await canonicalize(request.cwd);
-            const workspaceRoots = await Promise.all((request.workspaceRoots ?? [cwd]).map(canonicalize));
-            const compiled = request.permissionProfile
-                ? { profile: request.permissionProfile, workspaceRoots }
-                : compilePermissionProfile({ mode: request.mode, cwd, workspaceRoots });
-            const platform = input.platform ?? process.platform;
-            const capabilityInput = {
-                profile: compiled.profile,
-                cwd,
-                workspaceRoots: compiled.workspaceRoots,
-                platform,
-                sandboxManager: input.sandboxManager,
-                isExecutable: input.isExecutable ?? defaultIsExecutable,
-            };
-            const command = await probeCommandCapability(capabilityInput);
-            const filesystem = await probeFilesystemCapability({
-                ...capabilityInput,
-                getLaunchSpec: input.getFilesystemWorkerLaunchSpec,
-            });
-            return {
-                schemaVersion: 1,
-                platform,
-                profile: {
-                    name: profileName(compiled.profile),
-                    type: compiled.profile.type,
-                    fileSystem: summarizeFileSystem(compiled.profile),
-                    network: summarizeNetwork(compiled.profile),
-                    cwd,
-                    workspaceRoots: [...new Set(compiled.workspaceRoots)],
-                    protectedMetadata: protectedMetadataNames(compiled.profile),
-                },
-                capabilities: { command, filesystem },
-            };
-        },
-    };
-}
-export function toSandboxRunTraceProjection(snapshot) {
-    return {
-        schemaVersion: snapshot.schemaVersion,
-        platform: snapshot.platform,
-        profile: {
-            name: snapshot.profile.name,
-            type: snapshot.profile.type,
-            fileSystem: snapshot.profile.fileSystem,
-            network: snapshot.profile.network,
-            protectedMetadata: [...snapshot.profile.protectedMetadata],
-        },
-        capabilities: {
-            command: cloneCapability(snapshot.capabilities.command),
-            filesystem: cloneCapability(snapshot.capabilities.filesystem),
-        },
-    };
-}
-async function probeCommandCapability(input) {
-    const passive = passiveCapability(input.profile);
-    if (passive)
-        return passive;
-    const manager = input.sandboxManager;
-    if (!manager) {
-        return unavailable(expectedSandboxType(input.platform), 'selection', input.platform === 'darwin' || input.platform === 'linux' || input.platform === 'win32'
-            ? 'backend_not_available'
-            : 'unsupported_platform');
-    }
-    const selection = manager.selectInitial({ profile: input.profile, platform: input.platform });
-    if (!selection.ok) {
-        return unavailable(selection.sandboxType ?? expectedSandboxType(input.platform), 'selection', selection.reason);
-    }
-    if (selection.sandboxType === 'none') {
-        return {
-            status: 'not_required',
-            backend: 'none',
-            selectionReason: selection.reason,
-        };
-    }
-    // The Windows broker runs the purpose-built filesystem worker, but cannot
-    // launch an arbitrary shell inside its capability-less AppContainer. Match
-    // the real Bash execution contract instead of reporting the broker itself as
-    // evidence that command sandboxing is available.
-    if (input.platform === 'win32') {
-        return unavailable('windows', 'capability', 'backend_not_implemented', selection.reason);
-    }
-    try {
-        const probed = manager.probe({
-            platform: input.platform,
-            command: {
-                program: '/bin/sh',
-                args: ['-c', 'true'],
-                cwd: input.cwd,
-                env: {},
-                profile: input.profile,
-                pathContext: {
-                    workspaceRoots: input.workspaceRoots,
-                    tmpdir: await canonicalPath(tmpdir()),
-                    ...(input.platform === 'win32' ? {} : { slashTmp: await canonicalPath('/tmp') }),
-                },
-            },
-        });
-        if (!probed.ok) {
-            return unavailable(probed.sandboxType ?? selection.sandboxType, 'transform', probed.reason, selection.reason);
-        }
-        const executable = probed.executable;
-        if (!executable || !(await safelyCheckExecutable(executable, input.isExecutable))) {
-            return unavailable(probed.sandboxType, 'capability', 'executable_unavailable', selection.reason);
-        }
-        return {
-            status: 'available',
-            backend: probed.sandboxType,
-            selectionReason: selection.reason,
-        };
-    }
-    catch {
-        return unavailable(selection.sandboxType, 'capability', 'capability_probe_failed', selection.reason);
-    }
-}
-async function probeFilesystemCapability(input) {
-    const passive = passiveCapability(input.profile);
-    if (passive)
-        return passive;
-    if (!input.sandboxManager) {
-        return unavailable(expectedSandboxType(input.platform), 'selection', 'backend_not_available');
-    }
-    const selection = input.sandboxManager.selectInitial({
-        profile: input.profile,
-        platform: input.platform,
-    });
-    if (!selection.ok) {
-        return unavailable(selection.sandboxType ?? expectedSandboxType(input.platform), 'selection', selection.reason);
-    }
-    if (!input.getLaunchSpec) {
-        return unavailable(selection.sandboxType, 'launch', 'filesystem_worker_unavailable', selection.reason);
-    }
-    let launch;
-    try {
-        launch = await input.getLaunchSpec();
-    }
-    catch {
-        return unavailable(selection.sandboxType, 'capability', 'capability_probe_failed', selection.reason);
-    }
-    if (!launch.ok) {
-        return unavailable(selection.sandboxType, 'launch', launch.reason, selection.reason);
-    }
-    try {
-        const probed = input.sandboxManager.probe({
-            platform: input.platform,
-            command: {
-                program: launch.spec.program,
-                args: launch.spec.args,
-                cwd: input.cwd,
-                env: launch.spec.env,
-                profile: input.profile,
-                pathContext: {
-                    workspaceRoots: input.workspaceRoots,
-                    tmpdir: await canonicalPath(tmpdir()),
-                    ...(input.platform === 'win32' ? {} : { slashTmp: await canonicalPath('/tmp') }),
-                    runtimeReadableRoots: launch.spec.runtimeReadableRoots,
-                    executableRoots: launch.spec.executableRoots,
-                },
-            },
-        });
-        if (!probed.ok) {
-            return unavailable(probed.sandboxType ?? selection.sandboxType, 'transform', probed.reason, selection.reason);
-        }
-        const executable = probed.executable;
-        if (!executable || !(await safelyCheckExecutable(executable, input.isExecutable))) {
-            return unavailable(probed.sandboxType, 'capability', 'executable_unavailable', selection.reason);
-        }
-        return {
-            status: 'available',
-            backend: probed.sandboxType,
-            selectionReason: selection.reason,
-        };
-    }
-    catch {
-        return unavailable(selection.sandboxType, 'capability', 'capability_probe_failed', selection.reason);
-    }
-}
-function passiveCapability(profile) {
-    if (profile.type === 'external')
-        return { status: 'external', backend: 'none' };
-    if (profile.type === 'disabled' ||
-        (profile.type === 'managed' && profile.fileSystem.kind !== 'restricted')) {
-        return {
-            status: 'not_required',
-            backend: 'none',
-            selectionReason: 'sandbox_not_required',
-        };
-    }
-    return undefined;
-}
-function unavailable(backend, stage, reason, selectionReason) {
-    return {
-        status: 'unavailable',
-        backend,
-        ...(selectionReason ? { selectionReason } : {}),
-        failure: { stage, reason },
-    };
-}
-function expectedSandboxType(platform) {
-    if (platform === 'darwin')
-        return 'macos-seatbelt';
-    if (platform === 'linux')
-        return 'linux';
-    if (platform === 'win32')
-        return 'windows';
-    return 'none';
-}
-function profileName(profile) {
-    return profile.name ?? profile.type;
-}
-function summarizeFileSystem(profile) {
-    if (profile.type === 'disabled')
-        return 'disabled';
-    if (profile.type === 'external')
-        return 'external';
-    if (profile.fileSystem.kind === 'unrestricted')
-        return 'unrestricted';
-    if (profile.fileSystem.kind === 'external_sandbox')
-        return 'external';
-    if (!profile.fileSystem.entries.some((entry) => entry.access === 'write'))
-        return 'read-only';
-    return profile.fileSystem.entries.some((entry) => entry.kind === 'special' && entry.special === ':workspace_roots' && entry.access === 'write')
-        ? 'workspace-write'
-        : 'custom-restricted';
-}
-function summarizeNetwork(profile) {
-    return profile.type === 'disabled' ? 'unmanaged' : profile.network.kind;
-}
-function protectedMetadataNames(profile) {
-    if (profile.type !== 'managed')
-        return [];
-    return [...(profile.fileSystem.protectedMetadata?.names ?? [])];
-}
-function cloneCapability(capability) {
-    return {
-        ...capability,
-        ...(capability.failure ? { failure: { ...capability.failure } } : {}),
-    };
-}
-async function safelyCheckExecutable(path, isExecutable) {
-    try {
-        return await isExecutable(path);
-    }
-    catch {
-        return false;
-    }
-}
-async function defaultIsExecutable(path) {
-    try {
-        await access(path, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function canonicalPath(path) {
-    return await realpath(path).catch(() => resolve(path));
-}