@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/dist/lib/sandbox/recovery.js

@@ -1,13 +1,53 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxRuntimeCapabilityLabel } from './constants.js';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxRuntimeCapabilityLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel } from './constants.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
+import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
+import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
 import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
 import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
+import { processIdentityMatches } from '../server/process-state.js';
+function ensureSandboxControlBroker(params) {
+    const control = sandboxControlPaths({
+        base: params.config.controlBase ?? path.join(params.config.home, '.agent-infra', 'sandbox-control'),
+        project: params.config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    if (!fs.existsSync(control.manifestPath))
+        return;
+    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
+    const brokerPath = path.join(control.root, 'broker.json');
+    try {
+        const broker = JSON.parse(fs.readFileSync(brokerPath, 'utf8'));
+        if (broker.version === 1
+            && typeof broker.pid === 'number'
+            && typeof broker.startTime === 'string'
+            && broker.token === manifest.token
+            && processIdentityMatches({ version: 1, pid: broker.pid, startTime: broker.startTime }))
+            return;
+    }
+    catch {
+        // A missing, stale, or malformed broker record is replaced below.
+    }
+    fs.rmSync(brokerPath, { force: true });
+    const directory = path.dirname(fileURLToPath(import.meta.url));
+    const extension = path.extname(fileURLToPath(import.meta.url));
+    const internalCli = path.resolve(directory, '..', '..', 'bin', `internal-cli${extension}`);
+    const child = spawn(process.execPath, [internalCli, 'sandbox-control', 'serve', '--manifest', control.manifestPath], { cwd: params.config.repoRoot, detached: true, stdio: 'ignore' });
+    child.once('error', () => {
+        // Readiness remains fail-closed; a later control request reports the
+        // unavailable broker without turning this detached spawn into an
+        // unhandled process error.
+    });
+    child.unref();
+}
 function findingKey(finding) {
     return `${finding.repairKind}:${finding.path ?? finding.seed?.targetPath ?? finding.message}`;
 }
@@ -156,7 +196,28 @@ function hostSourceAccessible(hostPath, writable) {
 }
 function expectedMounts(params) {
     const { config, branch, tools, actualMounts } = params;
-    const core = sandboxCoreBindMounts(config, branch).map((mount) => ({
+    const view = sandboxWorkspaceViewPaths({
+        base: config.workspaceViewBase ?? path.join(config.home, '.agent-infra', 'workspace-views'),
+        project: config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    const control = sandboxControlPaths({
+        base: config.controlBase ?? path.join(config.home, '.agent-infra', 'sandbox-control'),
+        project: config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    const core = sandboxCoreBindMounts(config, branch, {
+        workspaceViewRoot: view.root,
+        controlDir: control.channelDir,
+        ...(params.workspace.mode === 'task-bound'
+            ? {
+                taskSource: assertSandboxTaskSource(config.repoRoot, params.workspace.taskId),
+                taskId: params.workspace.taskId
+            }
+            : {})
+    }).map((mount) => ({
         path: mount.containerPath,
         expectedType: 'bind',
         hostPaths: mount.hostPaths,
@@ -248,6 +309,7 @@ export function collectSandboxRecoverySnapshot(params) {
         }
     }
     const capabilityPlan = createSandboxCapabilityPlan(params.config);
+    const workspace = params.workspace ?? { mode: 'branch-only' };
     const tools = [...capabilityPlan.tools];
     const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
         const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
@@ -269,6 +331,10 @@ export function collectSandboxRecoverySnapshot(params) {
     }));
     const labels = inspection.Config?.Labels ?? {};
     const branchLabel = labels[sandboxBranchLabel(params.config)];
+    const containerWorkspace = parseSandboxWorkspaceIdentity(labels, {
+        mode: sandboxWorkspaceModeLabel(params.config),
+        taskId: sandboxTaskIdLabel(params.config)
+    });
     const selectedToolIds = new Set(tools.map((tool) => tool.id));
     const enforceCanonicalPlan = params.config.agentClientSource === 'canonical';
     const unexpectedCapabilityMounts = enforceCanonicalPlan
@@ -280,6 +346,8 @@ export function collectSandboxRecoverySnapshot(params) {
     const mountSnapshots = expectedMounts({
         config: params.config,
         branch: params.branch,
+        container: params.container,
+        workspace,
         tools,
         actualMounts: mountsByDestination
     }).map((expected) => {
@@ -313,7 +381,8 @@ export function collectSandboxRecoverySnapshot(params) {
     return {
         identityOk: typeof inspection.Id === 'string'
             && inspection.Id.length > 0
-            && branchLabel === params.branch,
+            && branchLabel === params.branch
+            && sameSandboxWorkspaceIdentity(containerWorkspace, workspace),
         runtimeCapabilityOk: enforceCanonicalPlan
             ? labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature
             : undefined,
@@ -424,14 +493,51 @@ function assess(params) {
     const snapshot = collectSandboxRecoverySnapshot(params);
     return { snapshot, findings: classifySandboxRecovery(snapshot) };
 }
-export function assertFreshSandboxReady(params) {
+function canRetryFreshReadiness(findings) {
+    return findings.length > 0 && findings.every((finding) => finding.repairKind === 'hard-failure'
+        && finding.path !== undefined
+        && (finding.path.startsWith('/workspace/.agents/workspace')
+            || finding.path === '/home/devuser/.host-shell-config'
+            || finding.path === '/home/devuser/.bash_aliases'));
+}
+export async function assertFreshSandboxReady(params) {
     validateTmpfsSeedEntries({
         engine: params.engine,
         container: params.container,
         entries: params.copiedEntries,
         deps: params.deps
     });
-    const { findings } = assess(params);
+    let { findings } = assess(params);
+    if (canRetryFreshReadiness(findings)) {
+        const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+        runVerboseFn(params.engine, 'docker', ['restart', params.container]);
+        prepareTmpfsMounts({
+            engine: params.engine,
+            container: params.container,
+            mountPaths: resolveTools(params.config)
+                .filter((tool) => tool.tmpfs)
+                .map((tool) => tool.containerMount),
+            deps: params.deps
+        });
+        hydrateTmpfsSeedEntries({
+            engine: params.engine,
+            container: params.container,
+            entries: params.copiedEntries,
+            replace: true,
+            deps: params.deps
+        });
+        let retried = assess(params);
+        if (!retried.findings.some((finding) => finding.repairKind === 'hard-failure')) {
+            repairFindings({
+                engine: params.engine,
+                container: params.container,
+                findings: retried.findings,
+                deps: params.deps
+            });
+            retried = assess(params);
+        }
+        findings = retried.findings;
+    }
     if (findings.length > 0) {
         throw new Error(`Fresh sandbox readiness check failed: ${describeFindings(findings)}`);
     }
@@ -441,6 +547,11 @@ export async function ensureSandboxReady(params) {
     const startFn = deps?.start ?? startSandboxContainer;
     const warnings = [];
     let failure = null;
+    ensureSandboxControlBroker({
+        config: params.config,
+        container: params.row.name,
+        workspace: params.workspace ?? { mode: 'branch-only' }
+    });
     try {
         if (!params.row.running) {
             startFn(params.engine, params.row.name);
@@ -448,6 +559,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -472,6 +584,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -486,6 +599,7 @@ export async function ensureSandboxReady(params) {
                     config: params.config,
                     engine: params.engine,
                     branch: params.branch,
+                    workspace: params.workspace,
                     container: params.row.name,
                     deps
                 });
@@ -499,6 +613,7 @@ export async function ensureSandboxReady(params) {
             config: params.config,
             engine: params.engine,
             branch: params.branch,
+            workspace: params.workspace,
             container: params.row.name,
             deps
         });
@@ -521,6 +636,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -539,6 +655,7 @@ export async function ensureSandboxReady(params) {
             config: params.config,
             engine: params.engine,
             branch: params.branch,
+            workspace: params.workspace,
             container: params.row.name,
             deps
         });
@@ -557,6 +674,11 @@ export async function ensureSandboxReady(params) {
     const warning = `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
     warnings.push(warning);
     (params.writeWarning ?? ((message) => process.stderr.write(`${message}\n`)))(warning);
+    const runVerboseFn = deps?.runVerbose ?? runVerboseEngine;
+    if (params.row.running) {
+        runVerboseFn(params.engine, 'docker', ['stop', params.row.name]);
+    }
+    runVerboseFn(params.engine, 'docker', ['rm', params.row.name]);
     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));
@@ -567,6 +689,7 @@ export async function ensureSandboxReady(params) {
         config: params.config,
         engine: params.engine,
         branch: params.branch,
+        workspace: params.workspace,
         container: replacement.name,
         deps
     });

package/dist/lib/sandbox/redaction.js

@@ -0,0 +1,12 @@
+const SENSITIVE_OUTPUT_PATTERNS = [
+    { pattern: /\{[^{}]*"claudeAiOauth"[\s\S]*?\}\s*\}/g, replacement: '[REDACTED credentials blob]' },
+    { pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g, replacement: '[REDACTED claude token]' },
+    { pattern: /gh[psoru]_[A-Za-z0-9]{30,}/g, replacement: '[REDACTED github token]' },
+    { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/gi, replacement: 'Bearer [REDACTED]' }
+];
+export function redactCommandError(text) {
+    if (!text || typeof text !== 'string')
+        return '';
+    return SENSITIVE_OUTPUT_PATTERNS.reduce((result, { pattern, replacement }) => result.replace(pattern, replacement), text);
+}
+//# sourceMappingURL=redaction.js.map

package/dist/lib/sandbox/runtimes/base.dockerfile

@@ -64,69 +64,9 @@ RUN printf '%s\n' \
       'set -g mouse on' \
       'set -g status-interval 1' \
       'set -g status-right-length 80' \
-      "set -g status-right '#(/usr/local/bin/cc-token-status) | %H:%M'" \
+      "set -g status-right '%H:%M'" \
     > /etc/tmux.conf
 
-RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/cc-token-status
-#!/bin/sh
-set -eu
-
-SETTINGS_FILE="/home/devuser/.claude/settings.json"
-if [ -r "$SETTINGS_FILE" ] && jq -e '
-  def has_nonempty($v):
-    if ($v | type) == "string" then ($v | gsub("^\\s+|\\s+$"; "") | length) > 0 else false end;
-  (if type == "object" then . else {} end) as $settings
-  | (if ($settings.env | type) == "object" then $settings.env else {} end) as $env
-  | has_nonempty($env.ANTHROPIC_AUTH_TOKEN)
-    or has_nonempty($env.ANTHROPIC_API_KEY)
-    or has_nonempty($settings.apiKeyHelper)
-' "$SETTINGS_FILE" >/dev/null 2>&1; then
-  exit 0
-fi
-
-CRED_FILE="/home/devuser/.claude/.credentials.json"
-[ -r "$CRED_FILE" ] || exit 0
-
-EXPIRES_MS=$(jq -r '(.claudeAiOauth.expiresAt // .expiresAt) // empty' "$CRED_FILE" 2>/dev/null || true)
-case "$EXPIRES_MS" in
-  ''|*[!0-9]*) exit 0 ;;
-esac
-
-NOW_MS=$(($(date +%s) * 1000))
-DIFF_MS=$((EXPIRES_MS - NOW_MS))
-DIFF_S=$((DIFF_MS / 1000))
-
-DIM='#[fg=colour245]'
-YELLOW='#[fg=yellow]'
-YELLOW_BOLD='#[fg=yellow,bold]'
-RED_BOLD='#[fg=red,bold]'
-RED_REV='#[fg=red,reverse]'
-RESET='#[default]'
-
-if [ "$DIFF_S" -le 0 ]; then
-  ELAPSED=$(( -DIFF_S ))
-  M=$((ELAPSED / 60))
-  printf '%sClaude Code auth EXPIRED %dm ago%s' "$RED_REV" "$M" "$RESET"
-elif [ "$DIFF_S" -lt 60 ]; then
-  printf '%sClaude Code auth expires in %ds%s' "$RED_BOLD" "$DIFF_S" "$RESET"
-elif [ "$DIFF_S" -lt 300 ]; then
-  M=$((DIFF_S / 60))
-  S=$((DIFF_S % 60))
-  printf '%sClaude Code auth expires in %dm %ds%s' "$RED_BOLD" "$M" "$S" "$RESET"
-elif [ "$DIFF_S" -lt 1800 ]; then
-  M=$((DIFF_S / 60))
-  printf '%sClaude Code auth expires in %dm%s' "$YELLOW_BOLD" "$M" "$RESET"
-elif [ "$DIFF_S" -lt 3600 ]; then
-  M=$((DIFF_S / 60))
-  printf '%sClaude Code auth expires in %dm%s' "$YELLOW" "$M" "$RESET"
-else
-  TOTAL_M=$((DIFF_S / 60))
-  H=$((TOTAL_M / 60))
-  M=$((TOTAL_M % 60))
-  printf '%sClaude Code auth expires in %dh %dm%s' "$DIM" "$H" "$M" "$RESET"
-fi
-SCRIPT
-
 RUN cat > /usr/local/bin/sandbox-dotfiles-link <<'SCRIPT' && chmod +x /usr/local/bin/sandbox-dotfiles-link
 #!/bin/sh
 # Mirror /dotfiles/ tree as symlinks under $HOME/, overwriting any image-baked
@@ -136,23 +76,34 @@ set -eu
 DOTFILES_SRC=/dotfiles
 [ -d "$DOTFILES_SRC" ] || exit 0
 
-cd "$DOTFILES_SRC"
-find . -type f -print | while IFS= read -r rel; do
-  rel=${rel#./}
-  target="$HOME/$rel"
-  case "$rel" in
+is_dotfiles_excluded() {
+  candidate=$1
+  case "$candidate" in
     .ssh|.ssh/*|\
     .gnupg|.gnupg/*|\
-    .claude|.claude/*|\
-    .codex|.codex/*|\
-    .gemini|.gemini/*|\
-    .config/opencode|.config/opencode/*|\
-    .local/share/opencode|.local/share/opencode/*|\
     .host-shell-config|.host-shell-config/*|\
     .gitconfig|.gitignore_global|.stCommitMsg|.bash_aliases|README.md)
-      continue ;;
+      return 0 ;;
   esac
 
+  [ -r /etc/agent-infra/dotfiles-exclusions ] || return 1
+  while IFS= read -r prefix; do
+    [ -n "$prefix" ] || continue
+    case "$candidate" in
+      "$prefix"|"$prefix"/*) return 0 ;;
+    esac
+  done < /etc/agent-infra/dotfiles-exclusions
+  return 1
+}
+
+cd "$DOTFILES_SRC"
+find . -type f -print | while IFS= read -r rel; do
+  rel=${rel#./}
+  target="$HOME/$rel"
+  if is_dotfiles_excluded "$rel"; then
+    continue
+  fi
+
   mkdir -p "$(dirname "$target")"
   if [ -d "$target" ] && [ ! -L "$target" ]; then
     printf 'sandbox-dotfiles-link: skipping %s (existing directory; use nested path like %s/<file> instead)\n' "$target" "$rel" >&2
@@ -198,8 +149,7 @@ fi
 exec tmux new-session -s "$SESSION"
 SCRIPT
 
-RUN test -s /usr/local/bin/cc-token-status && test -x /usr/local/bin/cc-token-status && \
-    test -s /usr/local/bin/sandbox-dotfiles-link && test -x /usr/local/bin/sandbox-dotfiles-link && \
+RUN test -s /usr/local/bin/sandbox-dotfiles-link && test -x /usr/local/bin/sandbox-dotfiles-link && \
     test -s /usr/local/bin/sandbox-tmux-entry && test -x /usr/local/bin/sandbox-tmux-entry
 
 ENV LANG=en_US.UTF-8

package/dist/lib/sandbox/workspace-identity.js

@@ -0,0 +1,95 @@
+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+$/;
+function stripQuotes(value) {
+    return value.replace(/^(?:"([^"]*)"|'([^']*)')$/, '$1$2');
+}
+function taskBranch(taskMd, taskId) {
+    const content = fs.readFileSync(taskMd, 'utf8');
+    const value = content.match(/^branch:\s*(.+)$/m)?.[1]?.trim()
+        ?? content.match(/^- \*\*(?:分支|Branch)\*\*：[ \t]*`?([^`\n]+)`?$/m)?.[1]?.trim();
+    if (!value)
+        throw new Error(`Task ${taskId} has no branch field in task.md`);
+    return stripQuotes(value);
+}
+function activeRegistry(repoRoot) {
+    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', '.short-ids.json');
+    if (!fs.existsSync(registryPath))
+        return {};
+    const value = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Active task short-id registry is invalid');
+    }
+    const ids = 'ids' in value && value.ids && typeof value.ids === 'object' && !Array.isArray(value.ids)
+        ? value.ids
+        : value;
+    return Object.fromEntries(Object.entries(ids).filter((entry) => SHORT_ID_RE.test(entry[0]) && typeof entry[1] === 'string' && TASK_ID_RE.test(entry[1])));
+}
+function taskIdentity(repoRoot, taskId, registry) {
+    const taskMd = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+    if (!fs.existsSync(taskMd))
+        throw new Error(`Active task not found: ${taskId}`);
+    const shortIds = Object.entries(registry).filter(([, id]) => id === taskId).map(([shortId]) => shortId);
+    if (shortIds.length !== 1) {
+        throw new Error(`Task ${taskId} must have exactly one active short id`);
+    }
+    return { mode: 'task-bound', taskId, shortId: shortIds[0] };
+}
+export function resolveSandboxTarget(requestedRef, repoRoot) {
+    if (isRemovedHashShortIdInput(requestedRef)) {
+        throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);
+    }
+    const registry = activeRegistry(repoRoot);
+    if (SHORT_ID_RE.test(requestedRef)) {
+        const matchingShortIds = Object.keys(registry).filter((shortId) => shortId === requestedRef || Number(shortId) === Number(requestedRef));
+        if (matchingShortIds.length > 1) {
+            throw new Error(`Short id '${requestedRef}' is ambiguous in active task registry`);
+        }
+        const canonicalShortId = matchingShortIds[0];
+        const taskId = canonicalShortId ? registry[canonicalShortId] : undefined;
+        if (!taskId)
+            throw new Error(`Short id '${requestedRef}' not found in active task registry`);
+        const workspace = taskIdentity(repoRoot, taskId, registry);
+        return { requestedRef, branch: taskBranch(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), taskId), workspace };
+    }
+    if (TASK_ID_RE.test(requestedRef)) {
+        const workspace = taskIdentity(repoRoot, requestedRef, registry);
+        return { requestedRef, branch: taskBranch(path.join(repoRoot, '.agents', 'workspace', 'active', requestedRef, 'task.md'), requestedRef), workspace };
+    }
+    const activeRoot = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const matches = fs.existsSync(activeRoot)
+        ? fs.readdirSync(activeRoot, { withFileTypes: true }).flatMap((entry) => {
+            if (!entry.isDirectory() || !TASK_ID_RE.test(entry.name))
+                return [];
+            const taskMd = path.join(activeRoot, entry.name, 'task.md');
+            if (!fs.existsSync(taskMd))
+                return [];
+            return taskBranch(taskMd, entry.name) === requestedRef ? [entry.name] : [];
+        })
+        : [];
+    if (matches.length > 1) {
+        throw new Error(`SANDBOX_TASK_IDENTITY_AMBIGUOUS: branch '${requestedRef}' is bound to multiple active tasks`);
+    }
+    if (matches.length === 1) {
+        const taskId = matches[0];
+        return { requestedRef, branch: requestedRef, workspace: taskIdentity(repoRoot, taskId, registry) };
+    }
+    return { requestedRef, branch: requestedRef, workspace: { mode: 'branch-only' } };
+}
+export function parseSandboxWorkspaceIdentity(labels, keys) {
+    const mode = labels[keys.mode];
+    const taskId = labels[keys.taskId];
+    if (mode === 'branch-only' && taskId === undefined)
+        return { mode: 'branch-only' };
+    if (mode === 'task-bound' && typeof taskId === 'string' && TASK_ID_RE.test(taskId)) {
+        return { mode: 'task-bound', taskId };
+    }
+    return { mode: 'legacy-invalid' };
+}
+export function sameSandboxWorkspaceIdentity(left, right) {
+    return left.mode === right.mode
+        && (left.mode !== 'task-bound' || (right.mode === 'task-bound' && left.taskId === right.taskId));
+}
+//# sourceMappingURL=workspace-identity.js.map

package/dist/lib/sandbox/workspace-view.js

@@ -0,0 +1,103 @@
+import { createHash, randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+export function sandboxWorkspaceViewPaths(params) {
+    const identityKey = params.identity.mode === 'task-bound'
+        ? `task-bound:${params.identity.taskId}`
+        : 'branch-only';
+    const digest = createHash('sha256').update(identityKey).digest('hex').slice(0, 16);
+    const projectRoot = path.resolve(params.base, params.project);
+    const root = path.resolve(projectRoot, params.container, digest);
+    return {
+        root,
+        taskMountPath: params.identity.mode === 'task-bound'
+            ? path.join(root, 'active', params.identity.taskId)
+            : null
+    };
+}
+export function sandboxControlPaths(params) {
+    const identityKey = params.identity.mode === 'task-bound'
+        ? `task-bound:${params.identity.taskId}`
+        : 'branch-only';
+    const digest = createHash('sha256').update(identityKey).digest('hex').slice(0, 16);
+    const root = path.resolve(params.base, params.project, params.container, digest);
+    return { root, channelDir: path.join(root, 'channel'), manifestPath: path.join(root, 'manifest.json') };
+}
+function assertSafeDirectory(directory, expectedBase) {
+    const relative = path.relative(expectedBase, directory);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Sandbox workspace view escapes its configured root: ${directory}`);
+    }
+    if (fs.existsSync(directory) && fs.lstatSync(directory).isSymbolicLink()) {
+        throw new Error(`Sandbox workspace view must not be a symbolic link: ${directory}`);
+    }
+}
+export function assertSandboxTaskSource(repoRoot, taskId) {
+    if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    const activeRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace', 'active'));
+    const source = path.join(activeRoot, taskId);
+    const stat = fs.lstatSync(source);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} must be a real directory`);
+    }
+    const canonical = fs.realpathSync.native(source);
+    if (path.dirname(canonical) !== activeRoot) {
+        throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} escapes the active workspace`);
+    }
+    return canonical;
+}
+export function materializeSandboxWorkspaceView(params) {
+    const projectRoot = path.resolve(params.base, params.project);
+    const { root, taskMountPath } = sandboxWorkspaceViewPaths(params);
+    assertSafeDirectory(projectRoot, path.resolve(params.base));
+    assertSafeDirectory(root, projectRoot);
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    for (const state of ['active', 'completed', 'blocked', 'archive']) {
+        const stateDir = path.join(root, state);
+        assertSafeDirectory(stateDir, root);
+        fs.rmSync(stateDir, { recursive: true, force: true });
+        fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+    }
+    const active = path.join(root, 'active');
+    const registry = {
+        version: 1,
+        ids: params.identity.mode === 'task-bound'
+            ? { [params.identity.shortId]: params.identity.taskId }
+            : {}
+    };
+    fs.writeFileSync(path.join(active, '.short-ids.json'), `${JSON.stringify(registry)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600
+    });
+    if (taskMountPath) {
+        assertSafeDirectory(taskMountPath, active);
+        fs.mkdirSync(taskMountPath, { recursive: true, mode: 0o700 });
+    }
+    return { root, taskMountPath };
+}
+export function materializeSandboxControl(params) {
+    const { root, channelDir, manifestPath } = sandboxControlPaths(params);
+    assertSafeDirectory(root, path.resolve(params.base));
+    for (const queue of ['requests', 'responses']) {
+        const directory = path.join(channelDir, queue);
+        assertSafeDirectory(directory, root);
+        fs.rmSync(directory, { recursive: true, force: true });
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    }
+    const token = randomBytes(32).toString('hex');
+    const manifest = {
+        version: 1,
+        repoRoot: fs.realpathSync.native(params.repoRoot),
+        project: params.project,
+        container: params.container,
+        branch: params.branch,
+        mode: params.identity.mode,
+        taskId: params.identity.mode === 'task-bound' ? params.identity.taskId : null,
+        token,
+        channelDir
+    };
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`, { mode: 0o600 });
+    return { channelDir, manifestPath, token };
+}
+//# sourceMappingURL=workspace-view.js.map