@fitlab-ai/agent-infra 0.9.13 → 0.9.15

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

@@ -1,119 +1,31 @@
-import { resolveArtifactContext } from '../task/artifact-lifecycle.js';
-import { finalizeLocalArtifact } from '../task/local-artifact-finalization.js';
-import { resolveTaskRef } from '../task/resolve-ref.js';
-import { loadVerificationConfig } from '../task/verification-config.js';
-const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family>\n       agent-infra-internal task-artifact <N | TASK-id> finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect workflow artifact context or finalize a local analysis/plan/code artifact without changing task state.\n`;
-function failUsage(message) {
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ARTIFACT_PAYLOAD_INVALID', message } })}\n`);
-    process.stderr.write(USAGE);
-    process.exitCode = 2;
-}
+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>\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> repair --family <family> --artifact <artifact> --expected-sha256 <sha256> --expected-semantic-digest <digest>\n       agent-infra-internal task-artifact <N | TASK-id> finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, repair, or finalize a workflow artifact without changing task state.\n`;
 function taskArtifact(args = []) {
+    if (!ensureInternalHandlerRoute('task-artifact', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length < 2) {
-        failUsage('task ref and operation are required');
-        return;
-    }
-    const operation = args[1];
-    if (operation !== 'inspect' && operation !== 'finalize-local') {
-        failUsage(`unknown operation '${operation}'`);
-        return;
-    }
-    let family = '';
-    let artifact = '';
-    const seen = new Set();
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (flag !== '--family' && flag !== '--artifact') {
-            failUsage(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            failUsage(`duplicate option '${flag}'`);
-            return;
-        }
-        const value = args[++index];
-        if (!value || value.startsWith('--')) {
-            failUsage(`option '${flag}' requires a value`);
-            return;
-        }
-        seen.add(flag);
-        if (flag === '--family')
-            family = value;
-        else
-            artifact = value;
-    }
-    if (!family) {
-        failUsage("option '--family' is required");
-        return;
-    }
-    if (operation === 'inspect') {
-        if (artifact) {
-            failUsage("option '--artifact' is only valid for finalize-local");
-            return;
-        }
-        const result = resolveArtifactContext(args[0], family);
-        const output = family === 'code' && result.codeMode ? {
-            ...result,
-            mode: result.codeMode.mode,
-            code_max: result.codeMode.codeMax,
-            rev_max: result.codeMode.reviewMax,
-            verdict: result.codeMode.verdict,
-            next_round: result.next?.round ?? null,
-            next_artifact: result.next?.name ?? null,
-            review_artifact: result.codeMode.reviewArtifact,
-            implementation_input: result.codeMode.implementationInput,
-            decision_id: result.codeMode.decisionId,
-            decision_evidence: result.codeMode.decisionEvidence,
-            message: result.codeMode.message
-        } : result;
-        process.stdout.write(`${JSON.stringify(output)}\n`);
-        if (result.status === 'refused')
-            process.exitCode = 1;
-        else if (result.status === 'failed')
-            process.exitCode = 2;
-        return;
-    }
-    const resolved = resolveTaskRef(args[0]);
-    const repositoryRoot = resolved.ok ? resolved.repoRoot : process.cwd();
-    if (!artifact) {
-        failUsage("option '--artifact' is required");
-        return;
-    }
-    if (family !== 'analysis' && family !== 'plan' && family !== 'code') {
-        failUsage("finalize-local only supports 'analysis', 'plan', and 'code'");
-        return;
-    }
-    const skillName = family === 'analysis' ? 'analyze-task' : family === 'plan' ? 'plan-task' : 'code-task';
-    let config = {};
+    let command;
     try {
-        const loaded = loadVerificationConfig(repositoryRoot, skillName);
-        const artifactConfig = loaded.checks.artifact;
-        if (artifactConfig && typeof artifactConfig === 'object' && !Array.isArray(artifactConfig)) {
-            const sections = artifactConfig.required_sections;
-            const patterns = artifactConfig.required_patterns;
-            config = {
-                requiredSections: Array.isArray(sections) ? sections.filter((value) => typeof value === 'string') : undefined,
-                requiredPatterns: Array.isArray(patterns) ? patterns.filter((value) => typeof value === 'string') : undefined
-            };
-        }
-    }
-    catch {
-        // Isolated fixture repositories may not contain the project's verification config.
+        command = parseArtifactCommand(args);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: {
+                code: 'ARTIFACT_PAYLOAD_INVALID', message: error instanceof Error ? error.message : String(error)
+            } })}\n`);
+        process.stderr.write(USAGE);
+        process.exitCode = 2;
+        return;
     }
