@fitlab-ai/agent-infra 0.9.3 → 0.9.5

package/dist/lib/sandbox/commands/enter.js

@@ -3,12 +3,13 @@ import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, san
 import { detectEngine } from '../engine.js';
 import { ensureSandboxReady } from '../recovery.js';
 import { createSandboxCapabilityPlan, runBoundedSandboxHookCommand, runSandboxHooks } from '../agent-client-reconciler.js';
-import { formatCredentialWarnings, formatRemaining, hasClaudeProviderAuth, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from '../credentials.js';
 import { runInteractiveEngine } from '../shell.js';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
+import { redactCommandError } from '../redaction.js';
 import { runInteractiveWithClipboardBridge } from '../clipboard/bridge.js';
 import { detectHostTimezone } from '../host-timezone.js';
-import { fetchSandboxRows, resolveBranchArg, selectSandboxContainer, } from './list-running.js';
+import { fetchSandboxRows, selectSandboxContainer, } from './list-running.js';
+import { resolveSandboxTarget } from '../workspace-identity.js';
 const USAGE = `Usage: ai sandbox exec [--recreate] <branch | TASK-id | N> [cmd...]
 
 N references an active task short id from
@@ -53,32 +54,6 @@ export function runSandboxInteractive(params) {
     }
     return runBridge({ engine, dockerArgs, container, home });
 }
-export function formatCredentialSyncStatus(result, isTTY = process.stderr.isTTY, providerAuthAvailable = false) {
-    if (providerAuthAvailable && (result.status === 'STALE_ACCESS' || result.status === 'MISSING')) {
-        return null;
-    }
-    if (result.status === 'STALE_ACCESS') {
-        return 'Warning: Claude Code credentials on host appear stale. Run "ai sandbox refresh" or "claude /login" to renew.\n';
-    }
-    if (result.status === 'MISSING') {
-        return 'Warning: Claude Code credentials missing on host. Run "claude /login" to authenticate.\n';
-    }
-    if (result.status === 'KEYCHAIN_WRITE_FAILED') {
-        return `Warning: A sandbox refresh produced newer credentials but host Keychain write failed (${formatCredentialWarnings(result.warnings)}). Run "ai sandbox refresh" again or "claude /status" on the host to retry.\n`;
-    }
-    if (result.status === 'KEYCHAIN_LOCKED' || result.status === 'KEYCHAIN_ERROR') {
-        return 'Warning: Host keychain is unavailable; Claude credential sync skipped. Run "ai sandbox refresh" for details.\n';
-    }
-    if (result.status === 'OK' && result.authoritative !== 'host') {
-        const message = `Synced Claude Code credentials from sandbox refresh back to host (expires in ${formatRemaining(result.expiresAt)})`;
-        return isTTY ? `\x1b[2m${message}\x1b[0m\n` : `${message}\n`;
-    }
-    if (result.status === 'OK' && result.filesWritten.length > 0) {
-        const message = `Synced Claude Code credentials from host Keychain (expires in ${formatRemaining(result.expiresAt)})`;
-        return isTTY ? `\x1b[2m${message}\x1b[0m\n` : `${message}\n`;
-    }
-    return null;
-}
 export function parseEnterArgs(args) {
     let recreate = false;
     let index = 0;
@@ -101,10 +76,10 @@ export async function enter(args) {
         return 0;
     }
     const config = loadConfig();
-    validateClaudeCredentialsEnvOverride();
     const engine = detectEngine(config);
     const parsed = parseEnterArgs(args);
-    const branch = resolveBranchArg(parsed.target, { repoRoot: config.repoRoot });
+    const target = resolveSandboxTarget(parsed.target, config.repoRoot);
+    const branch = target.branch;
     assertValidBranchName(branch);
     const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
     const found = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, branch));
@@ -115,11 +90,12 @@ export async function enter(args) {
         config,
         engine,
         branch,
+        workspace: target.workspace,
         row: found,
         allowRecreate: parsed.recreate,
-        recreate: async (targetBranch) => {
+        recreate: async () => {
             const { create } = await import('./create.js');
-            await create([targetBranch, '--no-refresh']);
+            await create([target.requestedRef, '--no-refresh']);
         }
     });
     const container = ready.container;
@@ -128,7 +104,11 @@ export async function enter(args) {
     const enterHookResults = await runSandboxHooks({
         hooks: capabilityPlan.hooksByPhase['before-enter'],
         phase: 'before-enter',
-        context: { config, plan: capabilityPlan },
+        context: {
+            config,
+            plan: capabilityPlan,
+            enter: { hostHome: config.home, hostEnv: { ...process.env } }
+        },
         runCommand: runBoundedSandboxHookCommand
     });
     for (const result of enterHookResults) {
@@ -138,20 +118,8 @@ export async function enter(args) {
         if (result.status === 'warning') {
             process.stderr.write(`Warning: ${result.message ?? `Sandbox hook '${result.hookId}' did not complete.`}\n`);
         }
-    }
-    if (capabilityPlan.selectedAgentClients.some((adapter) => adapter.id === 'claude-code')) {
-        try {
-            // Scan all projects so a refresh from a neighbouring sandbox can still flow back to the host.
-            const providerAuthAvailable = hasClaudeProviderAuth(config.home);
-            const result = reconcileClaudeCredentials(config.home);
-            const message = formatCredentialSyncStatus(result, process.stderr.isTTY, providerAuthAvailable);
-            if (message) {
-                process.stderr.write(message);
-            }
-        }
-        catch (error) {
-            process.stderr.write(`Warning: Failed to sync Claude Code credentials: ${redactCommandError(error instanceof Error ? error.message : 'unknown error')}\n`);
-        }
+        if (result.message && result.status !== 'warning')
+            process.stderr.write(result.message);
     }
     const envFlags = [...terminalEnvFlags(), ...hostTimezoneEnvFlags()];
     if (cmd.length === 0) {

package/dist/lib/sandbox/commands/list-running.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { runSafeEngine, runVerboseEngine } from '../shell.js';
 import { resolveTaskBranch } from '../task-resolver.js';
 import { isRemovedHashShortIdInput } from '../../task/short-id.js';
+import { parseSandboxWorkspaceIdentity } from '../workspace-identity.js';
 export function containerListFormat() {
     return '{{.Names}}\t{{.Status}}\t{{.Labels}}';
 }
@@ -24,19 +25,28 @@ export function parseLabels(csv) {
     }
     return labels;
 }
-export function parseSandboxRows(rawOutput, branchKey) {
+export function parseSandboxRows(rawOutput, branchKey, workspaceKeys) {
     if (!rawOutput) {
         return [];
     }
     return rawOutput.split('\n').map((line) => {
         const [name = '', status = '', labelsCsv = ''] = line.split('\t');
-        const branch = parseLabels(labelsCsv)[branchKey] ?? '';
+        const labels = parseLabels(labelsCsv);
+        const workspace = workspaceKeys
+            ? parseSandboxWorkspaceIdentity(labels, workspaceKeys)
+            : null;
         return {
             name,
             status,
-            branch,
+            branch: labels[branchKey] ?? '',
             running: status.startsWith('Up '),
-            index: null
+            index: null,
+            ...(workspace
+                ? {
+                    workspaceMode: workspace.mode,
+                    taskId: workspace.mode === 'task-bound' ? workspace.taskId : null
+                }
+                : {})
         };
     });
 }
@@ -58,7 +68,7 @@ export function sortAndIndexSandboxRows(rows) {
     }));
     return { running, nonRunning };
 }
-export function fetchSandboxRows(engine, label, branchKey) {
+export function fetchSandboxRows(engine, label, branchKey, workspaceKeys) {
     const raw = runSafeEngine(engine, 'docker', [
         'ps',
         '-a',
@@ -67,7 +77,7 @@ export function fetchSandboxRows(engine, label, branchKey) {
         '--format',
         containerListFormat()
     ]);
-    return sortAndIndexSandboxRows(parseSandboxRows(raw, branchKey));
+    return sortAndIndexSandboxRows(parseSandboxRows(raw, branchKey, workspaceKeys));
 }
 /**
  * Returns true iff `arg` is a syntactically valid task short reference.

package/dist/lib/sandbox/commands/ls.js

@@ -1,10 +1,10 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { loadConfig } from '../config.js';
-import { sandboxBranchLabel, sandboxLabel } from '../constants.js';
+import { sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel } from '../constants.js';
 import { detectEngine } from '../engine.js';
 import { formatTable } from '../../table.js';
-import { lookupShortIdByBranch } from '../../task/short-id.js';
+import { loadShortIdByTaskId } from '../../task/short-id.js';
 import { fetchSandboxRows } from './list-running.js';
 export { containerListFormat, parseLabels } from './list-running.js';
 const USAGE = `Usage: ai sandbox ls
@@ -19,9 +19,9 @@ to remove with "ai sandbox rm <branch>".
 
 Use "ai sandbox show <ref>" for a single sandbox's worktree and per-tool
 state paths.`;
-const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'];
+const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'WORKSPACE', 'TASK', 'BRANCH'];
 export function formatContainerTable(rows, zebra = false) {
-    return formatTable(CONTAINER_TABLE_HEADERS, rows.map((r) => [r.row, r.shortId, r.name, r.status, r.branch]), { zebra });
+    return formatTable(CONTAINER_TABLE_HEADERS, rows.map((r) => [r.row, r.shortId, r.name, r.status, r.workspace, r.taskId, r.branch]), { zebra });
 }
 export function ls(args = []) {
     if (args.length > 0 && (args[0] === '--help' || args[0] === '-h')) {
@@ -31,7 +31,7 @@ export function ls(args = []) {
     const config = loadConfig();
     const engine = detectEngine(config);
     const label = sandboxLabel(config);
-    const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config));
+    const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config), { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) });
     p.intro(pc.cyan(`Sandbox status for ${config.project}`));
     p.log.step('Containers');
     const ordered = [...running, ...nonRunning];
@@ -40,12 +40,16 @@ export function ls(args = []) {
     }
     else {
         const tableRows = ordered.map((container, i) => {
-            const shortId = container.branch ? lookupShortIdByBranch(container.branch, config.repoRoot) : null;
+            const shortId = container.taskId
+                ? loadShortIdByTaskId(config.repoRoot).get(container.taskId) ?? null
+                : null;
             return {
                 row: String(i + 1),
                 shortId: shortId ?? '-',
                 name: container.name,
                 status: container.status,
+                workspace: container.workspaceMode ?? 'legacy-invalid',
+                taskId: container.taskId ?? '-',
                 branch: container.branch
             };
         });

package/dist/lib/sandbox/commands/rebuild.js

@@ -7,7 +7,7 @@ import { sandboxImageRefreshLabel } from '../constants.js';
 import { detectEngine, ensureDocker } from '../engine.js';
 import { runEngine, runOkEngine, runSafeEngine, runVerboseEngine } from '../shell.js';
 import { pruneSandboxDanglingImages } from '../image-prune.js';
-import { resolveTools } from '../tools.js';
+import { createSandboxCapabilityPlan } from '../agent-client-reconciler.js';
 import { buildImageSignature, buildSandboxImageArgs, parseImageLabels, parseRefreshTimestamp } from '../image-build.js';
 import { assertBuildProxyCompatibility, buildProxyFailureHint, prepareBuildProxy, redactBuildProxyValues } from '../build-proxy.js';
 const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh] [--inherit-build-proxy|-B]`;
@@ -52,8 +52,9 @@ export async function rebuild(args) {
         return;
     }
     const config = loadConfig();
-    const tools = resolveTools(config);
-    const preparedDockerfile = prepareDockerfile(config);
+    const capabilityPlan = createSandboxCapabilityPlan(config);
+    const tools = [...capabilityPlan.tools];
+    const preparedDockerfile = prepareDockerfile(config, capabilityPlan.image);
     const imageSignature = buildImageSignature(preparedDockerfile, tools);
     const quiet = values.quiet ?? false;
     const refresh = values.refresh ?? false;

package/dist/lib/sandbox/commands/refresh.js

@@ -1,85 +1,5 @@
-import { homedir } from 'node:os';
-import { parseArgs } from 'node:util';
-import { buildLockedGuidance, discoverProjects, formatCredentialWarnings, formatRemaining, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from '../credentials.js';
-import { runProbe } from '../shell.js';
-const USAGE = 'Usage: ai sandbox refresh';
-export function probeClaudeStatus(spawnFn = runProbe) {
-    const result = spawnFn('claude', ['/status'], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: 30_000
-    });
-    return {
-        ok: result.status === 0,
-        stderr: result.stderr?.toString() ?? '',
-        error: result.error?.message ?? null
-    };
-}
-export async function refresh(args, deps = {}) {
-    const { spawnFn = runProbe, execFn, readFn, existsFn, writeFn, writeHostFn, discoverFn = discoverProjects, writeStdout = (chunk) => process.stdout.write(chunk), writeStderr = (chunk) => process.stderr.write(chunk) } = deps;
-    if (args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
-        writeStdout(`${USAGE}\n`);
-        return 0;
-    }
-    const { positionals } = parseArgs({ args, allowPositionals: true, strict: true });
-    if (positionals.length > 0) {
-        throw new Error(USAGE);
-    }
-    validateClaudeCredentialsEnvOverride();
-    const home = homedir();
-    if (!home) {
-        throw new Error('sandbox: home directory is required');
-    }
-    const projects = discoverFn(home);
-    if (projects.length === 0) {
-        writeStdout('No project credentials to refresh.\n');
-        return 0;
-    }
-    const reconcileOptions = { execFn, readFn, existsFn, writeFn, writeHostFn, projects };
-    let result = reconcileClaudeCredentials(home, reconcileOptions);
-    if (result.status === 'STALE_ACCESS' && result.authoritative === null) {
-        writeStdout('Host credentials appear stale; probing claude /status to trigger refresh...\n');
-        const probe = probeClaudeStatus(spawnFn);
-        if (!probe.ok) {
-            writeStderr(`Probe failed: ${redactCommandError(probe.stderr || probe.error || 'unknown error')}\n`);
-            writeStderr('Run "claude /login" on the host to renew credentials.\n');
-            return 1;
-        }
-        writeStdout('Probe succeeded; re-inspecting host credentials.\n');
-        result = reconcileClaudeCredentials(home, reconcileOptions);
-    }
-    if (result.status === 'MISSING') {
-        writeStderr('No Claude Code credentials found on host.\n');
-        writeStderr('Run "claude /login" on the host to authenticate.\n');
-        return 1;
-    }
-    if (result.status === 'KEYCHAIN_LOCKED') {
-        writeStderr(`${buildLockedGuidance()}\n`);
-        return 1;
-    }
-    if (result.status === 'KEYCHAIN_ERROR') {
-        writeStderr(`Host keychain error: ${redactCommandError(result.detail || 'unknown error')}\n`);
-        writeStderr(`${buildLockedGuidance()}\n`);
-        return 1;
-    }
-    if (result.status === 'KEYCHAIN_WRITE_FAILED') {
-        writeStderr(`[host] keychain write failed: ${formatCredentialWarnings(result.warnings) || 'unknown error'}\n`);
-        return 1;
-    }
-    if (result.status !== 'OK') {
-        writeStderr('Host credentials still invalid after probe; run "claude /login".\n');
-        return 1;
-    }
-    if (result.authoritative && result.authoritative !== 'host' && result.hostWritten) {
-        writeStdout(`[host] reconciled from ${result.authoritative}\n`);
-    }
-    for (const project of projects) {
-        const action = result.filesWritten.includes(project) ? 'updated' : 'unchanged';
-        writeStdout(`[${project}] ${action}; expires in ${formatRemaining(result.expiresAt)}\n`);
-    }
-    for (const failure of result.fileErrors) {
-        writeStderr(`[${failure.project}] sync failed: ${failure.error}\n`);
-    }
-    return result.fileErrors.length > 0 ? 1 : 0;
-}
+import { runClaudeCodeRefresh } from '../../agent-clients/adapters/claude-code-refresh.js';
+const refresh = runClaudeCodeRefresh;
+export { probeClaudeStatus, runClaudeCodeRefresh } from '../../agent-clients/adapters/claude-code-refresh.js';
+export { refresh };
 //# sourceMappingURL=refresh.js.map

package/dist/lib/sandbox/commands/rm.js

@@ -9,7 +9,7 @@ import { ENGINES, detectEngine, engineDisplayName, isManagedEngine, stopManagedV
 import { pruneSandboxDanglingImages } from '../image-prune.js';
 import { removeManagedDir, removeWorktreeDir } from '../managed-fs.js';
 import { runOk, runSafe, runSafeEngine } from '../shell.js';
-import { resolveTaskBranch } from '../task-resolver.js';
+import { resolveSandboxTarget } from '../workspace-identity.js';
 import { toolConfigDirCandidates, toolProjectDirCandidates } from '../tools.js';
 import { createSandboxCapabilityPlan } from '../agent-client-reconciler.js';
 import { fetchSandboxRows } from './list-running.js';
@@ -57,6 +57,17 @@ async function rmOne(config, tools, branch, options = {}) {
         for (const name of matchedContainers) {
             runSafeEngine(engine, 'docker', ['stop', name]);
             runSafeEngine(engine, 'docker', ['rm', name]);
+            for (const [base, label] of [
+                [path.join(config.workspaceViewBase, config.project), 'Workspace view'],
+                [path.join(config.controlBase, config.project), 'Control channel']
+            ]) {
+                const directory = path.join(base, name);
+                if (fs.existsSync(directory)) {
+                    removeManagedDir(base, directory);
+                    if (!options.quiet)
+                        p.log.success(`${label} removed: ${directory}`);
+                }
+            }
         }
         spinner.stop(pc.green(`Removed container(s): ${matchedContainers.join(', ')}`));
     }
@@ -184,6 +195,16 @@ async function rmPurge(config, tools) {
             p.log.success(`Project share dirs removed: ${config.shareBase}`);
         }
     }
+    for (const [base, label] of [
+        [config.workspaceViewBase, 'workspace views'],
+        [config.controlBase, 'control channels']
+    ]) {
+        const projectDir = path.join(base, config.project);
+        if (fs.existsSync(projectDir)) {
+            removeManagedDir(base, projectDir);
+            p.log.success(`Removed project ${label}: ${projectDir}`);
+        }
+    }
     const shouldRemoveImage = await p.confirm({
         message: `Remove image ${config.imageName}?`,
         initialValue: false
@@ -297,7 +318,7 @@ export async function rm(args) {
         });
         return;
     }
-    const branch = resolveTaskBranch(positionals[0] ?? '', config.repoRoot);
-    await rmOne(config, tools, branch);
+    const target = resolveSandboxTarget(positionals[0] ?? '', config.repoRoot);
+    await rmOne(config, tools, target.branch);
 }
 //# sourceMappingURL=rm.js.map

package/dist/lib/sandbox/commands/show.js

@@ -2,9 +2,11 @@ import fs from 'node:fs';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { loadConfig } from '../config.js';
-import { assertValidBranchName, worktreeDirCandidates } from '../constants.js';
-import { resolveBranchArg } from './list-running.js';
+import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel, worktreeDirCandidates } from '../constants.js';
+import { fetchSandboxRows, selectSandboxContainer } from './list-running.js';
 import { resolveTools, toolConfigDirCandidates } from '../tools.js';
+import { detectEngine } from '../engine.js';
+import { resolveSandboxTarget } from '../workspace-identity.js';
 const USAGE = `Usage: ai sandbox show <branch | TASK-id | N>
 
 Shows one sandbox's worktree path and per-tool state paths (Claude Code,
@@ -40,9 +42,13 @@ export function show(args = []) {
         return;
     }
     const config = loadConfig();
-    const branch = resolveBranchArg(args[0], { repoRoot: config.repoRoot });
+    const target = resolveSandboxTarget(args[0], config.repoRoot);
+    const branch = target.branch;
     assertValidBranchName(branch);
     const detail = collectSandboxDetail(config, branch);
+    const engine = detectEngine(config);
+    const rows = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) });
+    const container = selectSandboxContainer([...rows.running, ...rows.nonRunning], containerNameCandidates(config, branch));
     p.intro(pc.cyan(`Sandbox detail for ${config.project} · ${branch}`));
     p.log.step('Worktree');
     if (detail.worktrees.length === 0) {
@@ -53,6 +59,9 @@ export function show(args = []) {
             process.stdout.write(`  ${worktree}\n`);
         }
     }
+    p.log.step('Workspace identity');
+    process.stdout.write(`  Mode: ${container?.workspaceMode ?? 'legacy-invalid'}\n`);
+    process.stdout.write(`  Task: ${container?.taskId ?? '-'}\n`);
     for (const tool of detail.toolStates) {
         p.log.step(`${tool.name} state`);
         if (tool.entries.length === 0) {

package/dist/lib/sandbox/commands/start.js

@@ -2,7 +2,8 @@ import { loadConfig } from '../config.js';
 import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from '../constants.js';
 import { detectEngine } from '../engine.js';
 import { ensureSandboxReady } from '../recovery.js';
-import { fetchSandboxRows, resolveBranchArg, selectSandboxContainer, } from './list-running.js';
+import { fetchSandboxRows, selectSandboxContainer, } from './list-running.js';
+import { resolveSandboxTarget } from '../workspace-identity.js';
 const USAGE = `Usage: ai sandbox start [--recreate] <branch | TASK-id | N>
 
 Start an existing sandbox container that has stopped (for example after the
@@ -46,7 +47,8 @@ export async function start(args) {
     }
     const config = loadConfig();
     const engine = detectEngine(config);
-    const branch = resolveBranchArg(parsed.target, { repoRoot: config.repoRoot });
+    const target = resolveSandboxTarget(parsed.target, config.repoRoot);
+    const branch = target.branch;
     assertValidBranchName(branch);
     const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
     const found = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, branch));
@@ -57,11 +59,12 @@ export async function start(args) {
         config,
         engine,
         branch,
+        workspace: target.workspace,
         row: found,
         allowRecreate: parsed.recreate,
-        recreate: async (targetBranch) => {
+        recreate: async () => {
             const { create } = await import('./create.js');
-            await create([targetBranch, '--no-refresh']);
+            await create([target.requestedRef, '--no-refresh']);
         }
     });
     const message = ready.path === 'healthy'

package/dist/lib/sandbox/config.js

@@ -111,6 +111,8 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         worktreeBase: hostJoin(home, '.agent-infra', 'worktrees', project),
         shareBase: hostJoin(home, '.agent-infra', 'share', project),
         shellConfigBase: hostJoin(home, '.agent-infra', 'config', project),
+        workspaceViewBase: hostJoin(home, '.agent-infra', 'workspace-views'),
+        controlBase: hostJoin(home, '.agent-infra', 'sandbox-control'),
         dotfilesDir: hostJoin(home, '.agent-infra', 'dotfiles'),
         engine,
         runtimes,

package/dist/lib/sandbox/constants.js

@@ -69,6 +69,12 @@ export function sandboxLabel(config) {
 export function sandboxBranchLabel(config) {
     return `${sandboxLabel(config)}.branch`;
 }
+export function sandboxWorkspaceModeLabel(config) {
+    return `${sandboxLabel(config)}.workspace-mode`;
+}
+export function sandboxTaskIdLabel(config) {
+    return `${sandboxLabel(config)}.task-id`;
+}
 export function sandboxImageConfigLabel(config) {
     return `${sandboxLabel(config)}.image-config`;
 }

package/dist/lib/sandbox/control/client.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { SANDBOX_CONTROL_MAX_BYTES, isSandboxControlFamily } from './protocol.js';
+function sleep(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+function exchangeSandboxControl(request, params) {
+    const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
+    const encoded = `${JSON.stringify(request)}\n`;
+    if (Buffer.byteLength(encoded, 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_TOO_LARGE: request exceeds the control limit');
+    }
+    const requestsDir = path.join(channelDir, 'requests');
+    const responsesDir = path.join(channelDir, 'responses');
+    const temporary = path.join(requestsDir, `.${request.id}.tmp`);
+    const requestPath = path.join(requestsDir, `${request.id}.json`);
+    const responsePath = path.join(responsesDir, `${request.id}.json`);
+    fs.writeFileSync(temporary, encoded, { mode: 0o600, flag: 'wx' });
+    fs.renameSync(temporary, requestPath);
+    const deadline = Date.now() + (params.timeoutMs ?? 30_000);
+    while (Date.now() < deadline) {
+        if (fs.existsSync(responsePath)) {
+            const raw = fs.readFileSync(responsePath, 'utf8');
+            fs.unlinkSync(responsePath);
+            const response = JSON.parse(raw);
+            if (response.version !== 1 || response.id !== request.id || !Number.isInteger(response.exitCode)) {
+                throw new Error('SANDBOX_CONTROL_RESPONSE_INVALID: broker response is invalid');
+            }
+            return response;
+        }
+        sleep(25);
+    }
+    throw new Error(`SANDBOX_CONTROL_TIMEOUT: broker did not respond within ${params.timeoutMs ?? 30_000}ms`);
+}
+export function requestSandboxControl(params) {
+    if (!isSandboxControlFamily(params.family)) {
+        throw new Error(`SANDBOX_CONTROL_COMMAND_DENIED: '${params.family}' is not allowed`);
+    }
+    if (params.family === 'task-create')
+        throw new Error("SANDBOX_CONTROL_COMMAND_DENIED: 'task-create' requires a typed candidate");
+    const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
+    if (!token)
+        throw new Error('SANDBOX_CONTROL_UNAVAILABLE: control token is missing');
+    const id = randomUUID();
+    const request = { version: 1, id, token, family: params.family, args: params.args };
+    return exchangeSandboxControl(request, params);
+}
+export function requestSandboxTaskCreate(params) {
+    const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
+    if (!token)
+        throw new Error('SANDBOX_CONTROL_UNAVAILABLE: control token is missing');
+    const request = {
+        version: 1, id: randomUUID(), token, family: 'task-create', candidate: params.candidate
+    };
+    return exchangeSandboxControl(request, { ...params, timeoutMs: params.timeoutMs ?? 120_000 });
+}
+//# sourceMappingURL=client.js.map

package/dist/lib/sandbox/control/protocol.js

@@ -0,0 +1,54 @@
+import { validateTaskCreateCandidate } from '../../task/create.js';
+export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-orchestration', 'task-create'];
+export function isSandboxControlFamily(value) {
+    return SANDBOX_CONTROL_FAMILIES.includes(value);
+}
+export function validateSandboxControlRequest(value, manifest) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request must be an object');
+    }
+    const request = value;
+    if (request.version !== 1
+        || typeof request.id !== 'string'
+        || !/^[a-f0-9-]{16,64}$/.test(request.id)
+        || request.token !== manifest.token
+        || typeof request.family !== 'string'
+        || !isSandboxControlFamily(request.family)) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
+    }
+    if (Buffer.byteLength(JSON.stringify(request), 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_TOO_LARGE: request exceeds the control limit');
+    }
+    if (request.family === 'task-create') {
+        const keys = Object.keys(request).sort().join(',');
+        if (keys !== ['candidate', 'family', 'id', 'token', 'version'].sort().join(',')) {
+            throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
+        }
+        return { ...request, candidate: validateTaskCreateCandidate(request.candidate) };
+    }
+    const keys = Object.keys(request).sort().join(',');
+    if (keys !== ['args', 'family', 'id', 'token', 'version'].sort().join(',')
+        || !Array.isArray(request.args)
+        || !request.args.every((arg) => typeof arg === 'string')) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
+    }
+    if (manifest.mode !== 'task-bound' || !manifest.taskId) {
+        throw new Error('SANDBOX_CONTROL_BRANCH_ONLY: branch-only sandboxes cannot coordinate tasks');
+    }
+    if (request.family === 'task-orchestration'
+        && request.args.some((arg) => arg === '--git-worktree-root' || arg.startsWith('--git-worktree-root='))) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: worktree binding is reserved for the control broker');
+    }
+    return request;
+}
+export function bindSandboxControlTask(request, taskId) {
+    if (request.family === 'task-create') {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: task-create requests do not bind a current task');
+    }
+    if (request.args.length === 0) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: command arguments are required');
+    }
+    return [taskId, ...request.args.slice(1)];
+}
+//# sourceMappingURL=protocol.js.map