@fitlab-ai/agent-infra 0.9.7 → 0.9.8

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

@@ -302,7 +302,7 @@ async function taskOrchestration(args = []) {
     else if (intent === 'hook-start') {
         const missing = requireValues([
             ...(taskRef === 'auto' ? ['--client'] : []),
-            '--native-agent', '--child-id', '--parent-id', '--spawn-mode'
+            '--native-agent', '--child-id', '--parent-id'
         ]);
         if (missing) {
             usageFailure(`intent 'hook-start' requires '${missing}'`);
@@ -328,7 +328,11 @@ async function taskOrchestration(args = []) {
                 return;
             }
             result = sealMatchingOrchestrationDelegation(values['--client'], {
-                nativeAgent: values['--native-agent'], childId: values['--child-id']
+                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 {
@@ -345,7 +349,11 @@ async function taskOrchestration(args = []) {
             result = sealOrchestrationDelegation(taskRef, {
                 childId: values['--child-id'], exitCode,
                 afterFingerprint: values['--after-fingerprint'],
-                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
+                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);
         }
     }

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

@@ -0,0 +1,131 @@
+import { consumeHumanOverride, diagnoseHumanOverrideForTask, issueHumanOverride } from '../task/human-override.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+const USAGE = `Usage: agent-infra-internal task-override <task-ref> <diagnose|issue|consume> [options]
+
+Options: --failure-id <id> --target <target> --operator <operator> --reason <reason> --scope <scope>
+         --intent <lifecycle-intent> --alert-number <N> --issue-number <N> --staging-dir <path>
+         --expires-at <timestamp> --ticket <ticket-id> --pr-number <N>
+`;
+const FLAGS = {
+    '--failure-id': 'failureId',
+    '--target': 'target',
+    '--operator': 'operator',
+    '--reason': 'reason',
+    '--scope': 'scope',
+    '--intent': 'intent',
+    '--failure-digest': 'failureDigest',
+    '--expires-at': 'expiresAt',
+    '--ticket': 'ticketId',
+    '--facts': 'observedFacts',
+    '--alert-number': 'alertNumber',
+    '--issue-number': 'issueNumber',
+    '--pr-number': 'pullRequestNumber',
+    '--staging-dir': 'stagingDir'
+};
+function usageFailure(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'OVERRIDE_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function taskOverride(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const [taskRef, operation] = args;
+    if (!taskRef || !operation || !['diagnose', 'issue', 'consume'].includes(operation)) {
+        usageFailure('task ref and a valid operation are required');
+        return;
+    }
+    const values = { taskRef };
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        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 === 'observedFacts' ? value.split(',').map((fact) => fact.trim()).filter(Boolean)
+            : key === 'alertNumber' || key === 'issueNumber' || key === 'pullRequestNumber' ? Number(value) : value;
+    }
+    const required = {
+        diagnose: [],
+        issue: ['failureId', 'target', 'operator', 'reason', 'scope', 'expiresAt'],
+        consume: ['failureId', 'target', 'scope', 'ticketId']
+    };
+    const missing = required[operation].find((key) => values[key] === undefined);
+    if (missing) {
+        usageFailure(`${operation} requires '--${missing.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}'`);
+        return;
+    }
+    const resolved = resolveTaskRef(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;
+    }
+    let result;
+    try {
+        if (operation === 'diagnose') {
+            result = diagnoseHumanOverrideForTask(taskRef, values.failureId ? String(values.failureId) : undefined, values.target ? String(values.target) : undefined);
+        }
+        else if (operation === 'issue') {
+            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.issue', () => issueHumanOverride({
+                taskRef,
+                failureId: String(values.failureId),
+                target: String(values.target),
+                operator: String(values.operator),
+                reason: String(values.reason),
+                scope: String(values.scope),
+                expiresAt: String(values.expiresAt),
+                ...(values.intent ? { intent: String(values.intent) } : {}),
+                ...(values.alertNumber !== undefined ? { alertNumber: Number(values.alertNumber) } : {}),
+                ...(values.issueNumber !== undefined ? { issueNumber: Number(values.issueNumber) } : {}),
+                ...(values.pullRequestNumber !== undefined ? { pullRequestNumber: Number(values.pullRequestNumber) } : {}),
+                ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {}),
+                ...(values.failureDigest ? { failureDigest: String(values.failureDigest) } : {})
+            }));
+        }
+        else {
+            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.consume', () => consumeHumanOverride({
+                taskRef,
+                ticketId: String(values.ticketId),
+                failureId: String(values.failureId),
+                target: String(values.target),
+                scope: String(values.scope),
+                ...(values.intent ? { intent: String(values.intent) } : {}),
+                ...(values.alertNumber !== undefined ? { alertNumber: Number(values.alertNumber) } : {}),
+                ...(values.issueNumber !== undefined ? { issueNumber: Number(values.issueNumber) } : {}),
+                ...(values.pullRequestNumber !== undefined ? { pullRequestNumber: Number(values.pullRequestNumber) } : {}),
+                ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {}),
+                ...(values.failureDigest ? { failureDigest: String(values.failureDigest) } : {}),
+                ...(values.observedFacts ? { observedFacts: values.observedFacts } : {})
+            }));
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TaskExecutionLockError) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: cause.code, message: cause.message } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        throw cause;
+    }
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskOverride };
+//# sourceMappingURL=task-override.js.map

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

@@ -1,5 +1,8 @@
 import { finalizeReviewSummary } from '../task/review-finalization.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -27,10 +30,13 @@ function taskReview(args = []) {
     let artifact = '';
     let dryRun = false;
     let orchestrated = false;
+    let overrideTicket = '';
+    let overrideTarget = '';
+    let overrideScope = '';
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (!['--stage', '--artifact', '--orchestrated', '--dry-run'].includes(flag)) {
+        if (!['--stage', '--artifact', '--orchestrated', '--dry-run', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
             failUsage(`unknown option '${flag}'`);
             return;
         }
@@ -54,16 +60,68 @@ function taskReview(args = []) {
         }
         if (flag === '--stage')
             stage = value;
-        else
+        else if (flag === '--artifact')
             artifact = value;
+        else if (flag === '--override-ticket')
+            overrideTicket = value;
+        else if (flag === '--override-target')
+            overrideTarget = value;
+        else if (flag === '--override-scope')
+            overrideScope = value;
     }
     if (!stage || !artifact) {
         failUsage("options '--stage' and '--artifact' are required");
         return;
     }
-    const result = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun });
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed')
+    const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
+    if (dryRunConflict) {
+        failUsage(dryRunConflict.message);
+        return;
+    }
+    const resolved = resolveTaskRef(args[0]);
+    if (!resolved.ok) {
+        failUsage(resolved.message);
+        return;
+    }
+    let result;
+    let humanOverride = null;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', () => {
+            let current = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
+            if (current.status !== 'failed' || !overrideTicket)
+                return current;
+            if (!overrideTarget || !overrideScope) {
+                failUsage('override ticket requires target and scope');
+                return current;
+            }
+            const consumed = consumeHumanOverride({
+                taskRef: args[0], ticketId: overrideTicket,
+                failureId: failureId('review-finalization', current.error?.code ?? 'TASK_STATE_MISMATCH'),
+                target: overrideTarget, scope: overrideScope
+            }, {
+                effectExecutor: (capability) => {
+                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
+                    current = retried;
+                    return retried.status === 'failed' || retried.status === 'planned'
+                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no review effect was committed' : `${retried.error?.code ?? 'REVIEW_FAILED'}: ${retried.error?.message ?? 'manual review effect failed'}` }
+                        : null;
+                }
+            });
+            humanOverride = consumed;
+            return current;
+        });
+    }
+    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;
+    }
+    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
+    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
+        humanOverride.status === 'failed');
+    if (result.status === 'failed' || overrideFailed)
         process.exitCode = 1;
 }
 export { taskReview };

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

@@ -1,5 +1,8 @@
 import { renderTaskVerification, verifyTaskEvent } from '../task/verification.js';
-const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text]\n';
+import { consumeHumanOverride, failureId } from '../task/human-override.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'VERIFY_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -14,12 +17,17 @@ function taskVerify(args = []) {
         fail('task ref and verification event are required');
         return;
     }
+    const taskRef = args[0];
+    const event = args[1];
     let artifact;
     let format = 'json';
+    let overrideTicket;
+    let overrideTarget;
+    let overrideScope;
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag !== '--artifact' && flag !== '--format') {
+        if (!['--artifact', '--format', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
             fail(`unknown option '${flag}'`);
             return;
         }
@@ -35,6 +43,12 @@ function taskVerify(args = []) {
         seen.add(flag);
         if (flag === '--artifact')
             artifact = value;
+        else if (flag === '--override-ticket')
+            overrideTicket = value;
+        else if (flag === '--override-target')
+            overrideTarget = value;
+        else if (flag === '--override-scope')
+            overrideScope = value;
         else if (value === 'json' || value === 'text')
             format = value;
         else {
@@ -42,7 +56,55 @@ function taskVerify(args = []) {
             return;
         }
     }
-    const result = verifyTaskEvent({ taskRef: args[0], event: args[1], ...(artifact ? { artifact } : {}) });
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        fail(resolved.message);
+        return;
+    }
+    let result;
+    let humanOverride = null;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, () => {
+            let current = verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) });
+            if (current.status === 'pass' || !overrideTicket)
+                return current;
+            if (!overrideTarget || !overrideScope) {
+                fail('override ticket requires target and scope');
+                return current;
+            }
+            const failureProducer = current.status === 'blocked' || current.status === 'fail'
+                ? 'verification-engine'
+                : 'task-verify';
+            const failureCode = current.status === 'blocked'
+                ? 'CHECK_BLOCKED'
+                : current.status === 'fail'
+                    ? 'CHECK_FAILED'
+                    : current.error?.code ?? 'VERIFY_TASK_STATE_MISMATCH';
+            const consumed = consumeHumanOverride({
+                taskRef, ticketId: overrideTicket,
+                failureId: failureId(failureProducer, failureCode),
+                target: overrideTarget, scope: overrideScope
+            }, {
+                effectExecutor: (capability) => {
+                    const retried = verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }, { manualOverride: capability });
+                    current = retried;
+                    return retried.status !== 'pass'
+                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: `${retried.error?.code ?? 'VERIFY_FAILED'}: ${retried.error?.message ?? 'manual verification effect failed'}` }
+                        : null;
+                }
+            });
+            humanOverride = consumed;
+            return current;
+        });
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        fail(`${error.code}: ${error.message}`);
+        return;
+    }
+    if (humanOverride)
+        result = { ...result, humanOverride };
     process.stdout.write(format === 'text' ? renderTaskVerification(result) : `${JSON.stringify(result)}\n`);
     process.exitCode = result.status === 'pass' ? 0 : result.status === 'blocked' ? 2 : 1;
 }

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

@@ -1,8 +1,12 @@
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js';
+import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
 const FLAGS = {
     '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
-    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution'
+    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution',
+    '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'WARNING_PAYLOAD_INVALID', message } })}\n`);
@@ -55,6 +59,9 @@ function taskWarning(args = []) {
     };
     const optional = kind === 'list' ? ['status'] : [];
     const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...optional]);
+    allowed.add('overrideTicket');
+    allowed.add('overrideTarget');
+    allowed.add('overrideScope');
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     const missing = required[kind].find((key) => values[key] === undefined);
     if (unexpected) {
@@ -65,9 +72,55 @@ function taskWarning(args = []) {
         usageFailure(`${kind} requires '${missing}'`);
         return;
     }
-    const result = applyWorkflowWarningIntent(values);
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed')
+    const dryRunConflict = overrideDryRunConflict(values);
+    if (dryRunConflict) {
+        usageFailure(dryRunConflict.message);
+        return;
+    }
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        usageFailure(resolved.message);
+        return;
+    }
+    let result;
+    let humanOverride = null;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, () => {
+            let current = applyWorkflowWarningIntent(values);
+            if (current.status !== 'failed' || !values.overrideTicket)
+                return current;
+            if (!values.overrideTarget || !values.overrideScope) {
+                usageFailure('override ticket requires target and scope');
+                return current;
+            }
+            const consumed = consumeHumanOverride({
+                taskRef, ticketId: String(values.overrideTicket),
+                failureId: failureId('workflow-warning', current.error?.code ?? 'TASK_STATE_MISMATCH'),
+                target: String(values.overrideTarget), scope: String(values.overrideScope)
+            }, {
+                effectExecutor: (capability) => {
+                    const retried = applyWorkflowWarningIntent(values, { manualOverride: capability });
+                    current = retried;
+                    return retried.status === 'failed' || retried.status === 'planned'
+                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no workflow warning effect was committed' : `${retried.error?.code ?? 'WARNING_FAILED'}: ${retried.error?.message ?? 'manual warning effect failed'}` }
+                        : null;
+                }
+            });
+            humanOverride = consumed;
+            return current;
+        });
+    }
+    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;
+    }
+    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
+    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
+        humanOverride.status === 'failed');
+    if (result.status === 'failed' || overrideFailed)
         process.exitCode = 1;
 }
 export { taskWarning };

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

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { enumerateArtifacts } from '../task/artifacts.js';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { renderHumanOverrideAudit } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
@@ -10,8 +11,9 @@ import { platformResult } from './types.js';
 function summaryMarker(taskId) {
     return `<!-- sync-pr:${taskId}:summary -->`;
 }