-    const result = finalizeLocalArtifact({
-        taskRef: args[0],
-        family: family,
-        artifact,
-        repoRoot: repositoryRoot,
-        ...config
-    });
+    const result = executeArtifactCommand(command);
     process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed')
+    if (result.status === 'refused')
         process.exitCode = 1;
+    else if (result.status === 'failed')
+        process.exitCode = command.operation === 'inspect' ? 2 : 1;
 }
 export { taskArtifact };
 //# sourceMappingURL=task-artifact.js.map

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

@@ -1,5 +1,6 @@
 import { parseTaskScope } from '../task/command-options.js';
 import { resolveTaskContext } from '../task/resolve-ref.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-context resolve [<task-ref> | --task <task-ref> | -t <task-ref>]\n`;
 function fail(code, message, usage = false) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code, message } })}\n`);
@@ -8,11 +9,13 @@ function fail(code, message, usage = false) {
     process.exitCode = 1;
 }
 function taskContext(args = []) {
+    if (!ensureInternalHandlerRoute('task-context', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args[0] !== 'resolve') {
+    if (!internalHandlerRoute('task-context', 'resolve', args[0] ?? '')) {
         fail('TASK_CONTEXT_PAYLOAD_INVALID', "operation 'resolve' is required", true);
         return;
     }

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

@@ -1,21 +1,47 @@
 import fs from 'node:fs';
+import { resolveSandboxControlTransport } from './task-operation-registry.js';
 import path from 'node:path';
 import { requestSandboxTaskCreate, SandboxControlClientError } from '../sandbox/control/client.js';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.js';
 import { validateTaskCreateCandidate } from '../task/create.js';
-import { createTask } from '../task/create-service.js';
-function failed(code, message, retryable = false) {
-    return {
-        status: retryable ? 'blocked' : 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
-        operations: [], warnings: [], error: { code, message, retryable }
-    };
+import { createTask, parseTaskCreateResult, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../task/create-service.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+function failed(code, message, retryable = false, control) {
+    return taskCreateFailure({ code, message, retryable }, control);
 }
 function output(result) {
     process.stdout.write(`${JSON.stringify(result)}\n`);
-    process.exitCode = result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+    process.exitCode = taskCreateExitCode(result);
+}
+function clientErrorControl(error) {
+    return {
+        requestId: error.requestId,
+        accepted: error.accepted,
+        recovery: error.accepted ? 'same-request-id' : error.detail.retryable ? 'new-request-id' : 'none'
+    };
+}
+function parseControlledResult(response) {
+    if (response.phase !== 'completed' || response.error !== null) {
+        return failed('SANDBOX_CONTROL_RESPONSE_INVALID', 'SANDBOX_CONTROL_RESPONSE_INVALID: completed task-create response is invalid', false, { requestId: response.id, accepted: true, recovery: 'same-request-id' });
+    }
+    let result;
+    try {
+        result = parseTaskCreateResult(JSON.parse(response.stdout));
+    }
+    catch {
+        return failed('TASK_CREATE_RESULT_INVALID', 'TASK_CREATE_RESULT_INVALID: task-create result payload is invalid', false, { requestId: response.id, accepted: true, recovery: 'same-request-id' });
+    }
+    if (!result.control || result.control.requestId !== response.id || result.control.accepted !== true) {
+        return failed('TASK_CREATE_RESULT_INVALID', 'TASK_CREATE_RESULT_INVALID: controlled task-create result is missing request evidence', false, { requestId: response.id, accepted: true, recovery: 'same-request-id' });
+    }
+    process.stderr.write(response.stderr);
+    return result;
 }
 async function taskCreate(args) {
-    const inputIndex = args.indexOf('--input');
+    if (!ensureInternalHandlerRoute('task-create', args))
+        return;
+    const inputSelector = args.includes('--input') ? 'input' : '';
+    const inputIndex = internalHandlerRoute('task-create', 'input', inputSelector) ? args.indexOf('--input') : -1;
     const input = inputIndex >= 0 ? args[inputIndex + 1] : undefined;
     if (!input || args.length !== 2 || inputIndex !== 0) {
         output(failed('TASK_CREATE_PAYLOAD_INVALID', 'Usage: agent-infra-internal task-create --input <candidate.json>'));
@@ -29,22 +55,30 @@ async function taskCreate(args) {
         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')));
-        if (process.env.AGENT_INFRA_CONTROL_TOKEN) {
+        const environment = resolveSandboxControlTransport();
+        if (environment.kind === 'fail-closed') {
+            output(failed(environment.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID', 'sandbox client control configuration is invalid'));
+            return;
+        }
+        if (environment.kind === 'broker-client') {
             const response = requestSandboxTaskCreate({ candidate });
             if (response.phase === 'rejected') {
-                output(failed(response.error?.code ?? 'SANDBOX_CONTROL_REJECTED', response.error?.message ?? response.stderr, response.error?.retryable ?? false));
+                const accepted = response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN';
+                output(failed(response.error?.code ?? 'SANDBOX_CONTROL_REJECTED', response.error?.message ?? response.stderr, response.error?.retryable ?? false, {
+                    requestId: response.id,
+                    accepted,
+                    recovery: accepted ? 'same-request-id' : response.error?.retryable ? 'new-request-id' : 'none'
+                }));
                 return;
             }
-            process.stdout.write(response.stdout);
-            process.stderr.write(response.stderr);
-            process.exitCode = response.exitCode;
+            output(parseControlledResult(response));
             return;
         }
         output(await createTask(candidate, { repoRoot: process.cwd() }));
     }
     catch (error) {
         if (error instanceof SandboxControlClientError) {
-            output(failed(error.detail.code, error.detail.message, error.detail.retryable));
+            output(failed(error.detail.code, error.detail.message, error.detail.retryable, clientErrorControl(error)));
             return;
         }
         const message = error instanceof Error ? error.message : String(error);

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

@@ -1,11 +1,14 @@
 import path from 'node:path';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { deliverTaskBranch } from '../task/delivery.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-delivery <task-ref> deliver --agent <agent> [--remote <name>] [--base <branch>] [--dry-run] [--cwd <path>]\n`;
 function taskDelivery(args = []) {
+    if (!ensureInternalHandlerRoute('task-delivery', args))
+        return;
     const taskRef = args[0];
     const operation = args[1];
-    if (!taskRef || operation !== 'deliver') {
+    if (!taskRef || !internalHandlerRoute('task-delivery', 'deliver', operation ?? '')) {
         process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'DELIVERY_PAYLOAD_INVALID', message: 'task ref and deliver operation are required' } })}\n`);
         process.stderr.write(USAGE);
         process.exitCode = 1;

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

@@ -3,6 +3,7 @@ import { applyTaskEvent, eventCatalog } from '../task/events.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';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
@@ -17,6 +18,7 @@ const FLAGS = {
     '--verdict': 'verdict', '--blockers': 'blockers', '--major': 'major',
     '--minor': 'minor', '--manual-validation': 'manualValidation', '--files-modified': 'filesModified',
     '--tests-passed': 'testsPassed', '--summary-result': 'summaryResult',
+    '--transaction-id': 'transactionId', '--receipt-digest': 'receiptDigest', '--pr-head-sha': 'prHeadSha',
     '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const NUMERIC = new Set(['round', 'question', 'blockers', 'major', 'minor', 'manualValidation', 'filesModified', 'testsPassed']);
@@ -25,51 +27,35 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-async function taskEvent(args = []) {
-    if (args[0] === '--help' || args[0] === '-h') {
-        process.stdout.write(USAGE);
-        return;
-    }
-    if (args.length < 2) {
-        usageFailure('task ref and event are required');
-        return;
-    }
+export function parseTaskEventRequest(args) {
+    if (args.length < 2)
+        throw new Error('task ref and event are required');
     const request = { taskRef: args[0], event: args[1], agent: '' };
     const seen = new Set();
     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;
-            }
+            if (seen.has(flag))
+                throw new Error(`duplicate option '${flag}'`);
             seen.add(flag);
             request.orchestrated = true;
             continue;
         }
         if (flag === '--dry-run') {
-            if (seen.has(flag)) {
-                usageFailure(`duplicate option '${flag}'`);
-                return;
-            }
+            if (seen.has(flag))
+                throw new Error(`duplicate option '${flag}'`);
             seen.add(flag);
             request.dryRun = true;
             continue;
         }
         const key = FLAGS[flag];
-        if (!key) {
-            usageFailure(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            usageFailure(`duplicate option '${flag}'`);
-            return;
-        }
+        if (!key)
+            throw new Error(`unknown option '${flag}'`);
+        if (seen.has(flag))
+            throw new Error(`duplicate option '${flag}'`);
         const value = args[++index];
-        if (value === undefined || value.startsWith('--')) {
-            usageFailure(`option '${flag}' requires a value`);
-            return;
-        }
+        if (value === undefined || value.startsWith('--'))
+            throw new Error(`option '${flag}' requires a value`);
         seen.add(flag);
         if (NUMERIC.has(key))
             request[key] = Number(value);
@@ -79,14 +65,31 @@ async function taskEvent(args = []) {
             request[key] = value;
     }
     const agent = normalizeAgentToken(String(request.agent ?? ''));
-    if (!agent) {
-        usageFailure(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
-        return;
-    }
+    if (!agent)
+        throw new Error(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
     request.agent = agent;
     const dryRunConflict = overrideDryRunConflict(request);
-    if (dryRunConflict) {
-        usageFailure(dryRunConflict.message);
+    if (dryRunConflict)
+        throw new Error(dryRunConflict.message);
+    return request;
+}
+async function taskEvent(args = []) {
+    if (!ensureInternalHandlerRoute('task-event', args))
+        return;
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (!internalHandlerRoute('task-event', 'event', args[1] ? 'event' : '')) {
+        usageFailure('task ref and event are required');
+        return;
+    }
+    let request;
+    try {
+        request = parseTaskEventRequest(args);
+    }
+    catch (error) {
+        usageFailure(error instanceof Error ? error.message : String(error));
         return;
     }
     const resolved = resolveTaskRef(request.taskRef);

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

@@ -1,6 +1,7 @@
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.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`;
@@ -19,6 +20,8 @@ function parseFailure(error) {
     return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
 async function taskFinalization(args = []) {
+    if (!ensureInternalHandlerRoute('task-finalization', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -31,7 +34,7 @@ async function taskFinalization(args = []) {
         fail(parseFailure(error));
         return;
     }
-    if (operation.family !== 'task-finalization') {
+    if (operation.family !== 'task-finalization' || !internalHandlerRoute('task-finalization', 'complete', args[1] ?? '')) {
         fail('finalization operation is invalid');
         return;
     }

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

@@ -1,14 +1,17 @@
 import { reconcileTaskInvalidation } from '../task/invalidation-command.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-invalidation <task-ref> reconcile [--max-targets <n>] [--dry-run]\n';
 function taskInvalidation(args = []) {
+    if (!ensureInternalHandlerRoute('task-invalidation', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const taskRef = args[0];
-    if (!taskRef || args[1] !== 'reconcile') {
+    if (!taskRef || !internalHandlerRoute('task-invalidation', 'reconcile', args[1] ?? '')) {
         process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'INVALIDATION_PAYLOAD_INVALID', message: 'task ref and reconcile are required' } })}\n`);
         process.stderr.write(USAGE);
         process.exitCode = 1;

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

@@ -4,6 +4,7 @@ import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task
 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';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.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, rework-intent-upsert, stage-status\n`;
 const FLAGS = {
     '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
@@ -21,6 +22,8 @@ function usageFailure(message) {
     process.exitCode = 1;
 }
 async function taskLedger(args = []) {
+    if (!ensureInternalHandlerRoute('task-ledger', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -30,7 +33,15 @@ async function taskLedger(args = []) {
         usageFailure('task ref and intent are required');
         return;
     }
-    if (!['finding-upsert', 'finding-respond', 'finding-review', 'decision-next-id', 'decision-upsert', 'rework-intent-upsert', 'stage-status'].includes(kind)) {
+    if (![
+        internalHandlerRoute('task-ledger', 'finding-upsert', kind),
+        internalHandlerRoute('task-ledger', 'finding-respond', kind),
+        internalHandlerRoute('task-ledger', 'finding-review', kind),
+        internalHandlerRoute('task-ledger', 'decision-next-id', kind),
+        internalHandlerRoute('task-ledger', 'decision-upsert', kind),
+        internalHandlerRoute('task-ledger', 'rework-intent-upsert', kind),
+        internalHandlerRoute('task-ledger', 'stage-status', kind)
+    ].some(Boolean)) {
         usageFailure(`unknown ledger intent '${kind}'`);
         return;
     }

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

@@ -1,6 +1,7 @@
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.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`;
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
@@ -12,6 +13,8 @@ function parseFailure(error) {
     return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
 async function taskLifecycle(args = []) {
+    if (!ensureInternalHandlerRoute('task-lifecycle', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -24,7 +27,7 @@ async function taskLifecycle(args = []) {
         usageFailure(parseFailure(error));
         return;
     }
-    if (operation.family !== 'task-lifecycle') {
+    if (operation.family !== 'task-lifecycle' || !internalHandlerRoute('task-lifecycle', 'intent', args[1] ? 'intent' : '')) {
         usageFailure('lifecycle operation is invalid');
         return;
     }