@fitlab-ai/agent-infra 0.9.15 → 0.10.0

package/lib/sandbox/commands/rm.ts

@@ -2,12 +2,41 @@ import { parseArgs } from 'node:util';
 import { loadConfig } from '../config.ts';
 import { createSandboxCapabilityPlan } from '../agent-client-reconciler.ts';
 import { resolveSandboxCleanupTarget } from '../workspace-identity.ts';
+import { detectEngine } from '../engine.ts';
+import {
+  sandboxBranchLabel,
+  sandboxLabel,
+  sandboxTaskIdLabel,
+  sandboxWorkspaceModeLabel
+} from '../constants.ts';
+import { fetchSandboxRows } from './list-running.ts';
 import { rmOne, rmPurge, rmUnbound } from '../removal.ts';
 
 const USAGE = `Usage:
   ai sandbox rm <branch | TASK-id | short id> Remove one sandbox; use a full TASK-id for a task-bound sandbox and a branch for branch-only sandboxes
-  ai sandbox rm --unbound [--dry-run] [--yes] Remove completed task-bound and branch-only sandboxes and verified auxiliary state; active, blocked, and archive tasks are protected
+  ai sandbox rm --unbound [--dry-run] [--yes] Remove discovered task-bound and branch-only sandboxes
   ai sandbox rm --purge                     Tear down ALL sandboxes for the project (containers, worktrees, image, VM)`;
