@fitlab-ai/agent-infra 0.9.10 → 0.9.11

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

@@ -1,7 +1,6 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
-import { verifyTaskEvent } from '../task/verification.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`;
@@ -15,18 +14,25 @@ function fail(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
+function parseFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
+}
 function taskFinalization(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
-        fail('task ref, complete intent, and --agent are required');
+    let operation;
+    try {
+        operation = parseTaskControlOperation('task-finalization', args);
+    }
+    catch (error) {
+        fail(parseFailure(error));
         return;
     }
-    const agent = normalizeAgentToken(args[3]);
-    if (!agent) {
-        fail(`invalid --agent: ${AGENT_USAGE_HINT}`);
+    if (operation.family !== 'task-finalization') {
+        fail('finalization operation is invalid');
         return;
     }
     let repoRoot;
@@ -39,14 +45,18 @@ function taskFinalization(args = []) {
         process.exitCode = 1;
         return;
     }
-    const resolved = resolveTaskRef(args[0], { repoRoot });
+    const resolved = resolveTaskRef(operation.request.taskRef, { repoRoot });
     if (!resolved.ok) {
         const detail = { code: resolved.code, message: resolved.message, retryable: false };
         process.stdout.write(envelope('failed', false, true, null, detail));
         process.exitCode = 1;
         return;
     }
-    const result = applyTaskFinalization({ taskRef: resolved.taskId, intent: 'complete', agent }, { repoRoot, preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options) });
+    const boundOperation = {
+        ...operation,
+        request: { ...operation.request, taskRef: resolved.taskId }
+    };
+    const result = dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), boundOperation);
     process.stdout.write(envelope(result.status, result.changed, true, result, result.error));
     process.exitCode = exitCode(result.status);
 }

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { applyLedgerIntent } from '../task/ledger-intents.js';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
-import { isReviewStage, parseLedger, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.js';
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, stage-status\n`;
@@ -110,7 +110,13 @@ function taskLedger(args = []) {
             return;
         }
         try {
-            const rows = parseLedger(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+            const ledger = parseLedgerDocument(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+            if (!ledger.present) {
+                process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, taskId: resolved.taskId, error: { code: LEDGER_SECTION_MISSING_CODE, message: LEDGER_SECTION_MISSING_MESSAGE } })}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            const rows = ledger.rows;
             const invalid = validateLedgerRows(rows);
             if (invalid) {
                 process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, taskId: resolved.taskId, error: invalid })}\n`);

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

@@ -1,76 +1,36 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
-import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.js';
+import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
+import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
-const FLAGS = {
-    '--agent': 'agent', '--reason': 'reason', '--unblock-condition': 'unblockCondition',
-    '--note': 'note', '--alert-number': 'alertNumber', '--staging-dir': 'stagingDir',
-    '--issue-number': 'issueNumber', '--override-ticket': 'overrideTicket',
-    '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
-};
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
+function parseFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
+}
 function taskLifecycle(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length < 2) {
-        usageFailure('task ref and intent are required');
-        return;
-    }
-    const values = { taskRef: args[0], intent: args[1], agent: '' };
-    const seen = new Set();
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (flag === '--dry-run') {
-            if (seen.has(flag)) {
-                usageFailure(`duplicate option '${flag}'`);
-                return;
-            }
-            seen.add(flag);
-            values.dryRun = true;
-            continue;
-        }
-        const key = FLAGS[flag];
-        if (!key) {
-            usageFailure(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            usageFailure(`duplicate option '${flag}'`);
-            return;
-        }
-        const value = args[++index];
-        if (value === undefined || value.startsWith('--')) {
-            usageFailure(`option '${flag}' requires a value`);
-            return;
-        }
-        seen.add(flag);
-        values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
+    let operation;
+    try {
+        operation = parseTaskControlOperation('task-lifecycle', args);
     }
-    const agent = normalizeAgentToken(String(values.agent ?? ''));
-    if (!agent) {
-        usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+    catch (error) {
+        usageFailure(parseFailure(error));
         return;
     }
-    values.agent = agent;
-    const dryRunConflict = overrideDryRunConflict(values);
-    if (dryRunConflict) {
-        usageFailure(dryRunConflict.message);
+    if (operation.family !== 'task-lifecycle') {
+        usageFailure('lifecycle operation is invalid');
         return;
     }
+    const request = operation.request;
     let repoRoot;
-    let taskId;
-    if (values.intent === 'restore') {
-        // restore's precondition is that the task does NOT exist locally yet (it only lives
-        // in a staging dir), so resolveTaskRef's existence check is inapplicable here; identity
-        // is guaranteed by applyTaskLifecycle's own full-TASK-id check plus staging validation.
+    if (request.intent === 'restore') {
         try {
             repoRoot = detectRepoRoot();
         }
@@ -79,53 +39,17 @@ function taskLifecycle(args = []) {
             process.exitCode = 1;
             return;
         }
-        taskId = String(values.taskRef);
     }
     else {
-        const resolved = resolveTaskRef(String(values.taskRef));
+        const resolved = resolveTaskRef(request.taskRef);
         if (!resolved.ok) {
             process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
             process.exitCode = 1;
             return;
         }
         repoRoot = resolved.repoRoot;
-        taskId = resolved.taskId;
-    }
-    let result;
-    try {
-        result = withTaskExecutionLock(repoRoot, taskId, `task-lifecycle.${String(values.intent)}`, () => {
-            const lifecycleResult = applyTaskLifecycle(values);
-            if (lifecycleResult.status !== 'failed' || !values.overrideTicket)
-                return lifecycleResult;
-            if (!values.overrideTarget || !values.overrideScope) {
-                return {
-                    ...lifecycleResult,
-                    error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
-                };
-            }
-            const override = consumeHumanOverride({
-                taskRef: String(values.taskRef),
-                ticketId: String(values.overrideTicket),
-                failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
-                target: String(values.overrideTarget),
-                scope: String(values.overrideScope),
-                intent: String(values.intent),
-                ...(values.alertNumber ? { alertNumber: Number(values.alertNumber) } : {}),
-                ...(values.issueNumber ? { issueNumber: Number(values.issueNumber) } : {}),
-                ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {})
-            });
-            if (override.status === 'failed')
-                return { ...lifecycleResult, humanOverride: override };
-            return { ...lifecycleResult, ...override, humanOverride: override, error: null };
-        });
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-        process.exitCode = 1;
-        return;
     }
+    const result = dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), operation);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

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

@@ -1,6 +1,6 @@
-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';
+import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
+import { OrchestrationStateError } from '../task/orchestration.js';
+import { detectRepoRoot } from '../task/resolve-ref.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> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
@@ -10,236 +10,50 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 2;
 }
