@fitlab-ai/agent-infra 0.9.8 → 0.9.10

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

@@ -1,8 +1,7 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, dispatchOrchestrationDelegation, pauseOrchestration, recoverCommitIntent, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
+import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
 import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -23,26 +22,15 @@ async function taskOrchestration(args = []) {
     const [taskRef, intent] = args;
     if (![
         'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status',
-        'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
+        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
         return;
     }
     const values = {};
     const seen = new Set();
-    let orchestrated = false;
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--orchestrated') {
-            if (seen.has(flag)) {
-                usageFailure(`duplicate option '${flag}'`);
-                return;
-            }
-            seen.add(flag);
-            orchestrated = true;
-            continue;
-        }
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
@@ -52,8 +40,7 @@ async function taskOrchestration(args = []) {
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
             '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
-            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head',
-            '--attempt', '--git-worktree-root'
+            '--git-worktree-root'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -70,33 +57,6 @@ async function taskOrchestration(args = []) {
         }
         values[flag] = value;
     }
-    const commitIntentFlags = {
-        'commit-start': ['--agent', '--git-worktree-root'],
-        'commit-begin': ['--agent', '--baseline-head', '--attempt', '--orchestrated', '--git-worktree-root'],
-        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref', '--git-worktree-root'],
-        'commit-complete': ['--token', '--agent', '--git-worktree-root'],
-        'commit-recover': ['--agent', '--git-worktree-root'],
-        'commit-abort': ['--token', '--expected-head', '--git-worktree-root'],
-        'commit-terminate': ['--attempt', '--agent', '--code', '--git-worktree-root'],
-        'commit-status': ['--git-worktree-root']
-    };
-    if (intent in commitIntentFlags) {
-        const allowed = commitIntentFlags[intent];
-        const invalid = [...seen].find((flag) => !allowed.includes(flag));
-        if (invalid) {
-            usageFailure(`intent '${intent}' does not accept '${invalid}'`);
-            return;
-        }
-    }
-    else {
-        const commitOnly = [...seen].find((flag) => [
-            '--orchestrated', '--baseline-head', '--attempt', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
-        ].includes(flag));
-        if (commitOnly) {
-            usageFailure(`intent '${intent}' does not accept '${commitOnly}'`);
-            return;
-        }
-    }
     const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
     const coreOptions = values['--git-worktree-root'] === undefined
         ? {}
@@ -106,273 +66,178 @@ async function taskOrchestration(args = []) {
         return;
     }
     let result;
-    if (intent === 'commit-start') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-start' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = startCommitAttempt(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-begin') {
-        const missing = requireValues(['--agent', '--baseline-head', '--attempt']);
-        if (missing) {
-            usageFailure(`intent 'commit-begin' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = beginCommitIntent(taskRef, {
-            agent, orchestrated, baselineHead: values['--baseline-head'], attempt: values['--attempt']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-checkpoint') {
-        const missing = requireValues(['--token', '--kind', '--head']);
-        if (missing) {
-            usageFailure(`intent 'commit-checkpoint' requires '${missing}'`);
-            return;
-        }
-        if (!['committed', 'pushed'].includes(values['--kind'])) {
-            usageFailure('--kind must be committed or pushed');
-            return;
-        }
-        if (values['--kind'] === 'pushed') {
-            const pushedMissing = requireValues(['--remote', '--ref']);
-            if (pushedMissing) {
-                usageFailure(`pushed checkpoint requires '${pushedMissing}'`);
+    try {
+        if (intent === 'begin-or-resume') {
+            const missing = requireValues(['--client']);
+            if (missing) {
+                usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
                 return;
             }
+            const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
+            if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
+                usageFailure('--max-steps must be a positive integer');
+                return;
+            }
+            const policyFlags = [
+                '--executor-model', '--executor-reasoning-effort',
+                '--reviewer-model', '--reviewer-reasoning-effort'
+            ];
+            const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
+            if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
+                usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
+                return;
+            }
+            result = beginOrResumeOrchestration(taskRef, {
+                ...coreOptions,
+                maxSteps,
+                client: values['--client'],
+                modelPolicy: hasAnyPolicy ? {
+                    executor: {
+                        model: values['--executor-model'],
+                        reasoningEffort: values['--executor-reasoning-effort']
+                    },
+                    reviewer: {
+                        model: values['--reviewer-model'],
+                        reasoningEffort: values['--reviewer-reasoning-effort']
+                    }
+                } : undefined
+            });
+        }
+        else if (intent === 'route') {
+            result = routeOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'status') {
+            result = statusOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'prepare') {
+            const missing = requireValues(['--client']);
+            if (missing) {
+                usageFailure(`intent 'prepare' requires '${missing}'`);
+                return;
+            }
+            result = await prepareCodexOrchestrationDelegation(taskRef, {
+                client: values['--client'],
+                requestedModel: values['--requested-model'],
+                requestedReasoningEffort: values['--requested-reasoning-effort'],
+                capabilityToken: values['--capability-token']
+            }, { orchestrationOptions: coreOptions });
+        }
+        else if (intent === 'dispatch') {
+            result = dispatchOrchestrationDelegation(taskRef, coreOptions);
+        }
+        else if (intent === 'await-activation') {
+            const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
+            if (missing) {
+                usageFailure(`intent 'await-activation' requires '${missing}'`);
+                return;
+            }
+            const round = Number(values['--round']);
+            if (!Number.isSafeInteger(round) || round < 1) {
+                usageFailure('--round must be a positive integer');
+                return;
+            }
+            if (!['executor', 'reviewer'].includes(values['--role'])) {
+                usageFailure('--role must be executor or reviewer');
+                return;
+            }
+            result = await awaitOrchestrationDelegationActivation(taskRef, {
+                stage: values['--stage'],
+                round,
+                artifact: values['--artifact'],
+                role: values['--role']
+            }, coreOptions);
         }
-        else if (values['--remote'] !== undefined || values['--ref'] !== undefined) {
-            usageFailure('committed checkpoint does not accept --remote or --ref');
-            return;
-        }
-        result = checkpointCommitIntent(taskRef, {
-            token: values['--token'], kind: values['--kind'],
-            head: values['--head'], remote: values['--remote'], ref: values['--ref']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-complete') {
-        const missing = requireValues(['--token', '--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-complete' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = completeCommitIntent(taskRef, { token: values['--token'], agent }, coreOptions);
-    }
-    else if (intent === 'commit-recover') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-recover' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = recoverCommitIntent(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-abort') {
-        const missing = requireValues(['--token', '--expected-head']);
-        if (missing) {
-            usageFailure(`intent 'commit-abort' requires '${missing}'`);
-            return;
-        }
-        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] }, coreOptions);
-    }
-    else if (intent === 'commit-terminate') {
-        const missing = requireValues(['--attempt', '--agent', '--code']);
-        if (missing) {
-            usageFailure(`intent 'commit-terminate' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        if (!/^[A-Z][A-Z0-9_]{2,63}$/.test(values['--code'])) {
-            usageFailure('--code must be a stable uppercase identifier');
-            return;
-        }
-        result = terminateCommitAttempt(taskRef, {
-            attempt: values['--attempt'], agent, code: values['--code']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-status') {
-        result = statusCommitIntent(taskRef, coreOptions);
-    }
-    else if (intent === 'begin-or-resume') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
-            return;
-        }
-        const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
-        if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
-            usageFailure('--max-steps must be a positive integer');
-            return;
-        }
-        const policyFlags = [
-            '--executor-model', '--executor-reasoning-effort',
-            '--reviewer-model', '--reviewer-reasoning-effort'
-        ];
-        const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
-        if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
-            usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
-            return;
-        }
-        result = beginOrResumeOrchestration(taskRef, {
-            ...coreOptions,
-            maxSteps,
-            client: values['--client'],
-            modelPolicy: hasAnyPolicy ? {
-                executor: {
-                    model: values['--executor-model'],
-                    reasoningEffort: values['--executor-reasoning-effort']
-                },
-                reviewer: {
-                    model: values['--reviewer-model'],
-                    reasoningEffort: values['--reviewer-reasoning-effort']
-                }
-            } : undefined
-        });
-    }
-    else if (intent === 'route') {
-        result = routeOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'status') {
-        result = statusOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'prepare') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'prepare' requires '${missing}'`);
-            return;
-        }
-        result = await prepareCodexOrchestrationDelegation(taskRef, {
-            client: values['--client'],
-            requestedModel: values['--requested-model'],
-            requestedReasoningEffort: values['--requested-reasoning-effort'],
-            capabilityToken: values['--capability-token']
-        }, { orchestrationOptions: coreOptions });
-    }
-    else if (intent === 'dispatch') {
-        result = dispatchOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'await-activation') {
-        const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
-        if (missing) {
-            usageFailure(`intent 'await-activation' requires '${missing}'`);
-            return;
-        }
-        const round = Number(values['--round']);
-        if (!Number.isSafeInteger(round) || round < 1) {
-            usageFailure('--round must be a positive integer');
-            return;
-        }
-        if (!['executor', 'reviewer'].includes(values['--role'])) {
-            usageFailure('--role must be executor or reviewer');
-            return;
-        }
-        result = await awaitOrchestrationDelegationActivation(taskRef, {
-            stage: values['--stage'],
-            round,
-            artifact: values['--artifact'],
-            role: values['--role']
-        }, coreOptions);
-    }
-    else if (intent === 'recover-prepared') {
-        result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'hook-start') {
-        const missing = requireValues([
-            ...(taskRef === 'auto' ? ['--client'] : []),
-            '--native-agent', '--child-id', '--parent-id'
-        ]);
-        if (missing) {
-            usageFailure(`intent 'hook-start' requires '${missing}'`);
-            return;
+        else if (intent === 'recover-prepared') {
+            result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
         }
-        const event = {
-            nativeAgent: values['--native-agent'], childId: values['--child-id'],
-            parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
-            actualModel: values['--actual-model'],
-            actualReasoningEffort: values['--actual-reasoning-effort'],
-            modelFallbackReason: values['--model-fallback-reason'],
-            reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-        };
-        result = taskRef === 'auto'
-            ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
-            : activateOrchestrationDelegation(taskRef, event, coreOptions);
-    }
-    else if (intent === 'hook-stop') {
-        if (taskRef === 'auto') {
-            const missing = requireValues(['--client', '--native-agent', '--child-id']);
+        else if (intent === 'hook-start') {
+            const missing = requireValues([
+                ...(taskRef === 'auto' ? ['--client'] : []),
+                '--native-agent', '--child-id', '--parent-id'
+            ]);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'hook-start' requires '${missing}'`);
                 return;
             }
