@fitlab-ai/agent-infra 0.11.7 → 0.11.8

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/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);

package/lib/task/create-service.ts

@@ -4,6 +4,7 @@ import type { PlatformResult } from '../platform/types.ts';
 import { VERSION } from '../version.ts';
 import { applyWorkflowWarningIntent } from './workflow-warning-intents.ts';
 import { createLocalTask, type TaskCreateCandidateV1 } from './create.ts';
+import { TaskExecutionLockError } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
 
 type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
@@ -200,8 +201,9 @@ async function createTask(value: unknown, options: CreateTaskOptions): Promise<T
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
-    return taskCreateFailure({ code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' });
+    const lockBusy = error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY';
+    const code = lockBusy ? error.code : /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+    return taskCreateFailure({ code, message, retryable: lockBusy || code === 'TASK_CREATE_LOCK_TIMEOUT' });
   }
 
   const operations: TaskCreateOperation[] = [{
@@ -250,7 +252,7 @@ async function createTask(value: unknown, options: CreateTaskOptions): Promise<T
       task: local.task, issue, operations, warnings: [], error: verified.error
     };
     return {
-      status: platformFailure.status === 'blocked' ? 'blocked' : 'degraded',
+      status: 'degraded',
       changed: local.changed,
       task: local.task,
       issue,

package/lib/task/create.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 
 import { isValidAgentInfraVersion, VERSION } from '../version.ts';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
+import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.ts';
@@ -419,7 +419,7 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);
   const keyDigest = sha256(candidate.idempotencyKey);
-  return withCreateLock(repoRoot, projectConfig.project, () => {
+  function createUnderRepositoryLock(): LocalTaskCreateResult {
     const recovered = recoverPublishedTask(repoRoot, keyDigest, candidateDigest);
     if (recovered) {
       return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId, state: recovered.state } };
@@ -446,12 +446,24 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     fs.writeFileSync(path.join(temporary, 'task.md'), rendered, { flag: 'wx', mode: 0o600 });
     const destination = path.join(activeRoot, taskId);
     fs.renameSync(temporary, destination);
-    let shortId: string;
     const allocated = mutateShortIdRegistry(repoRoot, taskId, 'alloc');
     if (!allocated.shortId) throw new Error('TASK_CREATE_SHORT_ID_FAILED');
-    shortId = allocated.shortId;
-    return { status: 'applied', changed: true, task: { id: taskId, shortId, state: 'active' } };
+    return { status: 'applied', changed: true, task: { id: taskId, shortId: allocated.shortId, state: 'active' } };
+  }
+
+  return withCreateLock(repoRoot, projectConfig.project, () => {
+    let callbackError: unknown;
+    try {
+      return withRepositoryMutationLock(repoRoot, () => {
+        try { return createUnderRepositoryLock(); }
+        catch (error) { callbackError = error; throw error; }
+      });
+    } catch (error) {
+      if (callbackError !== undefined) throw callbackError;
+      throw error;
+    }
   });
+
 }
 
 export {

package/lib/task/finalization-artifacts.ts

@@ -15,7 +15,10 @@ const COMPLETION_BACKFILL_FAMILIES = [
   'plan',
   'review-plan',
   'code',
-  'review-code'
+  'review-code',
+  'manual-validation',
+  'validation-run',
+  'pr-review'
 ] as const satisfies readonly ArtifactFamily[];
 
 type CompletionArtifactResult = {