@fitlab-ai/agent-infra 0.8.0 → 0.8.1

package/dist/lib/task/commands/status.js

@@ -1,23 +1,26 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { commandForEngine } from "../../sandbox/shell.js";
 import { resolveTaskRef } from "../resolve-ref.js";
 import { enumerateArtifacts } from "../artifacts.js";
 import { parseTaskFrontmatter, extractTitle } from "../frontmatter.js";
 import { loadShortIdByTaskId } from "../short-id.js";
+import { parseActivityLog, pairEntries } from "./log.js";
 const USAGE = `Usage: ai task status <N | #N | TASK-id>
 
-Prints an aggregated "health check" view for a task: header, metadata, an
-artifacts summary, git branch state, and best-effort GitHub issue/PR status.
+Prints an aggregated "health check" view for a task: header, metadata,
+artifacts, workflow/runtime execution state, and git branch state.
   <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
-Git and Platform rows are best-effort: a failed git/gh call degrades that row to
-'-' without failing the command.
+Git rows are best-effort: a failed git call degrades that row to '-' without
+failing the command.
 `;
 const DASH = '-';
 function makeRunner(cwd) {
     return (file, args) => execFileSync(file, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
 }
-// Run `run` and swallow any failure into null, so a single failing git/gh call
+// Run `run` and swallow any failure into null, so a single failing git call
 // degrades only its own field instead of aborting the whole view.
 function tryRun(run, file, args) {
     try {
@@ -37,9 +40,7 @@ const METADATA_KEYS = [
     'branch',
     'assigned_to',
     'created_at',
-    'updated_at',
-    'issue_number',
-    'pr_status'
+    'updated_at'
 ];
 function collectMetadata(fm) {
     return METADATA_KEYS.map((key) => [key, fm[key] ? fm[key] : DASH]);
@@ -136,39 +137,123 @@ function collectGit(frontmatterBranch, run) {
     }
     return { current, frontmatter, match, exists, uncommitted, aheadBehind };
 }
-function collectPlatform(fm, run) {
-    let issue = DASH;
-    if (fm.issue_number && /^\d+$/.test(fm.issue_number)) {
-        const out = tryRun(run, 'gh', ['issue', 'view', fm.issue_number, '--json', 'state,labels']);
-        if (out !== null) {
-            try {
-                const data = JSON.parse(out);
-                const labels = Array.isArray(data.labels)
-                    ? data.labels.map((label) => label.name).join(', ')
-                    : '';
-                issue = labels ? `${data.state} [${labels}]` : `${data.state}`;
-            }
-            catch {
-                issue = DASH;
+const STALE_MS = 60 * 60 * 1000;
+function parseActivityTime(value) {
+    const epoch = Date.parse(value.replace(' ', 'T'));
+    return Number.isFinite(epoch) ? epoch : Number.NaN;
+}
+function collectWorkflow(content, now = new Date()) {
+    const parsed = parseActivityLog(content);
+    if (!parsed.sectionFound || parsed.entries.length === 0) {
+        return { state: 'unknown', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH };
+    }
+    const rows = pairEntries(parsed.entries);
+    const latest = rows.at(-1);
+    if (!latest) {
+        return { state: 'unknown', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH };
+    }
+    const inProgress = latest.started !== '' && latest.done === '';
+    const state = inProgress ? 'in-progress' : latest.done ? 'idle' : 'unknown';
+    let stale = DASH;
+    if (inProgress) {
+        const started = parseActivityTime(latest.started);
+        stale = Number.isFinite(started) ? (now.getTime() - started > STALE_MS ? 'yes' : 'no') : 'unknown';
+    }
+    return {
+        state,
+        step: latest.step || DASH,
+        agent: latest.agent || DASH,
+        startedAt: latest.started || DASH,
+        doneAt: latest.done || DASH,
+        stale
+    };
+}
+function latestRunRecord(taskDir) {
+    const runsDir = path.join(taskDir, 'runs');
+    if (!fs.existsSync(runsDir))
+        return null;
+    const candidates = [];
+    for (const entry of fs.readdirSync(runsDir)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const filePath = path.join(runsDir, entry);
+        const stat = fs.statSync(filePath);
+        if (stat.isFile())
+            candidates.push({ path: filePath, mtimeMs: stat.mtimeMs });
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const candidate of candidates) {
+        try {
+            const data = JSON.parse(fs.readFileSync(candidate.path, 'utf8'));
+            if (typeof data?.run_id === 'string' &&
+                typeof data?.engine === 'string' &&
+                typeof data?.container === 'string' &&
+                typeof data?.run_dir === 'string') {
+                return {
+                    run_id: data.run_id,
+                    engine: data.engine,
+                    container: data.container,
+                    run_dir: data.run_dir,
+                    status_file: typeof data.status_file === 'string' ? data.status_file : `${data.run_dir}/status`,
+                    log_file: typeof data.log_file === 'string' ? data.log_file : `${data.run_dir}/output.log`
+                };
             }
         }
+        catch {
+            // Ignore malformed local records and try the next newest file.
+        }
     }
-    let pr = DASH;
-    if (fm.pr_status === 'created' && fm.pr_number && /^\d+$/.test(fm.pr_number)) {
-        const out = tryRun(run, 'gh', ['pr', 'view', fm.pr_number, '--json', 'state,statusCheckRollup']);
-        if (out !== null) {
-            try {
-                const data = JSON.parse(out);
-                const rollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : [];
-                const passed = rollup.filter((check) => check.conclusion === 'SUCCESS' || check.state === 'SUCCESS').length;
-                pr = rollup.length > 0 ? `${data.state}, checks: ${passed}/${rollup.length}` : `${data.state}`;
-            }
-            catch {
-                pr = DASH;
+    return null;
+}
+function readRuntimeFile(record, filePath, run) {
+    const command = commandForEngine(record.engine, 'docker', ['exec', record.container, 'cat', filePath]);
+    const output = tryRun(run, command.cmd, command.args);
+    return output === null ? null : output.trim();
+}
+function runtimeValue(record, name, run) {
+    const output = readRuntimeFile(record, `${record.run_dir}/${name}`, run);
+    return output ? output : DASH;
+}
+function collectRuntime(taskDir, workflow, run) {
+    const record = latestRunRecord(taskDir);
+    if (!record) {
+        return workflow.state === 'in-progress'
+            ? {
+                mode: 'unmanaged',
+                status: 'inferred-from-workflow',
+                run: DASH,
+                tmux: DASH,
+                startedAt: DASH,
+                finishedAt: DASH,
+                exitCode: DASH,
+                log: DASH
             }
-        }
+            : {
+                mode: 'none',
+                status: DASH,
+                run: DASH,
+                tmux: DASH,
+                startedAt: DASH,
+                finishedAt: DASH,
+                exitCode: DASH,
+                log: DASH
+            };
     }
-    return { issue, pr };
+    const status = readRuntimeFile(record, record.status_file, run)?.trim() || 'unknown';
+    const session = runtimeValue(record, 'session', run);
+    const window = runtimeValue(record, 'window', run);
+    const pane = runtimeValue(record, 'pane', run);
+    const tmux = session !== DASH && window !== DASH && pane !== DASH ? `${session}:${window}:${pane}` : DASH;
+    return {
+        mode: 'managed-tmux',
+        status,
+        run: record.run_id,
+        tmux,
+        startedAt: runtimeValue(record, 'started_at', run),
+        finishedAt: runtimeValue(record, 'finished_at', run),
+        exitCode: runtimeValue(record, 'exit_code', run),
+        log: record.log_file
+    };
 }
 // Indent each label/value pair by two spaces and pad labels to a common width so
 // every section reads as an aligned "key   value" block.
@@ -189,6 +274,24 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
+    lines.push('', 'Workflow', ...renderPairs([
+        ['state', model.workflow.state],
+        ['step', model.workflow.step],
+        ['agent', model.workflow.agent],
+        ['started_at', model.workflow.startedAt],
+        ['done_at', model.workflow.doneAt],
+        ['stale', model.workflow.stale]
+    ]));
+    lines.push('', 'Runtime', ...renderPairs([
+        ['mode', model.runtime.mode],
+        ['status', model.runtime.status],
+        ['run', model.runtime.run],
+        ['tmux', model.runtime.tmux],
+        ['started_at', model.runtime.startedAt],
+        ['finished_at', model.runtime.finishedAt],
+        ['exit_code', model.runtime.exitCode],
+        ['log', model.runtime.log]
+    ]));
     lines.push('', 'Git', ...renderPairs([
         ['current', model.git.current],
         ['frontmatter', model.git.frontmatter],
@@ -197,11 +300,6 @@ function renderStatus(model) {
         ['uncommitted', model.git.uncommitted],
         ['ahead/behind', model.git.aheadBehind]
     ]));
-    const issueLabel = model.issueNumber ? `issue #${model.issueNumber}` : 'issue';
-    lines.push('', 'Platform', ...renderPairs([
-        [issueLabel, model.platform.issue],
-        ['pr', model.platform.pr]
-    ]));
     return lines;
 }
 function status(args = []) {
@@ -221,19 +319,20 @@ function status(args = []) {
     const fm = parseTaskFrontmatter(content);
     const run = makeRunner(resolved.repoRoot);
     const artifacts = enumerateArtifacts(resolved.taskDir);
+    const workflow = collectWorkflow(content);
     const model = {
         taskId: resolved.taskId,
         shortId: loadShortIdByTaskId(resolved.repoRoot).get(resolved.taskId) ?? DASH,
         title: extractTitle(content),
-        issueNumber: fm.issue_number && /^\d+$/.test(fm.issue_number) ? fm.issue_number : '',
         metadata: collectMetadata(fm),
         artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
-        git: collectGit(fm.branch ?? '', run),
-        platform: collectPlatform(fm, run)
+        workflow,
+        runtime: collectRuntime(resolved.taskDir, workflow, run),
+        git: collectGit(fm.branch ?? '', run)
     };
     for (const line of renderStatus(model)) {
         process.stdout.write(`${line}\n`);
     }
 }
-export { status, makeRunner, collectMetadata, groupArtifacts, collectGit, collectPlatform, renderStatus, METADATA_KEYS };
+export { status, makeRunner, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, METADATA_KEYS };
 //# sourceMappingURL=status.js.map

package/lib/run/index.ts

@@ -1,6 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { loadServerConfig } from '../server/config.ts';
 import { resolveTaskBranch } from '../sandbox/task-resolver.ts';
-import { runInSandbox } from '../sandbox/capture.ts';
+import { createRunId, runInSandbox, type SandboxRunMetadata } from '../sandbox/capture.ts';
+import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
 import { getSkillRunSpec } from './skills.ts';
 import { runHostCommand, type RunProcessResult } from './host.ts';
@@ -16,19 +19,27 @@ export type SandboxRunRequest = {
   taskRef: string;
   branch: string;
   command: string[];
+  runId?: string;
+};
+
+export type SandboxRunResult = RunProcessResult & {
+  run?: SandboxRunMetadata;
 };
 
 export type RunSkillOptions = {
   command?: Record<string, unknown>;
   repoRoot?: string;
   runHost?: (command: string[]) => Promise<RunProcessResult>;
-  runSandbox?: (request: SandboxRunRequest) => Promise<RunProcessResult>;
+  runSandbox?: (request: SandboxRunRequest) => Promise<SandboxRunResult>;
   writeStdout?: (chunk: string) => void;
   writeStderr?: (chunk: string) => void;
 };
 
 const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>]
 
+Task skills are scheduled inside the sandbox tmux session; ai run returns once
+the tmux window is created.
+
 Examples:
   ai run create-task "describe the task" --tui codex
   ai run code-task #7 --tui codex`;
@@ -78,6 +89,99 @@ function assertAllowedByConfig(skill: string, commandConfig: Record<string, unkn
   }
 }
 
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+
+function readShortIdLength(repoRoot: string): number {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+    const value = cfg?.task?.shortIdLength;
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 1) return value;
+  } catch {
+    // Use the project default when config is absent in lightweight tests.
+  }
+  return 2;
+}
+
+function readActiveShortIdRegistry(repoRoot: string): Record<string, string> {
+  const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', '.short-ids.json');
+  try {
+    const data = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    return data && typeof data === 'object' && data.ids && typeof data.ids === 'object' ? data.ids : {};
+  } catch {
+    return {};
+  }
+}
+
+type ActiveTaskIdentity = {
+  taskId: string;
+  taskDir: string;
+  taskRef: string;
+};
+
+function resolveActiveTaskIdentity(taskRef: string, repoRoot: string): ActiveTaskIdentity | null {
+  let taskId: string | null = null;
+  let resolvedTaskRef = taskRef;
+
+  if (TASK_ID_RE.test(taskRef)) {
+    taskId = taskRef;
+    resolvedTaskRef = loadShortIdByTaskId(repoRoot).get(taskId) ?? taskRef;
+  } else {
+    const normalized = normalizeShortIdInput(taskRef, { shortIdLength: readShortIdLength(repoRoot) });
+    if (normalized.kind !== 'shortId') return null;
+    resolvedTaskRef = normalized.value;
+    taskId = readActiveShortIdRegistry(repoRoot)[normalized.value.slice(1)] ?? null;
+  }
+
+  if (!taskId) return null;
+  const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+  if (!fs.existsSync(path.join(taskDir, 'task.md'))) return null;
+  return { taskId, taskDir, taskRef: resolvedTaskRef };
+}
+
+function formatLocalTimestamp(date: Date = new Date()): string {
+  const pad = (n: number): string => String(n).padStart(2, '0');
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hour = pad(date.getHours());
+  const minute = pad(date.getMinutes());
+  const second = pad(date.getSeconds());
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? '+' : '-';
+  const offsetHour = pad(Math.floor(Math.abs(offsetMinutes) / 60));
+  const offsetMinute = pad(Math.abs(offsetMinutes) % 60);
+  return `${year}-${month}-${day} ${hour}:${minute}:${second}${sign}${offsetHour}:${offsetMinute}`;
+}
+
+function writeRunRecord(params: {
+  identity: ActiveTaskIdentity;
+  run: SandboxRunMetadata;
+  branch: string;
+  command: string[];
+}): void {
+  const runsDir = path.join(params.identity.taskDir, 'runs');
+  fs.mkdirSync(runsDir, { recursive: true });
+  const record = {
+    version: 1,
+    run_id: params.run.runId,
+    task_id: params.identity.taskId,
+    task_ref: params.identity.taskRef,
+    branch: params.branch,
+    engine: params.run.engine,
+    container: params.run.container,
+    run_dir: params.run.runDir,
+    status_file: `${params.run.runDir}/status`,
+    log_file: `${params.run.runDir}/output.log`,
+    created_at: formatLocalTimestamp(),
+    command: params.command
+  };
+  fs.writeFileSync(
+    path.join(runsDir, `${params.run.runId}.json`),
+    `${JSON.stringify(record, null, 2)}\n`,
+    'utf8'
+  );
+}
+
 export async function runSkill(args: string[], options: RunSkillOptions = {}): Promise<number> {
   const parsed = parseRunArgs(args);
   const config = options.command ? null : loadServerConfig({ rootDir: options.repoRoot });
@@ -96,13 +200,22 @@ export async function runSkill(args: string[], options: RunSkillOptions = {}): P
 
   const repoRoot = options.repoRoot ?? config?.repoRoot ?? process.cwd();
   const branch = resolveTaskBranch(parsed.taskRef, repoRoot);
-  const runSandbox = options.runSandbox ?? ((request: SandboxRunRequest) => runInSandbox(request));
-  const result = await runSandbox({ taskRef: parsed.taskRef, branch, command });
+  const identity = resolveActiveTaskIdentity(parsed.taskRef, repoRoot);
+  const runId = identity ? createRunId() : undefined;
+  const writeStdout = options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk));
+  const writeStderr = options.writeStderr ?? ((chunk: string) => process.stderr.write(chunk));
+  const runSandbox =
+    options.runSandbox ??
+    ((request: SandboxRunRequest) => runInSandbox(request));
+  const result = await runSandbox({ taskRef: parsed.taskRef, branch, command, runId });
   if (result.stdout) {
-    (options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk)))(result.stdout);
+    writeStdout(result.stdout);
   }
   if (result.stderr) {
-    (options.writeStderr ?? ((chunk: string) => process.stderr.write(chunk)))(result.stderr);
+    writeStderr(result.stderr);
+  }
+  if ((result.exitCode ?? (result.signal ? 1 : 0)) === 0 && identity && result.run) {
+    writeRunRecord({ identity, run: result.run, branch, command });
   }
   return result.exitCode ?? (result.signal ? 1 : 0);
 }

package/lib/sandbox/capture.ts

@@ -22,22 +22,45 @@ export type SandboxCaptureResult = {
   signal: NodeJS.Signals | null;
   stdout: string;
   stderr: string;
+  run?: SandboxRunMetadata;
+};
+
+export type SandboxRunMetadata = {
+  runId: string;
+  engine: string;
+  container: string;
+  runDir: string;
 };
 
 export type SandboxCaptureOptions = {
   engine?: string;
   repoRoot?: string;
+  runId?: string;
   containerCandidates?: string[];
   rows?: SandboxRow[];
   startContainer?: (name: string) => void;
   spawn?: (file: string, args: string[]) => Promise<SandboxCaptureResult>;
 };
 
-async function spawnCapture(file: string, args: string[]): Promise<SandboxCaptureResult> {
+async function spawnCapture(
+  file: string,
+  args: string[]
+): Promise<SandboxCaptureResult> {
   return new Promise((resolve, reject) => {
     const child = spawn(file, args, { stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let stderr = '';
+    let settled = false;
+    const rejectOnce = (error: unknown): void => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    const resolveOnce = (result: SandboxCaptureResult): void => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
     child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
     child.stdout.on('data', (chunk) => {
@@ -46,11 +69,106 @@ async function spawnCapture(file: string, args: string[]): Promise<SandboxCaptur
     child.stderr.on('data', (chunk) => {
       stderr += chunk;
     });
-    child.on('error', reject);
-    child.on('close', (exitCode, signal) => resolve({ exitCode, signal, stdout, stderr }));
+    child.on('error', rejectOnce);
+    child.on('close', (exitCode, signal) => {
+      resolveOnce({ exitCode, signal, stdout, stderr });
+    });
   });
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export function createRunId(date: Date = new Date()): string {
+  return `run-${date.toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[-:]/g, '').replace('T', '-').replace('Z', '')}-${process.pid}`;
+}
+
+function buildRunScript(params: {
+  command: string[];
+  runDir: string;
+  runId: string;
+}): string {
+  const command = params.command.map(shellQuote).join(' ');
+  const runDir = shellQuote(params.runDir);
+  const runId = shellQuote(params.runId);
+  return `#!/bin/sh
+set -u
+cd /workspace
+date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/started_at
+printf '%s\\n' running > ${runDir}/status
+${command}
+code=$?
+printf '%s\\n' "$code" > ${runDir}/exit_code
+date "+%Y-%m-%d %H:%M:%S%:z" > ${runDir}/finished_at
+if [ "$code" -eq 0 ]; then
+  printf '%s\\n' completed > ${runDir}/status
+else
+  printf '%s\\n' failed > ${runDir}/status
+fi
+printf '\\n[agent-infra] run %s finished with exit code %s\\n' ${runId} "$code"
+exec bash -l
+`;
+}
+
+function buildTmuxLauncher(params: {
+  request: SandboxCaptureRequest;
+  runId: string;
+}): string {
+  const session = 'work';
+  const window = `ai-${params.runId.replace(/^run-/, '').slice(0, 18)}`;
+  const runRoot = '/tmp/agent-infra-runs';
+  const runDir = `${runRoot}/${params.runId}`;
+  const runScript = buildRunScript({ command: params.request.command, runDir, runId: params.runId });
+  const runScriptBase64 = Buffer.from(runScript, 'utf8').toString('base64');
+  const paneCommand = `cd /workspace && ${shellQuote(`${runDir}/run.sh`)}`;
+
+  return `set -eu
+session=${shellQuote(session)}
+window=${shellQuote(window)}
+run_id=${shellQuote(params.runId)}
+run_dir=${shellQuote(runDir)}
+task_ref=${shellQuote(params.request.taskRef)}
+branch=${shellQuote(params.request.branch)}
+
+sandbox-dotfiles-link >/dev/null 2>&1 || true
+mkdir -p "$run_dir"
+printf '%s\\n' pending > "$run_dir/status"
+printf '%s\\n' "$task_ref" > "$run_dir/task_ref"
+printf '%s\\n' "$branch" > "$run_dir/branch"
+printf '%s\\n' ${shellQuote(params.request.command.join(' '))} > "$run_dir/command"
+printf '%s' ${shellQuote(runScriptBase64)} | base64 -d > "$run_dir/run.sh"
+chmod +x "$run_dir/run.sh"
+
+if ! command -v tmux >/dev/null 2>&1; then
+  printf '%s\\n' "tmux is not installed in this sandbox" >&2
+  exit 127
+fi
+
+if ! tmux has-session -t "$session" 2>/dev/null; then
+  tmux new-session -d -s "$session" -n shell
+fi
+
+if [ -n "\${TZ:-}" ]; then
+  tmux set-environment -t "$session" TZ "$TZ" 2>/dev/null || true
+fi
+
+pane=$(tmux new-window -d -P -F '#{pane_id}' -t "$session" -n "$window")
+printf '%s\\n' "$session" > "$run_dir/session"
+printf '%s\\n' "$window" > "$run_dir/window"
+printf '%s\\n' "$pane" > "$run_dir/pane"
+tmux pipe-pane -o -t "$pane" "cat > $run_dir/output.log"
+tmux send-keys -t "$pane" ${shellQuote(paneCommand)} Enter
+
+cat <<EOF
+Started sandbox run $run_id in tmux session '$session', window '$window', pane '$pane'.
+Attach with: ai sandbox enter $task_ref
+Status file: $run_dir/status
+Output log: $run_dir/output.log
+EOF
+`;
+}
+
 export async function runInSandbox(
   request: SandboxCaptureRequest,
   options: SandboxCaptureOptions = {}
@@ -73,12 +191,25 @@ export async function runInSandbox(
   if (!found.running) {
     (options.startContainer ?? ((name: string) => startSandboxContainer(engine, name)))(found.name);
   }
+  const runId = options.runId ?? createRunId();
+  const runDir = `/tmp/agent-infra-runs/${runId}`;
   const dockerArgs = [
     'exec',
     ...terminalEnvFlags(),
     ...hostTimezoneEnvFlags(),
     found.name,
-    ...request.command
+    'bash',
+    '-lc',
+    buildTmuxLauncher({ request, runId })
   ];
-  return (options.spawn ?? spawnCapture)('docker', dockerArgs);
+  const result = await (options.spawn ?? spawnCapture)('docker', dockerArgs);
+  return {
+    ...result,
+    run: {
+      runId,
+      engine,
+      container: found.name,
+      runDir
+    }
+  };
 }

package/lib/sandbox/commands/create.ts

@@ -1438,9 +1438,9 @@ export async function create(args: string[]): Promise<void> {
             if (claudeCodeEntry) {
               ensureClaudeOnboarding(claudeCodeEntry.dir, effectiveConfig.home);
               ensureClaudeSettings(claudeCodeEntry.dir, effectiveConfig.home);
-              // prepareClaudeCredentials wrote the shared credentials file
-              // before this point. If credentials were missing, the
-              // claude-code entry was removed from effectiveResolvedTools.
+              // prepareClaudeCredentials wrote OAuth credentials or confirmed
+              // provider/API settings are enough for Claude Code. If no usable
+              // auth was present, the claude-code entry was removed above.
             }
             const codexEntry = effectiveResolvedTools.find(({ tool }) => tool.id === 'codex');
             if (codexEntry) {

package/lib/sandbox/commands/enter.ts

@@ -9,6 +9,7 @@ import { detectEngine } from '../engine.ts';
 import {
   formatCredentialWarnings,
   formatRemaining,
+  hasClaudeProviderAuth,
   reconcileClaudeCredentials,
   redactCommandError,
   validateClaudeCredentialsEnvOverride
@@ -93,8 +94,12 @@ export function runSandboxInteractive(params: {
 
 export function formatCredentialSyncStatus(
   result: ReturnType<typeof reconcileClaudeCredentials>,
-  isTTY = process.stderr.isTTY
+  isTTY = process.stderr.isTTY,
+  providerAuthAvailable = false
 ): string | null {
+  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';
   }
@@ -158,8 +163,9 @@ export async function enter(args: string[]): Promise<number> {
   if (config.tools.includes('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);
+      const message = formatCredentialSyncStatus(result, process.stderr.isTTY, providerAuthAvailable);
       if (message) {
         process.stderr.write(message);
       }