-            result = sealMatchingOrchestrationDelegation(values['--client'], {
+            const event = {
                 nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
                 actualModel: values['--actual-model'],
                 actualReasoningEffort: values['--actual-reasoning-effort'],
                 modelFallbackReason: values['--model-fallback-reason'],
                 reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-            }, coreOptions);
+            };
+            result = taskRef === 'auto'
+                ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
+                : activateOrchestrationDelegation(taskRef, event, coreOptions);
+        }
+        else if (intent === 'hook-stop') {
+            if (taskRef === 'auto') {
+                const missing = requireValues(['--client', '--native-agent', '--child-id']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                result = sealMatchingOrchestrationDelegation(values['--client'], {
+                    nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+            else {
+                const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                const exitCode = Number(values['--exit-code']);
+                if (!Number.isInteger(exitCode)) {
+                    usageFailure('--exit-code must be an integer');
+                    return;
+                }
+                result = sealOrchestrationDelegation(taskRef, {
+                    childId: values['--child-id'], exitCode,
+                    afterFingerprint: values['--after-fingerprint'],
+                    changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+        }
+        else if (intent === 'advance') {
+            result = advanceOrchestration(taskRef, coreOptions);
         }
         else {
-            const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+            const missing = requireValues(['--code', '--message', '--recoverable']);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'pause' requires '${missing}'`);
                 return;
             }
-            const exitCode = Number(values['--exit-code']);
-            if (!Number.isInteger(exitCode)) {
-                usageFailure('--exit-code must be an integer');
+            if (!['true', 'false'].includes(values['--recoverable'])) {
+                usageFailure('--recoverable must be true or false');
                 return;
             }
-            result = sealOrchestrationDelegation(taskRef, {
-                childId: values['--child-id'], exitCode,
-                afterFingerprint: values['--after-fingerprint'],
-                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
-                actualModel: values['--actual-model'],
-                actualReasoningEffort: values['--actual-reasoning-effort'],
-                modelFallbackReason: values['--model-fallback-reason'],
-                reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-            }, coreOptions);
-        }
-    }
-    else if (intent === 'advance') {
-        result = advanceOrchestration(taskRef, coreOptions);
-    }
-    else {
-        const missing = requireValues(['--code', '--message', '--recoverable']);
-        if (missing) {
-            usageFailure(`intent 'pause' requires '${missing}'`);
-            return;
-        }
-        if (!['true', 'false'].includes(values['--recoverable'])) {
-            usageFailure('--recoverable must be true or false');
-            return;
-        }
-        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+            result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OrchestrationStateError))
+            throw error;
+        result = {
+            status: 'failed',
+            changed: false,
+            taskId: error.taskId,
+            run: null,
+            next: null,
+            error: { code: error.code, message: error.message }
+        };
     }
-    process.stdout.write(`${JSON.stringify(result)}\n`);
+    const output = result;
+    process.stdout.write(`${JSON.stringify(output)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;
 }

package/dist/lib/{task/commands/validate.js → internal/task-validate.js}

@@ -3,19 +3,19 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { loadConfig } from '../../sandbox/config.js';
-import { detectEngine } from '../../sandbox/engine.js';
-import { runEngine } from '../../sandbox/shell.js';
-import { sandboxBranchLabel, sandboxLabel } from '../../sandbox/constants.js';
-import { fetchSandboxRows, selectSandboxContainer } from '../../sandbox/commands/list-running.js';
-import { containerNameCandidates } from '../../sandbox/constants.js';
-import { resolveSandboxTarget } from '../../sandbox/workspace-identity.js';
-import { sandboxControlPaths } from '../../sandbox/workspace-view.js';
-import { appendSandboxControlAudit, readActiveLease, readSandboxControlStatus } from '../../sandbox/control/state.js';
-import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../../sandbox/control/protocol.js';
-import { getProcessStartTime } from '../../server/process-state.js';
-import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
-const USAGE = `Usage: ai task validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] -- <command> [args...]`;
+import { loadConfig } from '../sandbox/config.js';
+import { detectEngine } from '../sandbox/engine.js';
+import { runEngine } from '../sandbox/shell.js';
+import { sandboxBranchLabel, sandboxLabel } from '../sandbox/constants.js';
+import { fetchSandboxRows, selectSandboxContainer } from '../sandbox/commands/list-running.js';
+import { containerNameCandidates } from '../sandbox/constants.js';
+import { resolveSandboxTarget } from '../sandbox/workspace-identity.js';
+import { sandboxControlPaths } from '../sandbox/workspace-view.js';
+import { appendSandboxControlAudit, readActiveLease, readSandboxControlStatus } from '../sandbox/control/state.js';
+import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../sandbox/control/protocol.js';
+import { getProcessStartTime } from '../server/process-state.js';
+import { assertGitWorktreeBinding } from '../git/worktree-identity.js';
+const USAGE = `Usage: agent-infra-internal task-validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] -- <command> [args...]`;
 const MAX_TIMEOUT_MS = 60 * 60 * 1000;
 const RECOVERY_GRACE_MS = 30_000;
 export function parseValidateArgs(args) {
@@ -254,36 +254,69 @@ function inplaceValidation(config, target, options) {
         }
     }
 }
-export async function validate(args) {
-    const options = parseValidateArgs(args);
+function errorCode(message) {
+    const match = message.match(/^([A-Z][A-Z0-9_]*)/);
+    return match && match[1].length >= 3 ? match[1] : 'TASK_VALIDATE_FAILED';
+}
+function fail(format, code, message) {
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code, message } })}\n`);
+    }
+    else {
+        process.stderr.write(`${message}\n`);
+    }
+    process.exitCode = 1;
+}
+function sniffFormat(args) {
+    const index = args.indexOf('--format');
+    return index >= 0 && args[index + 1] === 'json' ? 'json' : 'text';
+}
+function taskValidate(args) {
+    let options;
+    try {
+        options = parseValidateArgs(args);
+    }
+    catch (error) {
+        fail(sniffFormat(args), 'TASK_VALIDATE_ARGS_INVALID', error instanceof Error ? error.message : String(error));
+        return;
+    }
     if (options.help) {
         process.stdout.write(`${USAGE}\n`);
-        return 0;
+        return;
+    }
+    try {
+        const config = loadConfig();
+        const target = resolveSandboxTarget(options.target, config.repoRoot);
+        const commit = git(config.repoRoot, ['rev-parse', target.branch]);
+        const startedAt = new Date().toISOString();
+        const result = options.scope === 'snapshot'
+            ? snapshotValidation(config.repoRoot, commit, options)
+            : inplaceValidation(config, target, options);
+        const evidence = {
+            version: 1,
+            taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
+            branch: target.branch,
+            scope: options.scope,
+            commit,
+            command: path.basename(options.command[0]),
+            startedAt,
+            completedAt: new Date().toISOString(),
+            exitCode: result.exitCode,
+            signal: result.signal,
+            cleanup: result.cleanup()
+        };
+        if (options.format === 'json') {
+            process.stdout.write(`${JSON.stringify({ status: 'applied', changed: false, evidence, error: null })}\n`);
+        }
+        else {
+            process.stdout.write(`Validation ${result.exitCode === 0 ? 'passed' : 'failed'} (${options.scope}, ${evidence.command}, cleanup=${evidence.cleanup}).\n`);
+        }
+        process.exitCode = result.exitCode;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        fail(options.format, errorCode(message), message);
     }
-    const config = loadConfig();
-    const target = resolveSandboxTarget(options.target, config.repoRoot);
-    const commit = git(config.repoRoot, ['rev-parse', target.branch]);
-    const startedAt = new Date().toISOString();
-    const result = options.scope === 'snapshot'
-        ? snapshotValidation(config.repoRoot, commit, options)
-        : inplaceValidation(config, target, options);
-    const evidence = {
-        version: 1,
-        taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
-        branch: target.branch,
-        scope: options.scope,
-        commit,
-        command: path.basename(options.command[0]),
-        startedAt,
-        completedAt: new Date().toISOString(),
-        exitCode: result.exitCode,
-        signal: result.signal,
-        cleanup: result.cleanup()
-    };
-    if (options.format === 'json')
-        process.stdout.write(`${JSON.stringify(evidence)}\n`);
-    else
-        process.stdout.write(`Validation ${result.exitCode === 0 ? 'passed' : 'failed'} (${options.scope}, ${evidence.command}, cleanup=${evidence.cleanup}).\n`);
-    return result.exitCode;
 }
-//# sourceMappingURL=validate.js.map
+export { taskValidate };
+//# sourceMappingURL=task-validate.js.map