+function parseFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
+}
 async function taskOrchestration(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length < 2) {
-        usageFailure('task ref and intent are required');
-        return;
+    let operation;
+    try {
+        operation = parseTaskControlOperation('task-orchestration', args);
     }
-    const [taskRef, intent] = args;
-    if (![
-        'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
-    ].includes(intent)) {
-        usageFailure(`unknown intent '${intent}'`);
+    catch (error) {
+        usageFailure(parseFailure(error));
         return;
     }
-    const values = {};
-    const seen = new Set();
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (![
-            '--max-steps', '--executor-model', '--executor-reasoning-effort',
-            '--reviewer-model', '--reviewer-reasoning-effort',
-            '--client', '--requested-model', '--requested-reasoning-effort', '--capability-token',
-            '--parent-id', '--before-fingerprint',
-            '--stage', '--round', '--artifact', '--role',
-            '--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',
-            '--git-worktree-root'
-        ].includes(flag)) {
-            usageFailure(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            usageFailure(`duplicate option '${flag}'`);
-            return;
-        }
-        seen.add(flag);
-        const value = args[++index];
-        if (!value || value.startsWith('--')) {
-            usageFailure(`option '${flag}' requires a value`);
-            return;
-        }
-        values[flag] = value;
-    }
-    const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
-    const coreOptions = values['--git-worktree-root'] === undefined
-        ? {}
-        : { gitWorktreeRoot: values['--git-worktree-root'] };
-    if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
-        usageFailure(`unknown client '${values['--client']}'`);
+    if (operation.family !== 'task-orchestration') {
+        usageFailure('orchestration operation is invalid');
         return;
     }
-    let result;
+    let repoRoot = process.cwd();
     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 (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;
-            }
-            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']);
-                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(['--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);
-        }
+        repoRoot = detectRepoRoot();
+    }
+    catch { /* domain resolution reports the repository error */ }
+    try {
+        const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({
+            repoRoot,
+            ...(process.env.AGENT_INFRA_RUNTIME_DIR ? { runtimeDir: process.env.AGENT_INFRA_RUNTIME_DIR } : {})
+        }), operation);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
     }
     catch (error) {
         if (!(error instanceof OrchestrationStateError))
             throw error;
-        result = {
-            status: 'failed',
-            changed: false,
-            taskId: error.taskId,
-            run: null,
-            next: null,
+        process.stdout.write(`${JSON.stringify({
+            status: 'failed', changed: false, taskId: error.taskId, run: null, next: null,
             error: { code: error.code, message: error.message }
-        };
-    }
-    const output = result;
-    process.stdout.write(`${JSON.stringify(output)}\n`);
-    if (result.status === 'failed')
+        })}\n`);
         process.exitCode = 1;
+    }
 }
 export { taskOrchestration };
 //# sourceMappingURL=task-orchestration.js.map

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

@@ -12,6 +12,7 @@ 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 { readSandboxControlManifest } from '../sandbox/control/lifecycle.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';
@@ -150,7 +151,7 @@ function inplaceValidation(config, target, options) {
         base: config.controlBase, project: config.project,
         container: row.name, identity: target.workspace
     });
-    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
+    const manifest = readSandboxControlManifest(control.manifestPath);
     const initial = readSandboxControlStatus(control.statusDir);
     const now = Date.now();
     if (initial.generation !== manifest.generation