@fitlab-ai/agent-infra 0.11.9 → 0.11.11

package/dist/bin/internal-cli.js

@@ -13,7 +13,6 @@ const taskWorkflowCommand = command === 'task-artifact'
     || command === 'task-review'
     || command === 'task-event'
     || command === 'task-ledger'
-    || command === 'task-invalidation'
     || command === 'task-warning';
 const taskPlatformRecoveryCommand = command === 'task-platform-recovery';
 const manualValidationWorkflowCommand = command === 'manual-validation';
@@ -231,11 +230,6 @@ if (!controlRouted && !taskViewGuardFailed && internalRouteRegistered)
             await taskEvent(process.argv.slice(3));
             break;
         }
-        case 'task-invalidation': {
-            const { taskInvalidation } = await import('../lib/internal/task-invalidation.js');
-            taskInvalidation(process.argv.slice(3));
-            break;
-        }
         case 'task-lifecycle': {
             const { taskLifecycle } = await import('../lib/internal/task-lifecycle.js');
             await taskLifecycle(process.argv.slice(3));

package/dist/lib/agent-clients/adapter.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { AGENT_CLIENT_CAPABILITY_IDS, AGENT_CLIENT_SUPPORT_LEVELS, isAgentClientId } from './types.js';
 import { SANDBOX_HOOK_PHASES } from '../sandbox/tool-types.js';
 const PROJECT_ASSET_CATEGORIES = ['managed', 'merged', 'ejected'];
@@ -65,6 +66,24 @@ function freezeTool(tool) {
     if (!tool.containerMount.startsWith('/')) {
         throw new Error(`Sandbox tool '${tool.id}' containerMount must be absolute`);
     }
+    if (tool.hostStateMounts !== undefined && !Array.isArray(tool.hostStateMounts)) {
+        throw new Error(`Agent Client '${tool.id}' hostStateMounts must be an array`);
+    }
+    const hostStateMounts = tool.hostStateMounts?.map((entry) => {
+        if (!entry || typeof entry.hostSubdir !== 'string' || typeof entry.containerSubpath !== 'string') {
+            throw new Error(`Agent Client '${tool.id}' hostStateMounts must contain relative path pairs`);
+        }
+        for (const value of [entry.hostSubdir, entry.containerSubpath]) {
+            const normalized = path.posix.normalize(value);
+            if (value === ''
+                || path.posix.isAbsolute(value)
+                || normalized === '..'
+                || normalized.startsWith('../')) {
+                throw new Error(`Agent Client '${tool.id}' hostStateMounts must stay within the tool directories`);
+            }
+        }
+        return Object.freeze({ ...entry });
+    });
     if (!tool.versionCmd) {
         throw new Error(`Sandbox tool '${tool.id}' requires versionCmd`);
     }
@@ -82,6 +101,7 @@ function freezeTool(tool) {
         ...(tool.hostLiveMounts ? {
             hostLiveMounts: Object.freeze(tool.hostLiveMounts.map((entry) => Object.freeze({ ...entry })))
         } : {}),
+        ...(hostStateMounts ? { hostStateMounts: Object.freeze(hostStateMounts) } : {}),
         ...(tool.postSetupCmds ? { postSetupCmds: Object.freeze([...tool.postSetupCmds]) } : {}),
         ...(tool.tmpfs ? {
             tmpfs: Object.freeze({

package/dist/lib/agent-clients/adapters/codex-sandbox.js

@@ -241,6 +241,19 @@ const codexRecoveryChecks = [
             path: '/home/devuser/.codex'
         }
     },
+    {
+        id: 'app-server-package-writable',
+        probe: {
+            script: 'probe="$1/.agent-infra-app-server-package-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
+            args: ['/home/devuser/.codex/packages/app-server-daemon'],
+            user: 'devuser'
+        },
+        finding: {
+            repairKind: 'hard-failure',
+            message: 'Codex app-server package directory is not writable by devuser.',
+            path: '/home/devuser/.codex/packages/app-server-daemon'
+        }
+    },
     {
         id: 'prompts-link',
         when: {

package/dist/lib/agent-clients/adapters/codex.js

@@ -51,6 +51,10 @@ const codexAdapter = defineAgentClientAdapter({
             versionCmd: 'codex --version',
             setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
             tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'], exec: true },
+            hostStateMounts: [{
+                    hostSubdir: 'packages/app-server-daemon',
+                    containerSubpath: 'packages/app-server-daemon'
+                }],
             hostLiveMounts: [
                 {
                     hostPath: hostJoin(home, '.codex', 'auth.json'),

package/dist/lib/git/workflow.js

@@ -103,7 +103,7 @@ function commitExplicitPaths(input, runner = defaultRunner) {
         if (tree !== input.expectedTree)
             return { status: 'failed', changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'stage', status: 'applied' }], error: { code: 'GIT_TREE_MISMATCH', message: `Expected staged tree ${input.expectedTree}, received ${tree ?? 'unavailable'}` } };
     }
-    const commit = run(runner, input.cwd, ['commit', '-m', input.message]);
+    const commit = run(runner, input.cwd, ['commit', '--cleanup=verbatim', '-m', input.message]);
     const after = inspectGitWorkflow(input.cwd, runner);
     if (commit.status !== 0)
         return { status: 'failed', changed: false, snapshot: after.snapshot, operations: [{ name: 'commit', status: 'failed', message: commit.stderr.trim() }], error: { code: 'GIT_COMMIT_FAILED', message: commit.stderr.trim() } };

package/dist/lib/internal/cli-route-inventory.js

@@ -57,7 +57,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'task-orchestration': ['status', 'progress'],
     'task-review': ['preflight', 'finalize-summary'],
     'task-event': ['event'],
-    'task-invalidation': ['reconcile'],
     'task-lifecycle': ['intent'],
     'task-finalization': ['complete'],
     'task-platform-recovery': ['inspect', 'recover'],
@@ -105,8 +104,6 @@ export function internalRouteSelector(command, args) {
         return args[1] === 'status' ? 'status' : args[1] ? 'progress' : '';
     if (command === 'task-review')
         return args[1] ?? '';
-    if (command === 'task-invalidation')
-        return args[1] ?? '';
     if (command === 'task-artifact')
         return args[1] ?? '';
     if (command === 'platform-pr-review' && first(args) === 'publish') {

package/dist/lib/internal/manual-validation.js

@@ -196,7 +196,7 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
         if (transaction.phase === 'prepared') {
             const staged = await syncPullRequestSummary(taskRef, {
                 cwd, client: options.client, agent, body: pendingBody, changeReportFile: path.resolve(cwd, values.changeReportFile), primaryResult: primaryResult, strict: true,
-                manualValidation: { phase: 'pending' }, lockAlreadyHeld: true
+                manualValidation: { phase: 'pending', transactionId: transaction.transactionId }, lockAlreadyHeld: true
             });
             if (!['applied', 'no-op'].includes(staged.status))
                 transactionFailure(staged.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'pending summary staging failed' });
@@ -261,7 +261,7 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
             try {
                 await syncPullRequestSummary(taskRef, {
                     cwd, client: options.client, agent, body: pendingBody, changeReportFile: path.resolve(cwd, values.changeReportFile), primaryResult: primaryResult, strict: true,
-                    manualValidation: { phase: 'pending' }, lockAlreadyHeld: true
+                    manualValidation: { phase: 'pending', transactionId: transaction.transactionId }, lockAlreadyHeld: true
                 });
             }
             catch {

package/dist/lib/internal/platform-pr.js

@@ -10,7 +10,7 @@ const USAGE = `Usage: agent-infra-internal platform-pr inspect <task-ref> [--cwd
        agent-infra-internal platform-pr bind <task-ref> --pr <token> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr skip <task-ref> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr sync <task-ref> --agent <agent> [--metadata] [--closing-issue] --result <pr_created|pr_reused|no_op> [--dry-run] [--cwd <path>]
-       agent-infra-internal platform-pr sync-in-labels --pr <N> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr sync-in-labels --pr <token> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr summary-context <task-ref> [--cwd <path>]
        agent-infra-internal platform-pr change-report <task-ref> --agent <agent> --mechanical-file <path> --precheck-file <path> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr summary-sync <task-ref> --agent <agent> --body-file <path|-> --change-report-file <path> --result <pr_created|pr_reused|no_op> [--manual-phase pending|final ...] [--strict] [--dry-run] [--cwd <path>]
@@ -91,13 +91,12 @@ async function platformPr(args = []) {
             fail(`sync-in-labels does not accept --${unexpected}`);
             return;
         }
-        const pr = Number(values.pr);
-        if (!Number.isInteger(pr) || pr <= 0) {
-            fail('sync-in-labels requires a positive --pr');
+        if (typeof values.pr !== 'string' || !values.pr || values.pr.trim() !== values.pr) {
+            fail('sync-in-labels requires a non-empty --pr token');
             return;
         }
         const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
-        finish(await syncPlatformPullRequestInLabels(pr, { cwd, dryRun: values.dryRun === true }));
+        finish(await syncPlatformPullRequestInLabels(values.pr, { cwd, dryRun: values.dryRun === true }));
         return;
     }
     const taskRef = args[1];

package/dist/lib/internal/sandbox-control.js

@@ -4,8 +4,9 @@ import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.js';
-function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null) {
-    process.stdout.write(`${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`);
+import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
+function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null, requestId = null) {
+    process.stdout.write(serializeTaskFinalizationEnvelope({ status, changed, accepted, requestId, result, error }));
 }
 function finalizationErrorStatus(error) {
     if (error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
@@ -30,6 +31,28 @@ function recoveredExitCode(response) {
     }
     return response.exitCode ?? 1;
 }
+function finalizationResponseOutput(response) {
+    try {
+        const value = JSON.parse(response.stdout);
+        if (value.version === 2
+            && value.status
+            && ['completed', 'failed', 'blocked', 'unknown'].includes(value.status)
+            && (typeof value.changed === 'boolean' || value.changed === null)) {
+            return serializeTaskFinalizationEnvelope({
+                status: value.status,
+                changed: value.changed,
+                accepted: true,
+                requestId: response.id,
+                result: value.result ?? null,
+                error: value.error ?? null
+            });
+        }
+    }
+    catch {
+        // Preserve non-envelope output for diagnostics from the executor.
+    }
+    return response.stdout;
+}
 function sandboxFinalizationClient(args) {
     if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
         const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'task ref, complete intent, and --agent are required', retryable: false };
@@ -52,7 +75,8 @@ function sandboxFinalizationClient(args) {
     catch (error) {
         if (!(error instanceof SandboxControlClientError))
             throw error;
-        writeFinalizationEnvelope(finalizationErrorStatus(error.detail), error.accepted, error.detail);
+        const status = finalizationErrorStatus(error.detail);
+        writeFinalizationEnvelope(status, error.accepted, error.detail, status === 'unknown' ? null : false, null, error.requestId);
         writeClientError(error);
         process.exitCode = error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.detail.retryable ? 2 : 1;
         return;
@@ -63,12 +87,13 @@ function sandboxFinalizationClient(args) {
             message: 'sandbox control rejected the finalization request',
             retryable: false
         };
-        writeFinalizationEnvelope(finalizationErrorStatus(error), error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error);
+        const status = finalizationErrorStatus(error);
+        writeFinalizationEnvelope(status, error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error, status === 'unknown' ? null : false, null, response.id);
         process.stderr.write(`${error.message}\n`);
         process.exitCode = error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.retryable ? 2 : 1;
         return;
     }
-    process.stdout.write(response.stdout);
+    process.stdout.write(finalizationResponseOutput(response));
     process.stderr.write(response.stderr);
     process.exitCode = response.exitCode ?? 1;
 }

package/dist/lib/internal/task-artifact.js

@@ -1,6 +1,6 @@
 import { parseArtifactCommand, executeArtifactCommand } from '../task/artifact-command.js';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family> [--source-finding <id> --source-artifact <name> --source-sha256 <digest>]\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize workflow artifact facts.\n`;
+const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family> [--reason-code <reason>] [--source-finding <id> --source-artifact <name> --source-sha256 <digest>]\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize workflow artifact facts.\n`;
 function taskArtifact(args = []) {
     if (!ensureInternalHandlerRoute('task-artifact', args))
         return;

package/dist/lib/internal/task-create.js

@@ -54,7 +54,21 @@ async function taskCreate(args) {
             throw new Error('TASK_CREATE_INPUT_INVALID: input must be a regular file');
         if (stat.size > SANDBOX_CONTROL_MAX_BYTES)
             throw new Error('TASK_CREATE_INPUT_TOO_LARGE: input exceeds the control limit');
-        const candidate = validateTaskCreateCandidate(JSON.parse(fs.readFileSync(inputPath, 'utf8')));
+        const inputContent = fs.readFileSync(inputPath, 'utf8');
+        let candidate;
+        try {
+            candidate = validateTaskCreateCandidate(JSON.parse(inputContent));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_INPUT_INVALID';
+            output(failed(code, message, false, {
+                requestId: null,
+                accepted: false,
+                recovery: 'new-request-id'
+            }));
+            return;
+        }
         const environment = resolveSandboxControlTransport();
         if (environment.kind === 'fail-closed') {
             output(failed(environment.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID', 'sandbox client control configuration is invalid'));

package/dist/lib/internal/task-finalization.js

@@ -1,14 +1,13 @@
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
-import { applyTaskFinalization, bindTaskFinalizationReceipt, prepareTaskFinalization } from '../task/finalization.js';
-import { publishTaskFinalizationHandoff } from '../task/finalization-handoff.js';
+import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
-import { verifyTaskEvent } from '../task/verification.js';
 import { resolveSandboxControlTransport } from './task-operation-registry.js';
 import { requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
+import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
-function envelope(status, changed, accepted, result, error) {
-    return `${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`;
+function envelope(status, changed, accepted, result, error, requestId = null) {
+    return serializeTaskFinalizationEnvelope({ status, changed, accepted, requestId, result, error });
 }
 function exitCode(status) {
     return status === 'completed' ? 0 : status === 'blocked' ? 2 : 1;
@@ -65,34 +64,24 @@ async function taskFinalization(args = []) {
     };
     const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
     if (transport.kind === 'sandbox-local') {
-        const prepared = await prepareTaskFinalization(boundOperation.request, {
-            repoRoot,
-            preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
-        });
-        if (prepared.status !== 'prepared') {
-            process.stdout.write(envelope(prepared.status, prepared.changed, true, prepared, prepared.error));
-            process.exitCode = exitCode(prepared.status);
-            return;
-        }
         try {
-            const response = requestSandboxTaskFinalization({
-                agent: boundOperation.request.agent,
-                prepareHandoff: (binding) => {
-                    const receipt = bindTaskFinalizationReceipt(repoRoot, boundOperation.request.taskRef, binding);
-                    return publishTaskFinalizationHandoff('/share/branch', receipt, binding);
-                }
-            });
+            const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
             process.stdout.write(response.stdout);
             process.stderr.write(response.stderr);
             process.exitCode = response.exitCode ?? 1;
             return;
         }
         catch (error) {
-            const detail = error instanceof SandboxControlClientError
-                ? error.detail
+            const clientError = error instanceof SandboxControlClientError ? error : null;
+            const detail = clientError
+                ? clientError.detail
                 : { code: 'SANDBOX_CONTROL_CLIENT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
-            process.stdout.write(envelope(detail.retryable ? 'blocked' : 'failed', false, false, null, detail));
-            process.exitCode = detail.retryable ? 2 : 1;
+            const status = detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
+                ? 'unknown'
+                : detail.retryable ? 'blocked' : 'failed';
+            const changed = status === 'unknown' ? null : false;
+            process.stdout.write(envelope(status, changed, clientError?.accepted ?? false, null, detail, clientError?.requestId ?? null));
+            process.exitCode = exitCode(status);
             return;
         }
     }

package/dist/lib/internal/task-operation-registry.js

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { accessSandboxTaskView, parseSandboxTaskView, taskViewFromStatus } from '../sandbox/control/task-view.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { PUBLIC_CLI_COMMAND_ALIASES, PUBLIC_CLI_SELECTOR_ALIASES, internalRouteSelector } from './cli-route-inventory.js';
-import { readSandboxControlIdentitySentinel } from '../sandbox/control/identity-sentinel.js';
+import { hasSandboxControlMarker, resolveSandboxControlTransport, sandboxTaskMarkerState } from '../sandbox/environment.js';
+export { resolveSandboxControlTransport } from '../sandbox/environment.js';
 const descriptor = (dispatcher, command, selector, scope, effect, taskRefSource = scope === 'non-task' ? 'none' : 'argv') => ({ dispatcher, command, selector, scope, effect, taskRefSource, guardBeforeImport: true });
 function internalTaskRoutes() {
     return [
@@ -102,9 +103,8 @@ function internalTaskRoutes() {
         descriptor('internal', 'task-review', 'preflight', 'task-bound', 'artifact-write'),
         descriptor('internal', 'task-review', 'finalize-summary', 'task-bound', 'progress'),
         descriptor('internal', 'task-event', 'event', 'task-bound', 'progress'),
-        descriptor('internal', 'task-invalidation', 'reconcile', 'task-bound', 'progress'),
         descriptor('internal', 'task-lifecycle', 'intent', 'task-bound', 'progress'),
-        descriptor('internal', 'task-finalization', 'complete', 'task-bound', 'progress'),
+        descriptor('internal', 'task-finalization', 'complete', 'task-bound', 'recovery'),
         descriptor('internal', 'task-platform-recovery', 'inspect', 'task-bound', 'diagnostic'),
         descriptor('internal', 'task-platform-recovery', 'recover', 'task-bound', 'recovery'),
         descriptor('internal', 'task-short-id', 'list', 'conditional', 'diagnostic'),
@@ -179,7 +179,7 @@ export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
     'git-workflow', 'task-delivery', 'release-workflow', 'platform-release-notes', 'platform-security', 'platform-metadata', 'platform-context',
     'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
     'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
-    'task-orchestration', 'task-review', 'task-event', 'task-invalidation', 'task-lifecycle',
+    'task-orchestration', 'task-review', 'task-event', 'task-lifecycle',
     'task-finalization', 'task-platform-recovery', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);
 export const PUBLIC_DISPATCHER_ROUTES = Object.freeze([
@@ -233,141 +233,6 @@ export function resolveDelegatedTaskOperation(args) {
         return null;
     return resolveTaskOperation('internal', rest[0], rest.slice(1));
 }
-const TASK_MARKER_KEYS = [
-    'AGENT_INFRA_TASK_ID',
-    'AGENT_INFRA_CONTROL_TOKEN',
-    'AGENT_INFRA_CONTROL_GENERATION',
-    'AGENT_INFRA_CONTROL_DIR',
-    'AGENT_INFRA_CONTROL_STATUS_DIR',
-    'AGENT_INFRA_RUNTIME_DIR'
-];
-const TASK_CONTROL_MARKER_KEYS = [
-    'AGENT_INFRA_CONTROL_TOKEN',
-    'AGENT_INFRA_CONTROL_GENERATION',
-    'AGENT_INFRA_CONTROL_DIR',
-    'AGENT_INFRA_CONTROL_STATUS_DIR'
-];
-const TASK_CONTROL_CONFIG_KEYS = [
-    'AGENT_INFRA_CONTROL_TOKEN',
-    'AGENT_INFRA_CONTROL_GENERATION',
-    'AGENT_INFRA_CONTROL_ROOT_ID',
-    'AGENT_INFRA_CONTROL_DIR',
-    'AGENT_INFRA_CONTROL_STATUS_DIR'
-];
-export const SANDBOX_CONTROL_STATUS_MOUNT = '/run/agent-infra/control-status';
-function nativeDirectoryProbe(candidate) {
-    try {
-        // The fixed mount is a trust anchor. Do not use a mutable node:fs export:
-        // a preload must not turn a mounted sandbox into the direct-host path by
-        // replacing the ordinary filesystem probe.
-        const binding = process.binding('fs');
-        if (!Function.prototype.toString.call(binding.internalModuleStat).includes('[native code]'))
-            return 'unknown';
-        const result = binding.internalModuleStat(candidate);
-        if (result === 1)
-            return 'present';
-        if (result === -2)
-            return 'absent';
-        return 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-function taskMarkerState(env) {
-    const present = (key) => Boolean(env[key]);
-    const taskId = present('AGENT_INFRA_TASK_ID');
-    const controls = TASK_CONTROL_MARKER_KEYS.every(present);
-    const runtime = present('AGENT_INFRA_RUNTIME_DIR');
-    const any = TASK_MARKER_KEYS.some(present);
-    if (!any)
-        return 'none';
-    if (taskId && controls && runtime)
-        return 'task-bound';
-    if (!taskId && controls && !runtime)
-        return 'branch-only';
-    return 'incomplete';
-}
-export function resolveSandboxControlTransport(env = process.env, options = {}) {
-    const hasAnyMarker = TASK_MARKER_KEYS.some((key) => Boolean(env[key]))
-        || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING)
-        || Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
-    const fixedStatusDir = options.statusMountPath
-        ?? SANDBOX_CONTROL_STATUS_MOUNT;
-    const fixedStatusProbe = path.isAbsolute(fixedStatusDir)
-        ? nativeDirectoryProbe(fixedStatusDir) : 'absent';
-    if (fixedStatusProbe === 'unknown') {
-        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
-    }
-    const fixedStatusMounted = fixedStatusProbe === 'present';
-    // A fixed status mount is installed only in a task-bound sandbox. Its
-    // presence is not mutable by the sandbox process, so marker removal must
-    // never make that process look like a direct host invocation.
-    if (!hasAnyMarker) {
-        return fixedStatusMounted
-            ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' }
-            : { kind: 'direct-host', reasonCode: null };
-    }
-    const hasCompleteConfig = TASK_CONTROL_CONFIG_KEYS.every((key) => Boolean(env[key]));
-    if (!hasCompleteConfig) {
-        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
-    }
-    const configuredStatusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
-    const configuredStatusProbe = configuredStatusDir && path.isAbsolute(configuredStatusDir)
-        ? nativeDirectoryProbe(configuredStatusDir) : 'absent';
-    if (configuredStatusProbe === 'unknown') {
-        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
-    }
-    const statusDir = configuredStatusDir && path.isAbsolute(configuredStatusDir)
-        ? configuredStatusProbe === 'present' ? configuredStatusDir : null
-        : fixedStatusMounted ? fixedStatusDir : null;
-    const statusMounted = statusDir !== null;
-    if (env.AGENT_INFRA_EXECUTOR_MANIFEST || env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING) {
-        return { kind: 'fail-closed', reasonCode: 'TASK_CONTROL_TRANSPORT_INVALID' };
-    }
-    const taskBound = Boolean(env.AGENT_INFRA_TASK_ID);
-    const runtime = Boolean(env.AGENT_INFRA_RUNTIME_DIR);
-    if (statusMounted) {
-        let sentinel;
-        try {
-            sentinel = readSandboxControlIdentitySentinel(statusDir);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : '';
-            return { kind: 'fail-closed', reasonCode: message.endsWith('MISSING')
-                    ? 'SANDBOX_CONTROL_IDENTITY_MISSING'
-                    : 'SANDBOX_CONTROL_IDENTITY_MALFORMED' };
-        }
-        if (sentinel.generation !== env.AGENT_INFRA_CONTROL_GENERATION) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_GENERATION_MISMATCH' };
-        }
-        if (env.AGENT_INFRA_CONTROL_ROOT_ID && sentinel.controlRootId !== env.AGENT_INFRA_CONTROL_ROOT_ID) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_ROOT_ID_MISMATCH' };
-        }
-        if (sentinel.mode === 'task-bound'
-            && (sentinel.taskId !== env.AGENT_INFRA_TASK_ID || !runtime)) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
-        }
-        if (sentinel.mode === 'branch-only' && (taskBound || runtime)) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
-        }
-        if (!hasCompleteConfig) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
-        }
-        return { kind: options.localWorkflow ? 'sandbox-local' : 'broker-client', reasonCode: null };
-    }
-    if (!hasAnyMarker)
-        return { kind: 'direct-host', reasonCode: null };
-    if (!hasCompleteConfig || (taskBound && !runtime) || (!taskBound && runtime)) {
-        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
-    }
-    return options.localWorkflow
-        ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_MISSING' }
-        : { kind: 'broker-client', reasonCode: null };
-}
-export function hasTaskBoundMarker(env = process.env) {
-    return taskMarkerState(env) === 'task-bound';
-}
 function explicitTaskRefForOperation(dispatcher, command, args, selected) {
     if (selected.taskRefSource === 'none' || selected.taskRefSource === 'environment')
         return null;
@@ -447,7 +312,7 @@ function isSandboxExecutorRoute(dispatcher, command, args, env) {
         && first(args) === 'execute'
         && Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST)
         && Boolean(env.AGENT_INFRA_RUNTIME_DIR)
-        && !TASK_CONTROL_MARKER_KEYS.some((key) => Boolean(env[key]));
+        && !hasSandboxControlMarker(env);
 }
 function viewFromEnvironment(env) {
     const statusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
@@ -493,7 +358,7 @@ export function guardTaskOperation(dispatcher, command, args = [], options = {})
             taskView: null
         };
     }
-    const markerState = taskMarkerState(env);
+    const markerState = sandboxTaskMarkerState(env);
     if (markerState === 'incomplete' && !isSandboxExecutorRoute(dispatcher, command, args, env)) {
         throw new TaskViewOperationError('SANDBOX_TASK_VIEW_MARKER_INVALID', 'sandbox task markers are incomplete; refusing to infer host-direct authority');
     }

package/dist/lib/internal/task-platform-recovery.js

@@ -2,7 +2,7 @@ import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { readPlatformOperationJournal } from '../task/platform-operation-journal.js';
 import { recoverPlatformOperations } from '../task/platform-operation-recovery.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal task-platform-recovery <N | TASK-id> <inspect | recover> [--agent <agent>] [--selection required|deferred|all]\n';
+const USAGE = 'Usage: agent-infra-internal task-platform-recovery <N | TASK-id> <inspect | recover> [--agent <agent>] [--selection required|deferred|all] [--attempts <positive-integer>]\n';
 function option(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] : undefined;
@@ -41,14 +41,19 @@ async function taskPlatformRecovery(args = []) {
     }
     const agent = option(args, '--agent');
     const selection = option(args, '--selection') ?? 'all';
+    const attemptsInput = option(args, '--attempts');
+    const attempts = attemptsInput === undefined ? undefined : Number(attemptsInput);
+    const validAttempts = attemptsInput === undefined
+        || (attempts !== undefined && Number.isSafeInteger(attempts) && attempts > 0);
     if (!agent || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(agent)
-        || !['required', 'deferred', 'all'].includes(selection)) {
-        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'recover requires a valid --agent and --selection' } })}\n`);
+        || !['required', 'deferred', 'all'].includes(selection)
+        || !validAttempts) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'recover requires a valid --agent, --selection, and positive --attempts when supplied' } })}\n`);
         process.stderr.write(USAGE);
         process.exitCode = 1;
         return;
     }
-    const result = await recoverPlatformOperations(task.taskId, selection, { agent, cwd: repoRoot });
+    const result = await recoverPlatformOperations(task.taskId, selection, { agent, cwd: repoRoot, ...(attempts === undefined ? {} : { attempts }) });
     process.stdout.write(`${JSON.stringify(result)}\n`);
     process.exitCode = result.status === 'applied' || result.status === 'no-op' ? 0 : result.status === 'blocked' ? 2 : 1;
 }

package/dist/lib/platform/completion-backfill.js

@@ -8,6 +8,7 @@ import { getOpenWorkflowWarnings } from '../task/workflow-warnings.js';
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js';
 import { captureTaskWriteMetadata } from '../task/write.js';
 import { syncPlatformComment } from './issue-comments.js';
+import { providerErrorRetryable } from './provider-validation.js';
 import { platformResult } from './types.js';
 import { taskIssueIdentity } from './task-identities.js';
 function result(base, artifacts, warnings) {
@@ -124,7 +125,7 @@ async function backfillCompletionComments(taskRef, options) {
         if (latest.status === 'failed' || latest.status === 'blocked')
             return result({ ...latest, operations }, artifacts, []);
         if (latest.error)
-            return result(platformResult(latest.error.retryable ? 'blocked' : 'failed', {
+            return result(platformResult(latest.error.retryable || providerErrorRetryable(latest.error.code) ? 'blocked' : 'failed', {
                 platform: latest.platform,
                 resource: latest.resource,
                 capabilities: latest.capabilities,

package/dist/lib/platform/context.js

@@ -1,18 +1,20 @@
 import path from 'node:path';
 import { loadPlatformProvider } from './provider-loader.js';
 import { defaultGitRemote, parseGitHubRemote } from './github-provider.js';
+import { providerErrorRetryable } from './provider-validation.js';
 import { platformResult } from './types.js';
 function errorStatus(error) {
-    if (error.retryable || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING')
+    if (error.retryable || providerErrorRetryable(error.code) || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING')
         return 'blocked';
     if (error.code === 'REMOTE_MISSING' || error.code === 'PLATFORM_UNSUPPORTED')
         return 'no-op';
     return 'failed';
 }
 function contextError(providerType, error, repository = null) {
+    const retryable = error.retryable ?? providerErrorRetryable(error.code);
     return platformResult(errorStatus(error), {
         platform: { type: providerType || null, repository, currentUser: null },
-        error: { code: error.code, message: error.message, retryable: error.retryable }
+        error: { code: error.code, message: error.message, retryable }
     });
 }
 function contextFromSnapshot(providerType, snapshot) {