+
+function resolveMissingTaskSandboxBranch(taskId: string, config: ReturnType<typeof loadConfig>): string | null {
+  const engine = detectEngine(config);
+  const listed = fetchSandboxRows(
+    engine,
+    sandboxLabel(config),
+    sandboxBranchLabel(config),
+    { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) }
+  );
+  const branches = new Set(
+    [...listed.running, ...listed.nonRunning]
+      .filter((row) => row.workspaceMode === 'task-bound' && row.taskId === taskId && row.branch)
+      .map((row) => row.branch)
+  );
+  if (branches.size === 0) return null;
+  if (branches.size > 1) {
+    throw new Error(`SANDBOX_CLEANUP_TASK_ID_AMBIGUOUS: task ${taskId} matches multiple sandbox branches`);
+  }
+  return branches.values().next().value ?? null;
+}
+
 export async function rm(args: string[]): Promise<void> {
   const { values, positionals } = parseArgs({
     args,
@@ -64,6 +93,9 @@ export async function rm(args: string[]): Promise<void> {
     return;
   }
 
-  const cleanupTarget = resolveSandboxCleanupTarget(positionals[0] ?? '', config.repoRoot);
+  const cleanupTarget = resolveSandboxCleanupTarget(positionals[0] ?? '', config.repoRoot, {
+    allowProtected: true,
+    resolveMissingTask: (taskId) => resolveMissingTaskSandboxBranch(taskId, config)
+  });
   await rmOne(config, tools, cleanupTarget.branch, { cleanupTarget });
 }

package/lib/sandbox/control/protocol.ts

@@ -131,6 +131,11 @@ export type SandboxControlResponse = Readonly<{
   outputState?: 'available' | 'unavailable';
   payload?: SandboxControlPayloadReference | null;
 }>;
+export type SandboxControlRecoveryWarning = Readonly<{
+  code: string;
+  message: string;
+  action: string;
+}>;
 export type SandboxControlStatus = Readonly<{
   version: 3; generation: string; broker: ProcessIdentity & { brokerId: string };
   state: 'starting' | 'healthy' | 'busy' | 'parked'; reasonCode: string | null;

package/lib/sandbox/control/server.ts

@@ -12,6 +12,7 @@ import {
   SANDBOX_CONTROL_MAX_RESPONSE_BYTES,
   SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES,
   type SandboxControlManifest,
+  type SandboxControlRecoveryWarning,
   type SandboxControlRequest,
   type SandboxControlResponse,
   type SandboxControlTimingPolicy
@@ -62,6 +63,7 @@ import {
   SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES
 } from '../../task/control-recovery.ts';
 import { readRun } from '../../task/orchestration.ts';
+import { readLifecycleRecoveryDomainEvidence } from '../../task/lifecycle-recovery.ts';
 import { captureRepositorySnapshot } from '../../task/workspace-snapshot.ts';
 import { parseTypedTaskFrontmatter } from '../../task/frontmatter.ts';
 import { readLifecycleJournalEvidence } from '../../task/lifecycle.ts';
@@ -368,11 +370,12 @@ function outputMatchesEvidence(output: string, bytes: number, sha256: string): b
     && createHash('sha256').update(output, 'utf8').digest('hex') === sha256;
 }
 
-function genericRecoveryResponse(
+export function genericRecoveryResponse(
   request: SandboxControlRequest,
   exitCode: number,
   payload: ReturnType<typeof readSandboxControlPayload> | null,
-  cause: 'publish' | 'recovery' = 'recovery'
+  cause: 'publish' | 'recovery' = 'recovery',
+  warning: SandboxControlRecoveryWarning | null = null
 ): SandboxControlResponse {
   const outputUnavailable = request.family === 'task-create' && !payload;
   return {
@@ -381,9 +384,11 @@ function genericRecoveryResponse(
     phase: 'completed',
     exitCode,
     stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
-    stderr: payload ? '' : cause === 'publish'
-      ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
-      : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
+    stderr: payload ? '' : warning
+      ? `${warning.code}: ${warning.message}\nAction: ${warning.action}\n`
+      : cause === 'publish'
+        ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
+        : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
     error: null,
     outputState: payload ? 'available' : 'unavailable',
     payload: payload ? payloadReference(payload) : null
@@ -504,6 +509,21 @@ function readRecoveryDomain(
   }
 
   if (operation.family === 'task-lifecycle') {
+    if (operation.intent === 'recover-started') {
+      try {
+        if (!('args' in request)) return { domain: null };
+        const parsed = parseTaskControlOperation('task-lifecycle', request.args);
+        if (parsed.family !== 'task-lifecycle' || parsed.request.intent !== 'recover-started') {
+          return { domain: null };
+        }
+        return {
+          domain: readLifecycleRecoveryDomainEvidence(manifest.repoRoot, parsed.request, terminalResult),
+          journal: readLifecycleJournalEvidence(manifest.repoRoot, taskRef!)
+        };
+      } catch {
+        return { domain: null };
+      }
+    }
     if (!taskRef || !terminalResult.targetState) return { domain: null };
     const journal = readLifecycleJournalEvidence(manifest.repoRoot, taskRef);
     try {
@@ -577,7 +597,7 @@ function readCommittedCriticalPhases(manifest: SandboxControlManifest, requestId
   });
 }
 
-function recoveryResponse(
+export function recoveryResponse(
   manifest: SandboxControlManifest,
   manifestPath: string,
   request: SandboxControlRequest,
@@ -637,7 +657,7 @@ function recoveryResponse(
     if (finalization?.status !== 'matched') return null;
     return finalization.response ?? null;
   }
-  return genericRecoveryResponse(request, evidence.exitCode, payload);
+  return genericRecoveryResponse(request, evidence.exitCode, payload, 'recovery', terminalResult.warning ?? null);
 }
 
 function terminalMatchesEvidence(
@@ -681,7 +701,7 @@ function terminalMatchesEvidence(
   if (response.outputState === 'unavailable') {
     const causes = ['recovery', 'publish'] as const;
     const valid = causes.some((cause) => JSON.stringify(response)
-      === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
+      === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause, terminalResult?.warning ?? null)));
     return { valid, payloadReferenced: false };
   }
   return {
@@ -700,7 +720,7 @@ function publishExecutionResult(
   brokerOwns: () => boolean
 ): boolean {
   const normalized = sanitizeSandboxControlResult(manifest, result);
-  writeSandboxControlTerminalResult(manifest, {
+  const terminalResult = writeSandboxControlTerminalResult(manifest, {
     id: request.id,
     family: request.family,
     operation: operationKey(request, normalized.stdout)
@@ -737,7 +757,7 @@ function publishExecutionResult(
       } catch {
         payload = null;
       }
-      terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
+      terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish', terminalResult.warning ?? null);
     }
   }
   if (!brokerOwns()) return false;

package/lib/sandbox/control/state.ts

@@ -1,5 +1,6 @@
 import { isCompletionEvidence, type CleanCompletionEvidence } from '../../task/orchestration.ts';
 import { parseControlOutput } from '../../task/control-recovery.ts';
+import { isRecoveryWarning } from '../../task/recovery-warning.ts';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -14,6 +15,7 @@ import type {
   SandboxControlPayload,
   SandboxControlReservation,
   SandboxControlResultEvidence,
+  SandboxControlRecoveryWarning,
   SandboxControlStatus
 } from './protocol.ts';
 import {
@@ -113,6 +115,7 @@ export type SandboxControlTerminalResult = Readonly<{
   status: string;
   changed: boolean | null;
   completionEvidence: CleanCompletionEvidence | null;
+  warning?: SandboxControlRecoveryWarning | null;
 }>;
 
 export function terminalResultPath(manifest: SandboxControlManifest, requestId: string): string {
@@ -130,6 +133,7 @@ export function createSandboxControlTerminalResult(
     ? nested.run as Record<string, unknown> : null;
   const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
   const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
+  const warning = isRecoveryWarning(nested.warning) ? nested.warning : null;
   return {
     version: 1,
     requestId: request.id,
@@ -139,7 +143,8 @@ export function createSandboxControlTerminalResult(
     targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
     status: typeof nested.status === 'string' ? nested.status : 'completed',
     changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-    completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
+    completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null,
+    ...(warning ? { warning } : {})
   };
 }
 
@@ -173,6 +178,9 @@ export function readSandboxControlTerminalResult(filePath: string): SandboxContr
   if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
     throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
   }
+  if (value.warning !== undefined && value.warning !== null && !isRecoveryWarning(value.warning)) {
+    throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
+  }
   if (value.changed === undefined) {
     throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
   }

package/lib/sandbox/control/workflow-executor.ts

@@ -9,7 +9,7 @@ import { dispatchHostControlCommand } from '../../host-control/command.ts';
 import { assertSandboxTaskSource } from '../workspace-view.ts';
 import { appendDiagnosticAudit } from './audit.ts';
 import {
-  readTaskArtifact, writeTaskArtifact, type TaskWorkflowRequest
+  readTaskArtifact, type TaskWorkflowRequest
 } from './task-workflow.ts';
 import type { SandboxControlManifest } from './protocol.ts';
 import type { SandboxControlExecutionResult } from './executor.ts';
@@ -55,7 +55,7 @@ export async function executeTaskWorkflow(
     if (command === 'task-artifact' && 'operation' in input && input.operation === 'inspect') {
       return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot }));
     }
-    if ('operation' in input && (input.operation === 'init' || input.operation === 'repair')) {
+    if ('operation' in input && input.operation === 'init') {
       return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot, artifactDir: taskDir }));
     }
     return await withTaskExecutionLock(manifest.repoRoot, request.taskId, `sandbox-control.${request.operation}`, async () => {
@@ -65,27 +65,17 @@ export async function executeTaskWorkflow(
       if ('operation' in input) {
         const { family } = input;
         if (family !== 'analysis' && family !== 'plan' && family !== 'code') throw new Error('ARTIFACT_IDENTITY_INVALID');
-        const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot } as const;
+        const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, recoveryId: input.recoveryId, lockAlreadyHeld: true } as const;
         const prepared = prepareLocalArtifact(local, content, lifecycleRecoveryAttestation ?? undefined);
         if (prepared.result.status === 'failed') return executionResult(commitLocalArtifactProvenance(prepared));
         publicationStarted = true;
-        await writeTaskArtifact(taskDir, {
-          artifact: artifact.artifact,
-          bytes: artifact.bytes,
-          expectedSha256: artifact.sha256
-        });
         result = commitLocalArtifactProvenance(prepared);
       } else {
         if (input.overrideTicket) throw new Error('TASK_WORKFLOW_OVERRIDE_UNSUPPORTED');
-        const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot });
+        const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true, startRecovery: true });
         if (input.dryRun || prepared.result.status === 'planned') return executionResult(prepared.result);
         if (prepared.result.status === 'failed') return executionResult(commitReviewSummaryProvenance(prepared, manifest.repoRoot));
         publicationStarted = true;
-        await writeTaskArtifact(taskDir, {
-          artifact: input.artifact,
-          bytes: Buffer.from(prepared.content, 'utf8'),
-          expectedSha256: artifact.sha256
-        });
         result = commitReviewSummaryProvenance(prepared, manifest.repoRoot);
       }
       if (result.status !== 'failed') appendDiagnosticAudit(manifest, 'task-workflow-artifact-finalized', {

package/lib/sandbox/index.ts

@@ -20,8 +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 completed task-bound and branch-only sandboxes
-                               plus verified auxiliary state; active, blocked, and archive tasks are protected.
+                               removes discovered task-bound and branch-only sandboxes.
   start [--recreate] <branch | TASK-id | N>
                                Verify or recover an existing sandbox container;
                                optionally replace only the container on failure