@fitlab-ai/agent-infra 0.8.5 → 0.9.0

package/dist/lib/sandbox/mounts.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { shareBranchDir, shareCommonDir, shellConfigDirCandidates, worktreeDirCandidates } from './constants.js';
+export function sandboxCoreBindMounts(config, branch, overrides = {}) {
+    return [
+        {
+            hostPaths: overrides.worktree
+                ? [overrides.worktree]
+                : worktreeDirCandidates(config, branch),
+            containerPath: '/workspace',
+            readOnly: false
+        },
+        {
+            hostPaths: [path.join(config.repoRoot, '.agents', 'workspace')],
+            containerPath: '/workspace/.agents/workspace',
+            readOnly: false
+        },
+        {
+            hostPaths: [shareCommonDir(config)],
+            containerPath: '/share/common',
+            readOnly: false
+        },
+        {
+            hostPaths: [shareBranchDir(config, branch)],
+            containerPath: '/share/branch',
+            readOnly: false
+        },
+        {
+            hostPaths: overrides.shellConfigHostDir
+                ? [overrides.shellConfigHostDir]
+                : shellConfigDirCandidates(config, branch),
+            containerPath: '/home/devuser/.host-shell-config',
+            readOnly: true
+        }
+    ];
+}
+//# sourceMappingURL=mounts.js.map

package/dist/lib/sandbox/recovery.js