-function buildPullRequestSummary(taskId, body, headSha) {
-    return normalizeCommentContent(`${summaryMarker(taskId)}\n<!-- last-commit: ${headSha} -->\n\n${body.replace(/\s+$/, '')}\n`);
+function buildPullRequestSummary(taskId, body, headSha, humanOverrideAudit = '') {
+    const sections = [body.replace(/\s+$/, ''), humanOverrideAudit.trim()].filter(Boolean).join('\n\n');
+    return normalizeCommentContent(`${summaryMarker(taskId)}\n<!-- last-commit: ${headSha} -->\n\n${sections}\n`);
 }
 function reconcileSummaryComment(comments, taskId, desired) {
     const marker = summaryMarker(taskId);
@@ -67,7 +69,7 @@ function syncPullRequestSummary(taskRef, options) {
     catch (error) {
         return platformResult('failed', { platform: context.platform, capabilities: context.capabilities, error: { code: 'GIT_HEAD_UNRESOLVED', message: error instanceof Error ? error.message : String(error), retryable: false } });
     }
-    const desired = buildPullRequestSummary(resolved.taskId, options.body, headSha);
+    const desired = buildPullRequestSummary(resolved.taskId, options.body, headSha, renderHumanOverrideAudit(fs.readFileSync(resolved.taskMdPath, 'utf8')));
     const listed = listRemoteComments(client, context.platform.repository, prNumber, resolved.repoRoot);
     if (!listed.ok)
         return platformResult(listed.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: listed.error });

package/dist/lib/runtime/agent-runtime.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+const CLIENT_NAMESPACE = /^[a-z][a-z0-9-]{0,31}$/u;
+function runtimeError(code, message) {
+    const error = new Error(`${code}: ${message}`);
+    error.name = code;
+    return error;
+}
+function boundControlContext(env) {
+    return [
+        'AGENT_INFRA_CONTROL_TOKEN',
+        'AGENT_INFRA_CONTROL_GENERATION',
+        'AGENT_INFRA_EXECUTOR_MANIFEST',
+        'AGENT_INFRA_CODEX_CONTROLLER_CONTEXT'
+    ].some((key) => typeof env[key] === 'string' && env[key].length > 0);
+}
+function clientNamespace(client) {
+    if (!CLIENT_NAMESPACE.test(client)) {
+        throw runtimeError('AGENT_INFRA_RUNTIME_CLIENT_INVALID', `invalid runtime client namespace '${client}'`);
+    }
+    return client;
+}
+export function resolveAgentRuntimeRoot(options = {}) {
+    const env = options.env ?? process.env;
+    const configured = env.AGENT_INFRA_RUNTIME_DIR;
+    if (configured !== undefined && configured.length > 0) {
+        if (!path.isAbsolute(configured)) {
+            throw runtimeError('AGENT_INFRA_RUNTIME_DIR_INVALID', 'runtime directory must be absolute');
+        }
+        return path.resolve(configured);
+    }
+    if (boundControlContext(env)) {
+        throw runtimeError('AGENT_INFRA_RUNTIME_DIR_REQUIRED', 'task-bound control context requires AGENT_INFRA_RUNTIME_DIR');
+    }
+    return path.join(path.resolve(options.repoRoot ?? process.cwd()), '.agents', 'workspace', '.runtime');
+}
+export function resolveAgentRuntimeStoreRoot(options = {}) {
+    const client = clientNamespace(options.client ?? 'codex');
+    if (options.explicitRoot)
+        return path.resolve(options.explicitRoot);
+    const env = options.env ?? process.env;
+    const runtimeRoot = resolveAgentRuntimeRoot({ repoRoot: options.repoRoot, env });
+    if (env.AGENT_INFRA_RUNTIME_DIR) {
+        if (!options.store) {
+            throw runtimeError('AGENT_INFRA_RUNTIME_STORE_INVALID', 'store kind is required for task-bound runtime');
+        }
+        return path.join(runtimeRoot, 'clients', client, options.store);
+    }
+    if (client === 'codex' && options.store) {
+        return path.join(runtimeRoot, `codex-${options.store}`);
+    }
+    if (!options.store) {
+        throw runtimeError('AGENT_INFRA_RUNTIME_STORE_INVALID', 'store kind is required');
+    }
+    return path.join(runtimeRoot, 'clients', client, options.store);
+}
+//# sourceMappingURL=agent-runtime.js.map