@fitlab-ai/agent-infra 0.11.7 → 0.11.9

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`);
   }
@@ -219,6 +231,7 @@ export function parseCustomTool(
   if (!containerMount.startsWith('/')) {
     throw new Error(`${context}: field "containerMount" must be an absolute path`);
   }
+  const invoke = asOptionalNonEmptyString(entry.invoke, 'invoke', context);
 
   const tool: SandboxTool = {
     id,
@@ -229,6 +242,7 @@ export function parseCustomTool(
     versionCmd: asOptionalNonEmptyString(entry.versionCmd, 'versionCmd', context) ?? `which ${id}`,
     setupHint: asOptionalNonEmptyString(entry.setupHint, 'setupHint', context)
       ?? `Run \`${id}\` inside the container to set up.`,
+    ...(invoke === undefined ? {} : { invoke }),
     envVars: asStringRecord(entry.envVars, 'envVars', context),
     hostPreSeedFiles: parseHostPreSeedFiles(entry.hostPreSeedFiles, context),
     hostPreSeedDirs: parseHostPreSeedDirs(entry.hostPreSeedDirs, context),
@@ -243,13 +257,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 = {