@@ -0,0 +1,562 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.js';
+import { toEnginePath } from './engines/wsl2-paths.js';
+import { sandboxCoreBindMounts } from './mounts.js';
+import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
+import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
+import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
+function findingKey(finding) {
+    return `${finding.repairKind}:${finding.path ?? finding.seed?.targetPath ?? finding.message}`;
+}
+export function classifySandboxRecovery(snapshot) {
+    const findings = [];
+    if (!snapshot.identityOk) {
+        findings.push({
+            repairKind: 'hard-failure',
+            message: 'Container identity does not match the requested sandbox branch.'
+        });
+    }
+    for (const mount of snapshot.mounts) {
+        if (mount.actualType !== mount.expectedType
+            || !mount.sourceMatches
+            || mount.actualRW !== mount.expectedRW
+            || !mount.sourceAccessible) {
+            findings.push({
+                repairKind: 'hard-failure',
+                message: `Expected ${mount.expectedType} mount at ${mount.path}`
+                    + `${mount.expectedSource === null ? '' : ` from ${mount.expectedSource}`}`
+                    + ` with RW=${mount.expectedRW}, found ${mount.actualType ?? 'none'}`
+                    + `${mount.actualSource === null ? '' : ` from ${mount.actualSource}`}`
+                    + ` with RW=${mount.actualRW ?? 'unknown'}.`,
+                path: mount.path
+            });
+        }
+    }
+    for (const mount of snapshot.tmpfs) {
+        if (!mount.permissionsOk || !mount.writable) {
+            findings.push({
+                repairKind: 'permissions',
+                message: `Tmpfs ${mount.path} is not owned and writable by devuser with mode 0700.`,
+                path: mount.path
+            });
+        }
+    }
+    for (const seed of snapshot.seeds) {
+        if (!seed.mounted) {
+            continue;
+        }
+        if (seed.targetState === 'missing' || seed.targetState === 'wrong-type') {
+            findings.push({
+                repairKind: 'missing-seed',
+                message: `Runtime seed target ${seed.targetPath} must be restored from staging.`,
+                path: seed.targetPath,
+                seed: {
+                    toolId: seed.toolId,
+                    containerMount: seed.containerMount ?? seed.targetPath.slice(0, seed.targetPath.lastIndexOf('/')),
+                    stagingPath: seed.stagingPath,
+                    targetPath: seed.targetPath
+                }
+            });
+        }
+        else if (seed.targetState === 'inaccessible') {
+            findings.push({
+                repairKind: 'hard-failure',
+                message: `Runtime seed target ${seed.targetPath} exists but is not accessible to devuser.`,
+                path: seed.targetPath
+            });
+        }
+    }
+    if (!snapshot.aliasesReadable) {
+        findings.push({
+            repairKind: 'hard-failure',
+            message: 'Sandbox shell aliases are not readable by devuser.',
+            path: '/home/devuser/.bash_aliases'
+        });
+    }
+    if (snapshot.codex) {
+        if (!snapshot.codex.commandAvailable) {
+            findings.push({
+                repairKind: 'hard-failure',
+                message: 'Codex is not available on PATH inside the sandbox.'
+            });
+        }
+        if (!snapshot.codex.stateWritable) {
+            findings.push({
+                repairKind: 'permissions',
+                message: 'Codex state directory is not writable by devuser.',
+                path: '/home/devuser/.codex'
+            });
+        }
+        if (snapshot.codex.promptsSourceExists && !snapshot.codex.promptsValid) {
+            findings.push({
+                repairKind: 'builtin-link',
+                message: 'Codex prompts link does not point to the workspace commands directory.',
+                path: '/home/devuser/.codex/prompts'
+            });
+        }
+    }
+    const seen = new Set();
+    return findings.filter((finding) => {
+        const key = findingKey(finding);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function inspectContainer(engine, container, runFn) {
+    const raw = runFn(engine, 'docker', ['inspect', container]);
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) || !parsed[0] || typeof parsed[0] !== 'object') {
+        throw new Error(`Unable to inspect sandbox container '${container}'.`);
+    }
+    return parsed[0];
+}
+function probe(engine, container, script, args, runOkFn, user = 'devuser') {
+    return runOkFn(engine, 'docker', [
+        'exec', '--user', user, container, 'sh', '-c', script, 'agent-infra-recovery', ...args
+    ]);
+}
+function normalizeMountSource(engine, source) {
+    const normalized = toEnginePath(engine, source).replace(/\\/g, '/').replace(/\/+$/, '');
+    return /^[A-Za-z]:\//.test(normalized)
+        ? `${normalized[0].toLowerCase()}${normalized.slice(1)}`
+        : normalized;
+}
+function sourceCandidates(engine, hostPath) {
+    const candidates = [hostPath];
+    try {
+        candidates.push(fs.realpathSync(hostPath));
+    }
+    catch {
+        // The access check below reports a missing or inaccessible host source.
+    }
+    return [...new Set(candidates.map((candidate) => normalizeMountSource(engine, candidate)))];
+}
+function sameHostSource(left, right) {
+    try {
+        const leftStat = fs.statSync(left, { bigint: true });
+        const rightStat = fs.statSync(right, { bigint: true });
+        return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
+    }
+    catch {
+        return false;
+    }
+}
+function hostSourceAccessible(hostPath, writable) {
+    try {
+        fs.accessSync(hostPath, fs.constants.R_OK | (writable ? fs.constants.W_OK : 0));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function expectedMounts(params) {
+    const { config, branch, actualMounts } = params;
+    const tools = resolveTools(config);
+    const core = sandboxCoreBindMounts(config, branch).map((mount) => ({
+        path: mount.containerPath,
+        expectedType: 'bind',
+        hostPaths: mount.hostPaths,
+        expectedRW: !mount.readOnly
+    }));
+    const live = tools.flatMap((tool) => (tool.hostLiveMounts ?? []).flatMap(({ hostPath, containerSubpath }) => {
+        const destination = path.posix.join(tool.containerMount, containerSubpath);
+        if (!fs.existsSync(hostPath) && !actualMounts.has(destination))
+            return [];
+        return [{
+                path: destination,
+                expectedType: 'bind',
+                hostPaths: [hostPath],
+                expectedRW: true
+            }];
+    }));
+    const persistentTools = tools
+        .filter((tool) => !tool.tmpfs && actualMounts.has(tool.containerMount))
+        .map((tool) => ({
+        path: tool.containerMount,
+        expectedType: 'bind',
+        hostPaths: toolConfigDirCandidates(tool, config.project, branch),
+        expectedRW: true
+    }));
+    const staging = tools.flatMap((tool) => (tool.tmpfs?.seed ?? []).flatMap((seedEntry, index) => {
+        const stagingPath = `/run/agent-infra/tmpfs-seeds/${tool.id}/${index}`;
+        if (!actualMounts.has(stagingPath))
+            return [];
+        return [{
+                path: stagingPath,
+                expectedType: 'bind',
+                hostPaths: toolConfigDirCandidates(tool, config.project, branch)
+                    .map((candidate) => path.join(candidate, seedEntry)),
+                expectedRW: false
+            }];
+    }));
+    return [
+        ...core,
+        ...persistentTools,
+        ...live,
+        ...staging,
+        ...tools
+            .filter((tool) => tool.tmpfs)
+            .map((tool) => ({
+            path: tool.containerMount,
+            expectedType: 'tmpfs',
+            hostPaths: [],
+            expectedRW: true
+        }))
+    ];
+}
+function targetState(engine, container, seed, runOkFn) {
+    const exists = probe(engine, container, 'test -e "$1" || test -L "$1"', [seed.targetPath], runOkFn);
+    if (!exists)
+        return 'missing';
+    const compatible = probe(engine, container, 'if test -d "$1"; then test -d "$2"; else test -f "$2"; fi', [seed.stagingPath, seed.targetPath], runOkFn);
+    if (!compatible)
+        return 'wrong-type';
+    const readable = runOkFn(engine, 'docker', [
+        'exec', '--user', 'devuser', container, 'test', '-r', seed.targetPath
+    ]);
+    const writable = runOkFn(engine, 'docker', [
+        'exec', '--user', 'devuser', container, 'test', '-w', seed.targetPath
+    ]);
+    return readable && writable ? 'ok' : 'inaccessible';
+}
+export function collectSandboxRecoverySnapshot(params) {
+    const runFn = params.deps?.run ?? runEngine;
+    const runOkFn = params.deps?.runOk ?? runOkEngine;
+    const inspection = inspectContainer(params.engine, params.container, runFn);
+    const mounts = Array.isArray(inspection.Mounts) ? inspection.Mounts : [];
+    const mountsByDestination = new Map(mounts.flatMap((mount) => typeof mount.Destination === 'string'
+        ? [[mount.Destination, mount]]
+        : []));
+    const declaredTmpfs = inspection.HostConfig?.Tmpfs;
+    if (declaredTmpfs && typeof declaredTmpfs === 'object' && !Array.isArray(declaredTmpfs)) {
+        for (const [destination, rawOptions] of Object.entries(declaredTmpfs)) {
+            if (mountsByDestination.has(destination) || typeof rawOptions !== 'string')
+                continue;
+            const options = rawOptions.split(',').map((option) => option.trim());
+            mountsByDestination.set(destination, {
+                Type: 'tmpfs',
+                Source: '',
+                Destination: destination,
+                RW: !options.includes('ro')
+            });
+        }
+    }
+    const tools = resolveTools(params.config);
+    const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
+        const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
+        return {
+            toolId: seed.toolId,
+            containerMount: seed.containerMount,
+            stagingPath: seed.stagingPath,
+            targetPath: seed.targetPath,
+            mounted,
+            targetState: mounted
+                ? targetState(params.engine, params.container, seed, runOkFn)
+                : 'missing'
+        };
+    });
+    const tmpfs = tools.filter((tool) => tool.tmpfs).map((tool) => ({
+        path: tool.containerMount,
+        permissionsOk: probe(params.engine, params.container, 'test "$(stat -c %u:%g:%a -- "$1")" = "$(id -u devuser):$(id -g devuser):700"', [tool.containerMount], runOkFn),
+        writable: probe(params.engine, params.container, 'probe="$1/.agent-infra-ready-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"', [tool.containerMount], runOkFn)
+    }));
+    const labels = inspection.Config?.Labels ?? {};
+    const branchLabel = labels[sandboxBranchLabel(params.config)];
+    const hasCodex = tools.some((tool) => tool.id === 'codex');
+    const mountSnapshots = expectedMounts({
+        config: params.config,
+        branch: params.branch,
+        engine: params.engine,
+        actualMounts: mountsByDestination
+    }).map((expected) => {
+        const actual = mountsByDestination.get(expected.path);
+        const actualSource = typeof actual?.Source === 'string' ? actual.Source : null;
+        const actualSourceCandidates = actualSource === null
+            ? []
+            : sourceCandidates(params.engine, actualSource);
+        const matchedHostPath = expected.hostPaths.find((hostPath) => sourceCandidates(params.engine, hostPath).some((candidate) => actualSourceCandidates.includes(candidate))
+            || (actualSource !== null && sameHostSource(hostPath, actualSource)));
+        const sourceMatches = expected.expectedType === 'tmpfs'
+            ? actualSource === '' || actualSource === null
+            : matchedHostPath !== undefined;
+        return {
+            path: expected.path,
+            expectedType: expected.expectedType,
+            actualType: typeof actual?.Type === 'string' ? actual.Type : null,
+            expectedSource: expected.hostPaths[0]
+                ? normalizeMountSource(params.engine, expected.hostPaths[0])
+                : null,
+            actualSource,
+            sourceMatches,
+            expectedRW: expected.expectedRW,
+            actualRW: typeof actual?.RW === 'boolean' ? actual.RW : null,
+            sourceAccessible: expected.expectedType === 'tmpfs'
+                ? true
+                : matchedHostPath !== undefined
+                    && hostSourceAccessible(matchedHostPath, expected.expectedRW)
+        };
+    });
+    return {
+        identityOk: typeof inspection.Id === 'string'
+            && inspection.Id.length > 0
+            && branchLabel === params.branch,
+        mounts: mountSnapshots,
+        tmpfs,
+        seeds,
+        aliasesReadable: probe(params.engine, params.container, 'test -r "$1"', ['/home/devuser/.bash_aliases'], runOkFn),
+        codex: hasCodex
+            ? {
+                commandAvailable: probe(params.engine, params.container, 'command -v codex', [], runOkFn),
+                stateWritable: probe(params.engine, params.container, 'probe="$1/.agent-infra-codex-state-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"', ['/home/devuser/.codex'], runOkFn),
+                promptsSourceExists: probe(params.engine, params.container, 'test -d "$1"', ['/workspace/.codex/commands'], runOkFn),
+                promptsValid: probe(params.engine, params.container, 'test "$(readlink -- "$1")" = "$2"', ['/home/devuser/.codex/prompts', '/workspace/.codex/commands'], runOkFn)
+            }
+            : undefined
+    };
+}
+export function prepareTmpfsMounts(params) {
+    const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+    for (const mountPath of params.mountPaths) {
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'root', params.container, 'chown', 'devuser:', '--', mountPath
+        ]);
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'root', params.container, 'chmod', '0700', '--', mountPath
+        ]);
+    }
+}
+export function hydrateTmpfsSeedEntries(params) {
+    const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+    for (const entry of params.entries) {
+        if (params.replace) {
+            runVerboseFn(params.engine, 'docker', [
+                'exec', '--user', 'devuser', params.container, 'rm', '-rf', '--', entry.targetPath
+            ]);
+        }
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'mkdir', '-p',
+            entry.targetPath.slice(0, entry.targetPath.lastIndexOf('/'))
+        ]);
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'cp', '-R', '--',
+            entry.stagingPath, entry.targetPath
+        ]);
+    }
+    validateTmpfsSeedEntries(params);
+}
+export function validateTmpfsSeedEntries(params) {
+    const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+    const runOkFn = params.deps?.runOk ?? runOkEngine;
+    for (const entry of params.entries) {
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'diff', '-qr', '--',
+            entry.stagingPath, entry.targetPath
+        ]);
+        const readable = runOkFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'test', '-r', entry.targetPath
+        ]);
+        const writable = runOkFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'test', '-w', entry.targetPath
+        ]);
+        if (!readable || !writable) {
+            throw new Error(`Hydrated seed target ${entry.targetPath} is not writable by devuser.`);
+        }
+    }
+}
+function mountedSeeds(snapshot) {
+    return snapshot.seeds.filter((seed) => seed.mounted).map((seed) => ({
+        toolId: seed.toolId,
+        containerMount: seed.containerMount ?? seed.targetPath.slice(0, seed.targetPath.lastIndexOf('/')),
+        stagingPath: seed.stagingPath,
+        targetPath: seed.targetPath
+    }));
+}
+function repairFindings(params) {
+    const permissionPaths = params.findings
+        .filter((finding) => finding.repairKind === 'permissions' && finding.path)
+        .map((finding) => finding.path);
+    prepareTmpfsMounts({
+        engine: params.engine,
+        container: params.container,
+        mountPaths: [...new Set(permissionPaths)],
+        deps: params.deps
+    });
+    const missingSeeds = params.findings.flatMap((finding) => finding.repairKind === 'missing-seed' && finding.seed ? [finding.seed] : []);
+    hydrateTmpfsSeedEntries({
+        engine: params.engine,
+        container: params.container,
+        entries: missingSeeds,
+        replace: true,
+        deps: params.deps
+    });
+    const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+    if (params.findings.some((finding) => finding.repairKind === 'builtin-link')) {
+        runVerboseFn(params.engine, 'docker', [
+            'exec', '--user', 'devuser', params.container, 'ln', '-sfn',
+            '/workspace/.codex/commands', '/home/devuser/.codex/prompts'
+        ]);
+    }
+}
+function describeFindings(findings) {
+    return findings.map((finding) => finding.message).join(' ');
+}
+function assess(params) {
+    const snapshot = collectSandboxRecoverySnapshot(params);
+    return { snapshot, findings: classifySandboxRecovery(snapshot) };
+}
+export function assertFreshSandboxReady(params) {
+    validateTmpfsSeedEntries({
+        engine: params.engine,
+        container: params.container,
+        entries: params.copiedEntries,
+        deps: params.deps
+    });
+    const { findings } = assess(params);
+    if (findings.length > 0) {
+        throw new Error(`Fresh sandbox readiness check failed: ${describeFindings(findings)}`);
+    }
+}
+export async function ensureSandboxReady(params) {
+    const deps = params.deps;
+    const startFn = deps?.start ?? startSandboxContainer;
+    const warnings = [];
+    let failure = null;
+    try {
+        if (!params.row.running) {
+            startFn(params.engine, params.row.name);
+            const initial = assess({
+                config: params.config,
+                engine: params.engine,
+                branch: params.branch,
+                container: params.row.name,
+                deps
+            });
+            if (initial.findings.some((finding) => finding.repairKind === 'hard-failure')) {
+                throw new Error(describeFindings(initial.findings.filter((finding) => finding.repairKind === 'hard-failure')));
+            }
+            const tools = resolveTools(params.config);
+            prepareTmpfsMounts({
+                engine: params.engine,
+                container: params.row.name,
+                mountPaths: tools.filter((tool) => tool.tmpfs).map((tool) => tool.containerMount),
+                deps
+            });
+            hydrateTmpfsSeedEntries({
+                engine: params.engine,
+                container: params.row.name,
+                entries: mountedSeeds(initial.snapshot),
+                replace: true,
+                deps
+            });
+            let final = assess({
+                config: params.config,
+                engine: params.engine,
+                branch: params.branch,
+                container: params.row.name,
+                deps
+            });
+            if (!final.findings.some((finding) => finding.repairKind === 'hard-failure')) {
+                repairFindings({
+                    engine: params.engine,
+                    container: params.row.name,
+                    findings: final.findings,
+                    deps
+                });
+                final = assess({
+                    config: params.config,
+                    engine: params.engine,
+                    branch: params.branch,
+                    container: params.row.name,
+                    deps
+                });
+            }
+            if (final.findings.length > 0) {
+                throw new Error(describeFindings(final.findings));
+            }
+            return { container: params.row.name, path: 'recovered', warnings };
+        }
+        const initial = assess({
+            config: params.config,
+            engine: params.engine,
+            branch: params.branch,
+            container: params.row.name,
+            deps
+        });
+        if (initial.findings.length === 0) {
+            return { container: params.row.name, path: 'healthy', warnings };
+        }
+        if (initial.findings.some((finding) => finding.repairKind === 'hard-failure')) {
+            throw new Error(describeFindings(initial.findings));
+        }
+        let current = initial;
+        const permissionFindings = current.findings.filter((finding) => finding.repairKind === 'permissions');
+        if (permissionFindings.length > 0) {
+            repairFindings({
+                engine: params.engine,
+                container: params.row.name,
+                findings: permissionFindings,
+                deps
+            });
+            current = assess({
+                config: params.config,
+                engine: params.engine,
+                branch: params.branch,
+                container: params.row.name,
+                deps
+            });
+            if (current.findings.some((finding) => finding.repairKind === 'hard-failure'
+                || finding.repairKind === 'permissions')) {
+                throw new Error(describeFindings(current.findings));
+            }
+        }
+        repairFindings({
+            engine: params.engine,
+            container: params.row.name,
+            findings: current.findings,
+            deps
+        });
+        const final = assess({
+            config: params.config,
+            engine: params.engine,
+            branch: params.branch,
+            container: params.row.name,
+            deps
+        });
+        if (final.findings.length > 0) {
+            throw new Error(describeFindings(final.findings));
+        }
+        return { container: params.row.name, path: 'recovered', warnings };
+    }
+    catch (error) {
+        failure = error instanceof Error ? error : new Error(String(error));
+    }
+    const dataBoundary = 'The existing container writable layer, ordinary /tmp data, processes, tmux sessions, and RAM state may be lost by replacement; worktree and host-managed sandbox data are preserved.';
+    if (!params.allowRecreate || !params.recreate) {
+        throw new Error(`Sandbox recovery failed: ${failure.message} ${dataBoundary} Re-run with --recreate to authorize container-only replacement.`);
+    }
+    const warning = `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
+    warnings.push(warning);
+    (params.writeWarning ?? ((message) => process.stderr.write(`${message}\n`)))(warning);
+    await params.recreate(params.branch);
+    const rows = (deps?.fetchRows ?? fetchSandboxRows)(params.engine, sandboxLabel(params.config), sandboxBranchLabel(params.config));
+    const replacement = selectSandboxContainer([...rows.running, ...rows.nonRunning], containerNameCandidates(params.config, params.branch));
+    if (!replacement?.running) {
+        throw new Error('Replacement sandbox container was not found in a running state.');
+    }
+    const final = assess({
+        config: params.config,
+        engine: params.engine,
+        branch: params.branch,
+        container: replacement.name,
+        deps
+    });
+    if (final.findings.length > 0) {
+        throw new Error(`Replacement sandbox readiness check failed: ${describeFindings(final.findings)}`);
+    }
+    return { container: replacement.name, path: 'recreated', warnings };
+}
+//# sourceMappingURL=recovery.js.map

package/dist/lib/sandbox/task-resolver.js

@@ -1,8 +1,9 @@
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { isRemovedHashShortIdInput } from '../task/short-id.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const SHORT_ID_RE = /^#?\d+$/;
+const SHORT_ID_RE = /^\d+$/;
 const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
 function resolveShortIdStrict(arg, repoRoot) {
     const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
@@ -39,6 +40,9 @@ function resolveBranchFromTaskContent(content, taskId) {
     throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
 export function resolveTaskBranch(arg, repoRoot) {
+    if (isRemovedHashShortIdInput(arg)) {
+        throw new Error(`Invalid task short id '${arg}': task short ids must use bare digits`);
+    }
     if (SHORT_ID_RE.test(arg)) {
         const taskId = resolveShortIdStrict(arg, repoRoot);
         const content = readTaskContent(repoRoot, taskId);

package/dist/lib/sandbox/tools.js

@@ -1,5 +1,24 @@
+import path from 'node:path';
 import { safeNameCandidates, sanitizeBranchName } from './constants.js';
 import { hostJoin } from './engines/wsl2-paths.js';
+export function tmpfsSeedStagingPath(toolId, index) {
+    return `/run/agent-infra/tmpfs-seeds/${toolId}/${index}`;
+}
+export function tmpfsSeedTargetPath(containerMount, entry) {
+    const normalized = path.posix.normalize(entry);
+    if (path.posix.isAbsolute(entry) || normalized === '..' || normalized.startsWith('../')) {
+        throw new Error(`tmpfs seed entry must stay within ${containerMount}: ${entry}`);
+    }
+    return path.posix.join(containerMount, normalized);
+}
+export function declaredTmpfsSeedEntries(tools) {
+    return tools.flatMap((tool) => (tool.tmpfs?.seed ?? []).map((entry, index) => ({
+        toolId: tool.id,
+        containerMount: tool.containerMount,
+        stagingPath: tmpfsSeedStagingPath(tool.id, index),
+        targetPath: tmpfsSeedTargetPath(tool.containerMount, entry)
+    })));
+}
 const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 function createBuiltinTools(home, project) {
     return {

package/dist/lib/server/protocol.js

@@ -20,16 +20,16 @@ export function commandHelp() {
         '/sandbox ls',
         '/sandbox show {ref}',
         '/sandbox vm status',
-        '/task decisions {ref}',
-        '/task log {ref}',
+        '/task decisions [--task {ref}] [--item {selector}]',
+        '/task log [--task {ref}]',
         '/task ls',
-        '/task show {ref}',
-        '/task status {ref}',
+        '/task show [--task {ref}]',
+        '/task status [--task {ref}]',
         'Write:',
         '/sandbox create {ref}',
         '/sandbox start {ref}',
         'Exec:',
-        '/decide {task-ref} {HD-id} {decision}',
+        '/decide [--task {ref}] --item {ordinal|ledger-id} [--needs-implementation true|false] {decision}',
         '/run create-task {description}',
         '/run {skill} {task-ref}'
     ].join('\n');