@fitlab-ai/agent-infra 0.11.6 → 0.11.8

package/lib/sandbox/config.ts

@@ -32,7 +32,7 @@ type WriteStderr = (chunk: string) => unknown;
 type SandboxConfigInput = {
   engine?: SandboxEngineInput;
   runtimes?: string[];
-  tools?: string[];
+  tools?: unknown;
   customTools?: unknown;
   refreshIntervalDays?: unknown;
   dockerfile?: string | null;
@@ -115,10 +115,22 @@ function resolveSandboxToolIds(
   sandbox: SandboxConfigInput,
   defaults: readonly string[]
 ): string[] {
-  if (Array.isArray(sandbox.tools)) {
-    return sandbox.tools.filter((tool): tool is string => typeof tool === 'string');
+  if (sandbox.tools === undefined) {
+    return [...defaults];
   }
-  return [...defaults];
+  if (typeof sandbox.tools !== 'object' || sandbox.tools === null || Array.isArray(sandbox.tools)) {
+    throw new Error('sandbox.tools must be an object when configured');
+  }
+  const tools = sandbox.tools as Record<string, unknown>;
+  if (!Array.isArray(tools.ids)) {
+    throw new Error('sandbox.tools.ids must be an array');
+  }
+  return tools.ids.map((id, index) => {
+    if (typeof id !== 'string') {
+      throw new Error(`sandbox.tools.ids[${index}] must be a string`);
+    }
+    return id;
+  });
 }
 
 export function loadConfig({
@@ -180,7 +192,13 @@ export function loadConfig({
     }
   }
 
-  const customTools = parseCustomTools(sandbox.customTools, { home });
+  const toolsConfig = sandbox.tools && typeof sandbox.tools === 'object' && !Array.isArray(sandbox.tools)
+    ? sandbox.tools as Record<string, unknown>
+    : undefined;
+  if (sandbox.customTools !== undefined) {
+    throw new Error('sandbox.customTools is no longer supported; use sandbox.tools.definitions');
+  }
+  const customTools = parseCustomTools(toolsConfig?.definitions, { home });
   const tools = resolveSandboxToolIds(sandbox, defaults.tools);
 
   return {

package/lib/sandbox/control/server.ts

@@ -272,12 +272,15 @@ function taskCreateDomainEvidence(
     ? output.task as Record<string, unknown> : null;
   const taskId = typeof task?.id === 'string' ? task.id : null;
   const shortId = typeof task?.shortId === 'string' ? task.shortId : null;
-  if (!taskId || !shortId) return { consistent: false };
+  const state = task?.state;
+  if (!taskId || !['active', 'blocked', 'completed', 'archive'].includes(String(state))) return { consistent: false };
+  if (state === 'active' ? !shortId : output.status !== 'no-op' || shortId !== null) return { consistent: false };
   try {
     const resolved = resolveTaskRef(taskId, { repoRoot: manifest.repoRoot });
     const shortIds = loadShortIdByTaskId(manifest.repoRoot);
     return {
-      consistent: resolved.ok && resolved.taskId === taskId && resolved.state === 'active' && shortIds.get(taskId) === shortId,
+      consistent: resolved.ok && resolved.taskId === taskId && resolved.state === state
+        && (state === 'active' ? shortIds.get(taskId) === shortId : !shortIds.has(taskId)),
       taskId,
       shortId
     };

package/lib/sandbox/git-metadata.ts

@@ -0,0 +1,66 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const SANDBOX_GIT_COMMON_DIR = '/run/agent-infra/git';
+
+export type SandboxGitMetadata = Readonly<{
+  commonDir: string;
+  worktreeGitFile: string;
+  worktreeGitFileContent: string;
+}>;
+
+function gitText(worktreeRoot: string, args: string[]): string {
+  const env = { ...process.env };
+  for (const key of [
+    'GIT_DIR',
+    'GIT_COMMON_DIR',
+    'GIT_WORK_TREE',
+    'GIT_INDEX_FILE',
+    'GIT_PREFIX',
+    'GIT_NAMESPACE',
+    'GIT_OBJECT_DIRECTORY',
+    'GIT_CEILING_DIRECTORIES',
+    'GIT_DISCOVERY_ACROSS_FILESYSTEM'
+  ]) {
+    delete env[key];
+  }
+  return execFileSync('git', ['-C', worktreeRoot, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env
+  }).trim();
+}
+
+export function resolveSandboxGitMetadata(
+  worktreeRoot: string,
+  controlDir: string
+): SandboxGitMetadata {
+  const commonDir = fs.realpathSync.native(gitText(worktreeRoot, [
+    'rev-parse', '--path-format=absolute', '--git-common-dir'
+  ]));
+  const gitDir = fs.realpathSync.native(gitText(worktreeRoot, ['rev-parse', '--absolute-git-dir']));
+  const relativeGitDir = path.relative(commonDir, gitDir);
+  if (path.isAbsolute(relativeGitDir) || relativeGitDir.startsWith(`..${path.sep}`) || relativeGitDir === '..') {
+    throw new Error('SANDBOX_GIT_METADATA_INVALID: worktree git directory is outside its common directory');
+  }
+
+  const containerGitDir = relativeGitDir === '.'
+    ? SANDBOX_GIT_COMMON_DIR
+    : path.posix.join(SANDBOX_GIT_COMMON_DIR, ...relativeGitDir.split(path.sep));
+  return {
+    commonDir,
+    worktreeGitFile: path.join(controlDir, 'workspace.git'),
+    worktreeGitFileContent: `gitdir: ${containerGitDir}\n`
+  };
+}
+
+export function materializeSandboxGitMetadata(
+  worktreeRoot: string,
+  controlDir: string
+): SandboxGitMetadata {
+  const metadata = resolveSandboxGitMetadata(worktreeRoot, controlDir);
+  fs.mkdirSync(controlDir, { recursive: true });
+  fs.writeFileSync(metadata.worktreeGitFile, metadata.worktreeGitFileContent, 'utf8');
+  return metadata;
+}

package/lib/sandbox/index.ts

@@ -20,7 +20,7 @@ Commands:
   rm <branch | TASK-id> | --unbound | --purge
                                Remove one sandbox; use a full TASK-id for task-bound
                                cleanup and a branch for branch-only cleanup. --unbound
-                               removes discovered task-bound and branch-only sandboxes.
+                               removes sandboxes not bound to an active task short id.
   start [--recreate] <branch | TASK-id | N>
                                Verify or recover an existing sandbox container;
                                optionally replace only the container on failure

package/lib/sandbox/mounts.ts

@@ -7,6 +7,7 @@ import {
 } from './constants.ts';
 import type { SandboxConfig } from './config.ts';
 import { sandboxWorkspaceViewStatePaths } from './workspace-view.ts';
+import { SANDBOX_GIT_COMMON_DIR } from './git-metadata.ts';
 
 export type SandboxBindMountDeclaration = {
   hostPaths: string[];
@@ -26,6 +27,8 @@ export function sandboxCoreBindMounts(
     workspaceViewRoot: string;
     controlDir: string;
     controlStatusDir: string;
+    gitCommonDir?: string;
+    worktreeGitFile?: string;
     runtimeDir?: string;
     taskSources?: string[];
     taskId?: string;
@@ -46,7 +49,17 @@ export function sandboxCoreBindMounts(
           readOnly: true
         }
   );
+  if (Boolean(overrides.gitCommonDir) !== Boolean(overrides.worktreeGitFile)) {
+    throw new Error('SANDBOX_GIT_METADATA_INCOMPLETE');
+  }
+  const gitCommonMount = overrides.gitCommonDir
+    ? { hostPaths: [overrides.gitCommonDir], containerPath: SANDBOX_GIT_COMMON_DIR, readOnly: false }
+    : null;
+  const worktreeGitFileMount = overrides.worktreeGitFile
+    ? { hostPaths: [overrides.worktreeGitFile], containerPath: '/workspace/.git', readOnly: true }
+    : null;
   const mounts: SandboxBindMountDeclaration[] = [
+    ...(gitCommonMount ? [gitCommonMount] : []),
     {
       hostPaths: overrides.worktree
         ? [overrides.worktree]
@@ -54,6 +67,7 @@ export function sandboxCoreBindMounts(
       containerPath: '/workspace',
       readOnly: false
     },
+    ...(worktreeGitFileMount ? [worktreeGitFileMount] : []),
     ...workspaceMounts,
   ];
   if (taskBound) {

package/lib/sandbox/recovery.ts

@@ -24,6 +24,7 @@ import type {
 import type { SandboxConfig } from './config.ts';
 import { toEnginePath } from './engines/wsl2-paths.ts';
 import { sandboxCoreBindMounts } from './mounts.ts';
+import { resolveSandboxGitMetadata } from './git-metadata.ts';
 import {
   assertSandboxTaskSource,
   sandboxControlPaths,
@@ -764,7 +765,19 @@ function expectedMounts(params: {
     ? recoveryTaskSources(config.repoRoot, params.workspace.taskId)
     : null;
   const taskId = params.workspace.mode === 'task-bound' ? params.workspace.taskId : null;
+  const worktrees = worktreeDirCandidates(config, branch).filter((candidate) =>
+    fs.existsSync(path.join(candidate, '.git'))
+  );
+  const gitMetadata = worktrees.length === 1
+    ? resolveSandboxGitMetadata(worktrees[0]!, control.channelDir)
+    : null;
   const core = sandboxCoreBindMounts(config, branch, {
+    ...(gitMetadata === null
+      ? {}
+      : {
+        gitCommonDir: gitMetadata.commonDir,
+        worktreeGitFile: gitMetadata.worktreeGitFile
+      }),
     workspaceViewRoot: view.root,
     controlDir: control.channelDir,
     controlStatusDir: control.statusDir,

package/lib/sandbox/removal.ts

@@ -22,6 +22,7 @@ import { run, runEngine, runOk, runOkEngine, runSafe, runSafeEngine } from './sh
 import {
   parseSandboxWorkspaceIdentity,
   resolveSandboxCleanupTarget,
+  resolveSandboxTarget,
   sameSandboxWorkspaceIdentity,
   type SandboxCleanupTarget,
   type SandboxWorkspaceKey
@@ -1112,7 +1113,10 @@ async function rmUnbound(
   tools: SandboxTool[],
   options: { dryRun: boolean; assumeYes: boolean }
 ): Promise<void> {
-  return rmUnboundCore(config, tools, options);
+  return withRepositoryMutationLock(
+    config.repoRoot,
+    () => rmUnboundCore(config, tools, options)
+  );
 }
 
 async function rmUnboundCore(
@@ -1127,32 +1131,66 @@ async function rmUnboundCore(
     sandboxBranchLabel(config),
     { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) }
   );
-  const rows = [...listed.running, ...listed.nonRunning];
+  const discovered = [...listed.running, ...listed.nonRunning];
+  const branchMismatches: Array<{ container: string; labelBranch: string; taskBranch: string }> = [];
+  const classified = discovered.map((row) => {
+    if (!row.branch) return { row, protected: true, cleanupTarget: null };
+    if (row.workspaceMode === 'task-bound' && row.taskId) {
+      try {
+        resolveSandboxTarget(row.taskId, config.repoRoot);
+        return { row, protected: true, cleanupTarget: null };
+      } catch {
+        try {
+          const cleanupTarget = resolveSandboxCleanupTarget(row.taskId, config.repoRoot, { allowProtected: true });
+          if (cleanupTarget.taskState === 'blocked'
+            || cleanupTarget.taskState === 'completed'
+            || cleanupTarget.taskState === 'archive') {
+            if (row.branch !== cleanupTarget.branch) {
+              branchMismatches.push({ container: row.name, labelBranch: row.branch, taskBranch: cleanupTarget.branch });
+              return { row, protected: true, cleanupTarget: null };
+            }
+            const activeBranchTarget = resolveSandboxTarget(cleanupTarget.branch, config.repoRoot);
+            if (activeBranchTarget.workspace.mode === 'branch-only') {
+              return { row, protected: false, cleanupTarget };
+            }
+          }
+        } catch {
+          // An unresolved task identity has no active short-id evidence, so keep it out of bulk cleanup.
+        }
+        return { row, protected: true, cleanupTarget: null };
+      }
+    }
+    if (row.workspaceMode !== 'branch-only') return { row, protected: true, cleanupTarget: null };
+    const cleanupTarget = resolveSandboxCleanupTarget(row.branch, config.repoRoot);
+    return cleanupTarget.workspace.mode === 'branch-only'
+      ? { row, protected: false, cleanupTarget }
+      : { row, protected: true, cleanupTarget: null };
+  });
+  const protectedBranches = new Set(classified
+    .filter((entry) => entry.protected)
+    .map(({ row }) => row.branch));
+  const targets = classified
+    .filter((entry) => !entry.protected && !protectedBranches.has(entry.row.branch) && entry.cleanupTarget)
+    .map(({ row, cleanupTarget }) => ({
+      row,
+      cleanupTarget: cleanupTarget!,
+      target: resolveRmTarget(config, tools, cleanupTarget!, { discoveredContainers: [row.name] })
+    }));
   p.intro(pc.cyan(`Removing sandboxes for ${config.project}`));
+  for (const mismatch of branchMismatches) {
+    p.log.warn(`Skipping task-bound sandbox '${mismatch.container}': container branch '${mismatch.labelBranch}' differs from task record branch '${mismatch.taskBranch}'. Inspect the task record and container labels before retrying cleanup.`);
+  }
   if (options.dryRun) {
-    p.outro(`Dry run: ${rows.length} sandbox(es) found, nothing deleted`);
+    p.outro(`Dry run: ${targets.length} sandbox(es) found, nothing deleted`);
     return;
   }
-  for (const row of rows) {
-    if (!row.branch) {
-      runSafeEngine(engine, 'docker', ['rm', '-f', row.name]);
-      continue;
-    }
-    const cleanupTarget: SandboxCleanupTarget = {
-      requestedRef: row.branch,
-      branch: row.branch,
-      workspace: row.workspaceMode === 'task-bound' && row.taskId
-        ? { mode: 'task-bound', taskId: row.taskId }
-        : { mode: 'branch-only' },
-      taskState: 'branch-only'
-    };
-    const target = resolveRmTarget(config, tools, cleanupTarget, { discoveredContainers: [row.name] });
-    await rmOne(config, tools, cleanupTarget.branch, {
+  for (const { row, cleanupTarget, target } of targets) {
+    await runRmOneUnderRepositoryLock(config, tools, cleanupTarget.branch, {
       assumeYes: options.assumeYes,
       target,
       cleanupTarget
     });
   }
-  p.outro(pc.green(`Removed ${rows.length} sandbox(es)`));
+  p.outro(pc.green(`Removed ${targets.length} sandbox(es)`));
 }
 export { authorizeWorktrees, rmOne, rmPurge, rmUnbound };

package/lib/sandbox/tool-types.ts

@@ -16,7 +16,7 @@ type SandboxTool = {
   pathRewriteFiles?: string[];
   hostLiveMounts?: Array<{ hostPath: string; containerSubpath: string }>;
   postSetupCmds?: string[];
-  tmpfs?: { size?: string; seed?: string[] };
+  tmpfs?: { size?: string; seed?: string[]; exec?: boolean };
 };
 
 type SandboxAlias = Readonly<{

package/lib/sandbox/tools.ts

@@ -85,6 +85,16 @@ function asOptionalNonEmptyString(value: unknown, field: string, context: string
   return value;
 }
 
+function asOptionalBoolean(value: unknown, field: string, context: string): boolean | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== 'boolean') {
+    throw new Error(`${context}: field "${field}" must be a boolean when provided`);
+  }
+  return value;
+}
+
 function asStringRecord(value: unknown, field: string, context: string): Record<string, string> | undefined {
   if (value === undefined) {
     return undefined;
@@ -193,18 +203,20 @@ function parseTmpfs(value: unknown, context: string): SandboxTool['tmpfs'] {
   if (!isPlainObject(value)) {
     throw new Error(`${context}: field "tmpfs" must be an object when provided`);
   }
+  const exec = asOptionalBoolean(value.exec, 'tmpfs.exec', context);
   return {
     size: asOptionalNonEmptyString(value.size, 'tmpfs.size', context),
-    seed: asStringArray(value.seed, 'tmpfs.seed', context)
+    seed: asStringArray(value.seed, 'tmpfs.seed', context),
+    ...(exec === undefined ? {} : { exec })
   };
 }
 
 export function parseCustomTool(
   entry: unknown,
   index: number,
-  options: { home: string }
+  options: { home: string },
+  context = `customTools[${index}]`
 ): SandboxTool {
-  const context = `customTools[${index}]`;
   if (!isPlainObject(entry)) {
     throw new Error(`${context} must be an object`);
   }
@@ -243,13 +255,30 @@ export function parseCustomTool(
 }
 
 export function parseCustomTools(value: unknown, options: { home: string }): SandboxTool[] {
-  if (value === undefined || value === null) {
+  if (value === undefined) {
     return [];
   }
-  if (!Array.isArray(value)) {
-    throw new Error('sandbox: "customTools" must be an array');
+  if (!isPlainObject(value)) {
+    throw new Error('sandbox.tools.definitions must be an object');
   }
-  return value.map((entry, index) => parseCustomTool(entry, index, options));
+  return Object.entries(value).map(([id, definition], index) => {
+    const context = `sandbox.tools.definitions.${id}`;
+    if (!TOOL_ID_PATTERN.test(id)) {
+      throw new Error(`${context}: tool id must match ${TOOL_ID_PATTERN.source}`);
+    }
+    if (!isPlainObject(definition)) {
+      throw new Error(`${context} must be an object`);
+    }
+    if (Object.hasOwn(definition, 'id')) {
+      throw new Error(`${context}.id is not allowed; the definition key is the tool id`);
+    }
+    return parseCustomTool(
+      { ...definition, id },
+      index,
+      options,
+      context
+    );
+  });
 }
 
 export function resolveTools(config: ToolsConfig): SandboxTool[] {

package/lib/server/config.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { resolvePrimaryWorktreeRoot } from '../git/primary-worktree.ts';
 
 export type ServerLogConfig = {
   path: string;
@@ -52,17 +52,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-// Daemon runtime state (log + PID) lives OUTSIDE the repo, under the user's home
-// directory, keyed by the .airc.json "project" AND a stable hash of the repo
-// root path:
-//   ~/.agent-infra/logs/<project>/<repo-hash>/server.log
-//   ~/.agent-infra/run/<project>/<repo-hash>/server.pid
-// The <project> segment groups a project's checkouts for readability; the
-// <repo-hash> segment guarantees that two checkouts/worktrees of the same
-// project (same "project" but different absolute path) get ISOLATED runtime
-// dirs, so they never read/control each other's daemon. Using os.homedir() +
-// path.join keeps this correct on Windows too (C:\Users\<name>\.agent-infra\...).
-// An explicit log.path in server.json/.local/env still overrides the log default.
+// Runtime state is shared by all worktrees through the primary checkout.
 function resolveProjectKey(repoRoot: string): string {
   try {
     const airc = JSON.parse(
@@ -77,13 +67,8 @@ function resolveProjectKey(repoRoot: string): string {
   return path.basename(repoRoot);
 }
 
-// Short, stable, filesystem-safe discriminator for a checkout's absolute path.
-function repoKey(repoRoot: string): string {
-  return createHash('sha256').update(repoRoot).digest('hex').slice(0, 12);
-}
-
-function runtimePath(repoRoot: string, projectKey: string, kind: 'logs' | 'run', file: string): string {
-  return path.join(homedir(), '.agent-infra', kind, projectKey, repoKey(repoRoot), file);
+function runtimePath(projectKey: string, kind: 'logs' | 'run', file: string): string {
+  return path.join(homedir(), '.agent-infra', kind, projectKey, file);
 }
 
 function detectRepoRoot(): string {
@@ -185,7 +170,7 @@ export function validateServerConfig(committed: Record<string, unknown>): Server
 }
 
 export function loadServerConfig({ rootDir }: { rootDir?: string } = {}): ServerConfig {
-  const repoRoot = rootDir ?? detectRepoRoot();
+  const repoRoot = resolvePrimaryWorktreeRoot(rootDir ?? detectRepoRoot());
   const agentsDir = path.join(repoRoot, '.agents');
 
   const committed = readJsonIfPresent(path.join(agentsDir, 'server.json'));
@@ -205,18 +190,11 @@ export function loadServerConfig({ rootDir }: { rootDir?: string } = {}): Server
   const projectKey = resolveProjectKey(repoRoot);
 
   const log = isPlainObject(merged.log) ? merged.log : {};
-  // No explicit log.path → default under ~/.agent-infra/logs/<project>/.
-  // Explicit relative path resolves against the repo root; absolute is used as-is.
-  const explicitPath = typeof log.path === 'string' ? log.path : null;
-  const resolvedLogPath = explicitPath === null
-    ? runtimePath(repoRoot, projectKey, 'logs', 'server.log')
-    : (path.isAbsolute(explicitPath) ? explicitPath : path.join(repoRoot, explicitPath));
-
   return {
     repoRoot,
-    pidFile: runtimePath(repoRoot, projectKey, 'run', 'server.pid'),
+    pidFile: runtimePath(projectKey, 'run', 'server.pid'),
     log: {
-      path: resolvedLogPath,
+      path: runtimePath(projectKey, 'logs', 'server.log'),
       rotateAtBytes: typeof log.rotateAtBytes === 'number' ? log.rotateAtBytes : DEFAULT_ROTATE_BYTES
     },
     heartbeatMs: typeof merged.heartbeatMs === 'number' ? merged.heartbeatMs : DEFAULT_SERVER_CONFIG.heartbeatMs,

package/lib/server/daemon.ts

@@ -83,7 +83,7 @@ export function createMessageDispatcher(options: MessageDispatcherOptions): (mes
           chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
           throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
         },
-        (emit) => runAiImpl(plan.argv, { onChunk: emit }),
+        (emit) => runAiImpl(plan.argv, { onChunk: emit, cwd: options.config.repoRoot }),
         (outbound) => replyOutbound(message, outbound)
       );
     }
@@ -100,15 +100,17 @@ export function createMessageDispatcher(options: MessageDispatcherOptions): (mes
 //   - runDaemon() awaits a shutdown promise that only resolves once a
 //     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
 //     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon(): Promise<void> {
+export async function runDaemon({ rootDir }: { rootDir?: string } = {}): Promise<void> {
   let config;
   try {
-    config = loadServerConfig();
+    config = loadServerConfig({ rootDir });
   } catch (error) {
     process.stderr.write(`${errorMessage(error)}\n`);
     process.exit(1);
   }
 
+  process.chdir(config.repoRoot);
+
   const logger = createLogger(config.log);
   logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
   const ownStartTime = getProcessStartTime(process.pid);

package/lib/server/process-control.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.ts';
 import type { ServerConfig } from './config.ts';
@@ -91,7 +92,7 @@ export async function start({ foreground = false }: StartOptions = {}): Promise<
   }
 
   if (foreground) {
-    await runDaemon();
+    await runDaemon({ rootDir: config.repoRoot });
     return;
   }
 
@@ -103,8 +104,9 @@ export async function start({ foreground = false }: StartOptions = {}): Promise<
   // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
   // (node --experimental-strip-types ./bin/cli.ts) and the built path
   // (node dist/bin/cli.js) both work.
-  const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+  const child = spawn(process.execPath, [...process.execArgv, path.resolve(cliEntry), 'server', '__daemon'], {
     detached: true,
+    cwd: config.repoRoot,
     stdio: 'ignore'
   });
   child.unref();

package/lib/server/runner.ts

@@ -10,8 +10,9 @@ export type RunnerResult = {
 };
 
 export type RunnerOptions = {
-  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>) => Promise<RunnerResult>;
+  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>, cwd?: string) => Promise<RunnerResult>;
   onChunk?: (chunk: string) => void | Promise<void>;
+  cwd?: string;
 };
 
 function resolveCommand(file: string): string {
@@ -40,13 +41,15 @@ function needsShell(file: string): boolean {
 function spawnCapture(
   file: string,
   args: string[],
-  onChunk?: (chunk: string) => void | Promise<void>
+  onChunk?: (chunk: string) => void | Promise<void>,
+  cwd?: string
 ): Promise<RunnerResult> {
   return new Promise((resolve, reject) => {
     const resolvedFile = resolveCommand(file);
     const child = spawn(resolvedFile, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: needsShell(resolvedFile)
+      shell: needsShell(resolvedFile),
+      ...(cwd === undefined ? {} : { cwd })
     });
     let stdout = '';
     let stderr = '';
@@ -91,5 +94,5 @@ function spawnCapture(
 }
 
 export async function runAi(args: string[], options: RunnerOptions = {}): Promise<RunnerResult> {
-  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk, options.cwd);
 }

package/lib/server/server.schema.json

@@ -13,10 +13,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "path": {
-          "type": "string",
-          "description": "Log file path. Defaults to ~/.agent-infra/logs/<project>/<repo-hash>/server.log (outside the repo; the repo-hash isolates checkouts that share a project). Relative paths resolve against the repo root; absolute paths are used as-is."
-        },
         "rotateAtBytes": {
           "type": "integer",
           "minimum": 0,

package/lib/task/activity-intent.ts

@@ -108,6 +108,7 @@ const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS: ReadonlySet<string> = new Set(['approved', 'changes-requested', 'commented']);
 const OUTCOMES: ReadonlySet<string> = new Set(['aborted', 'superseded']);
 const SUCCESS_STATUSES: ReadonlySet<PrReviewArtifactStatus> = new Set(['applied', 'no-op']);
+const LOCAL_COMPLETION_STATUSES: ReadonlySet<PrReviewArtifactStatus> = new Set(['applied', 'no-op', 'blocked', 'failed']);
 const ARTIFACT_STATUSES: ReadonlySet<string> = new Set([
   'pending', 'applied', 'no-op', 'blocked', 'failed', 'aborted', 'superseded'
 ]);
@@ -209,7 +210,7 @@ function readSnapshot(taskRef: string, repoRoot?: string):
     if (terminal.length === 1) {
       const note = terminal[0]!.note;
       const terminalMatchesStatus =
-        (note.startsWith('Verdict: ') && SUCCESS_STATUSES.has(parsed.status))
+        (note.startsWith('Verdict: ') && LOCAL_COMPLETION_STATUSES.has(parsed.status))
         || (note.startsWith('Outcome: Aborted, ') && parsed.status === 'aborted')
         || (note.startsWith('Outcome: Superseded, ') && parsed.status === 'superseded')
         || (note.startsWith('receipt ') && SUCCESS_STATUSES.has(parsed.status));
@@ -338,8 +339,8 @@ function applyLocked(intent: PrReviewActivityIntent, normalizedAgent: string, op
     if (roundState.startedAgent === null) {
       return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${base} has no matching started row`, state.taskId);
     }
-    if (intent.kind === 'pr-review-complete' && !SUCCESS_STATUSES.has(roundState.status)) {
-      return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} must be applied or no-op before completion`, state.taskId);
+    if (intent.kind === 'pr-review-complete' && !LOCAL_COMPLETION_STATUSES.has(roundState.status)) {
+      return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} must record a publication outcome before completion`, state.taskId);
     }
     if (intent.kind === 'pr-review-terminate' && roundState.status !== intent.outcome) {
       return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} status must match outcome ${intent.outcome}`, state.taskId);