@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/task/commit-operation.js

@@ -7,12 +7,12 @@ import { checkpointCommitMatches } from './commit-identity.js';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.js';
 import { commitPushDecision } from './commit-policy.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { checkpointIntentDigest, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent } from './commit-intent.js';
 const HEAD_REF = /^refs\/heads\/(.+)$/;
 function isCommitExecutionMode(value) {
-    return value === 'direct' || value === 'orchestrated';
+    return value === 'direct';
 }
 function gitText(repoRoot, args) {
     return execFileSync('git', [...args], {
@@ -117,50 +117,43 @@ function validateCommon(input, branch) {
     }
     return null;
 }
-function syncTaskCommit(input, task, committedHead) {
+// Log presentation only; checkpoint identity and recovery never depend on this projection.
+function commitLogProjection(activity, timestamp, agent, commitNote) {
+    if (!activity)
+        return [];
+    let lastCommit = -1;
+    for (const [index, entry] of activity.entries.entries()) {
+        if (entry.step === 'Commit' && entry.note === commitNote)
+            lastCommit = index;
+    }
+    const reviewedAfter = activity.entries.slice(lastCommit + 1).some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
+    if (lastCommit >= 0 && !reviewedAfter)
+        return [];
+    return [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: activity.heading,
+            body: appendActivityEntry(activity, { time: timestamp, step: 'Commit', agent, note: commitNote }) }];
+}
+function syncTaskCommit(input, task, committedHead, writeOptions = {}) {
     let content;
     try {
         content = fs.readFileSync(task.taskMdPath, 'utf8');
         const activity = locateActivityLog(content);
-        if (!activity)
-            return warning('TASK_STATUS_SYNC_FAILED', 'task has no unique Activity Log section', true, 'task', task.taskId, 'ACTION_REQUIRED');
         const metadata = captureTaskWriteMetadata();
         const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
-        let matchingCommitIndex = -1;
-        for (let index = activity.entries.length - 1; index >= 0; index -= 1) {
-            const entry = activity.entries[index];
-            if (entry.step === 'Commit' && entry.note === commitNote) {
-                matchingCommitIndex = index;
-                break;
-            }
-        }
-        const reviewedAfterCommit = matchingCommitIndex >= 0 && activity.entries
-            .slice(matchingCommitIndex + 1)
-            .some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
-        const alreadyLogged = matchingCommitIndex >= 0 && !reviewedAfterCommit;
-        const mutations = [];
-        if (!alreadyLogged)
-            mutations.push({
-                kind: 'section',
-                aliases: ['活动日志', 'Activity Log'],
-                heading: activity.heading,
-                body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Commit', agent: input.agent, note: commitNote })
-            });
+        const mutations = commitLogProjection(activity, metadata.timestamp, input.agent, commitNote);
         const frontmatter = {
             assigned_to: input.agent,
             checkpoint_commit: committedHead
         };
         mutations.push({ kind: 'frontmatter', set: frontmatter });
-        if (mutations.length === 0)
-            return null;
         const written = writeTask({
             taskRef: task.taskId,
             expectedState: 'active',
             mutations
-        }, { repoRoot: task.repoRoot, metadataProvider: () => metadata });
+        }, { ...writeOptions, repoRoot: task.repoRoot, metadataProvider: () => metadata });
         if (written.status === 'failed')
             return warning('TASK_STATUS_SYNC_FAILED', written.error.message, true, 'task', task.taskId, 'ACTION_REQUIRED');
-        return null;
+        const logWarning = activityWarnings(content)[0];
+        return logWarning ? warning(logWarning.code, logWarning.message, true, 'task', task.taskId, 'IMPORTANT') : null;
     }
     catch (error) {
         return warning('TASK_STATUS_SYNC_FAILED', error instanceof Error ? error.message : String(error), true, 'task', task.taskId, 'ACTION_REQUIRED');
@@ -183,12 +176,10 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
-function executeCommitOperationCore(input, task, mode) {
+function executeCommitOperationCore(input, task, mode, writeOptions) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
         return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
-    if (mode === 'orchestrated')
-        return failure(input, mode, task?.taskId ?? null, 'ORCHESTRATED_COMMIT_REMOVED', 'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task', 'blocked', inspected.snapshot);
     const branch = inspected.snapshot.branch;
     const commonError = validateCommon(input, branch);
     if (commonError)
@@ -380,13 +371,13 @@ function executeCommitOperationCore(input, task, mode) {
     }
     if (task && (committed.status === 'applied' || committed.status === 'no-op')) {
         const committedHead = checkpointCommittedHead ?? committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']);
-        const taskWarning = syncTaskCommit(input, task, committedHead);
+        const taskWarning = syncTaskCommit(input, task, committedHead, writeOptions);
         if (taskWarning) {
             warnings.push(taskWarning);
             status = 'applied';
             result = 'committed_with_warnings';
         }
-        if (delivery.mode === 'local' && !taskWarning && pendingIntent && checkpointCommittedHead) {
+        if (delivery.mode === 'local' && taskWarning?.code !== 'TASK_STATUS_SYNC_FAILED' && pendingIntent && checkpointCommittedHead) {
             const synced = updateCheckpointIntent(pendingIntent, {
                 state: 'synced', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
             });
@@ -406,7 +397,7 @@ function executeCommitOperationCore(input, task, mode) {
         error: null
     };
 }
-function executeCommitOperation(input) {
+function executeCommitOperation(input, writeOptions = {}) {
     if (input.mode !== undefined && !isCommitExecutionMode(input.mode))
         return {
             status: 'blocked',
@@ -417,7 +408,7 @@ function executeCommitOperation(input) {
             warnings: [],
             snapshot: null,
             operations: [],
-            error: { code: 'COMMIT_MODE_INVALID', message: 'commit mode must be direct or orchestrated' }
+            error: { code: 'COMMIT_MODE_INVALID', message: 'commit mode must be direct' }
         };
     const mode = input.mode ?? 'direct';
     let normalizedInput;
@@ -431,10 +422,8 @@ function executeCommitOperation(input) {
     if (resolved.kind === 'error')
         return resolved.result;
     const task = resolved.kind === 'bound' ? resolved.task : null;
-    if (mode === 'orchestrated' && !task)
-        return failure(normalizedInput, mode, null, 'ORCHESTRATION_TASK_REQUIRED', 'orchestrated commit requires a task context', 'blocked');
     try {
-        return executeCommitOperationCore(normalizedInput, task, mode);
+        return executeCommitOperationCore(normalizedInput, task, mode, writeOptions);
     }
     catch (error) {
         const code = 'COMMIT_OPERATION_FAILED';

package/dist/lib/task/completion-facts.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { canonicalSemanticDigest } from './artifact-operations.js';
-import { inspectActivityLog, pairEntries } from './activity-log.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseArtifactName } from './artifact-name.js';
 import { sha256File } from './artifact-receipts.js';
@@ -23,56 +23,69 @@ export function parseCompletionFacts(value) {
         return [];
     }
 }
-export function hasArtifactCompletionFact(taskContent, artifactPath, event) {
+function completionEvent(family) {
+    if (family === 'validation-run')
+        return 'validation-run.completed';
+    if (family === 'analysis')
+        return 'analyze.completed';
+    if (family === 'review-analysis')
+        return 'review-analysis.completed';
+    if (family === 'plan')
+        return 'plan.completed';
+    if (family === 'review-plan')
+        return 'review-plan.completed';
+    if (family === 'code')
+        return 'code.completed';
+    if (family === 'review-code')
+        return 'review-code.completed';
+    return null;
+}
+/** Validates an artifact's own completion fact and output evidence. */
+export function hasValidArtifactCompletion(taskContent, taskDir, artifact, event) {
     try {
-        const frontmatter = parseTypedTaskFrontmatter(taskContent);
-        const output = artifactPath.split(/[\\/]/u).at(-1) ?? '';
-        const content = fs.readFileSync(artifactPath, 'utf8');
-        const outputSha256 = sha256File(artifactPath);
-        const semanticDigest = canonicalSemanticDigest(content);
-        return parseCompletionFacts(frontmatter.completion_facts).some((fact) => fact.event === event && fact.output === output
-            && fact.outputSha256 === outputSha256 && fact.semanticDigest === semanticDigest
-            && fact.requestId.length > 0);
+        const fact = findCompletionFact(taskContent, artifact, event);
+        return Boolean(fact && validateOutput(taskDir, artifact, fact));
     }
     catch {
         return false;
     }
 }
-export function hasArtifactCompletionLog(taskContent, artifact, event) {
-    return artifactCompletionOrder(taskContent, artifact, event) !== null;
+/** Distinguishes an invalidated completion fact from a round that has never completed. */
+export function hasArtifactCompletionRecord(taskContent, artifact, event) {
+    try {
+        const raw = parseTypedTaskFrontmatter(taskContent).completion_facts;
+        if (raw === undefined)
+            return false;
+        if (typeof raw !== 'string')
+            return true;
+        if (raw.trim() === '')
+            return false;
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return true;
+        return parsed.some((fact) => fact && typeof fact === 'object' && !Array.isArray(fact)
+            && fact.event === event
+            && fact.output === artifact);
+    }
+    catch {
+        return true;
+    }
 }
-/** Returns the stable Activity Log position of a paired completion row. */
-export function artifactCompletionOrder(taskContent, artifact, event) {
+function findCompletionFact(taskContent, artifact, event) {
     const identity = parseArtifactName(artifact);
-    if (!identity)
+    if (!identity || completionEvent(identity.family) !== event)
         return null;
-    const family = event === 'analysis.completed' || event === 'analyze.completed' ? 'analysis'
-        : event === 'review-analysis.completed' ? 'review-analysis'
-            : event === 'plan.completed' ? 'plan'
-                : event === 'review-plan.completed' ? 'review-plan'
-                    : event === 'code.completed' ? 'code'
-                        : event === 'review-code.completed' ? 'review-code' : null;
-    if (!family || family !== identity.family)
-        return null;
-    const action = family === 'analysis' ? 'Analyze Task'
-        : family === 'review-analysis' ? 'Review Analysis'
-            : family === 'plan' ? 'Plan Task'
-                : family === 'review-plan' ? 'Review Plan'
-                    : family === 'code' ? 'Code Task' : 'Review Code';
-    const { section, invalidEntries } = inspectActivityLog(taskContent);
-    if (!section || invalidEntries.length > 0)
-        return null;
-    const ordered = section.entries.map((entry, sourceOrder) => ({ entry, sourceOrder }))
-        .sort((left, right) => Date.parse(left.entry.time.replace(' ', 'T')) - Date.parse(right.entry.time.replace(' ', 'T')) || left.sourceOrder - right.sourceOrder);
-    const entries = ordered.map(({ entry }) => entry);
-    const roundPattern = new RegExp(`^${action} \\(Round ${identity.round}(?:, [^)]+)?\\)$`);
-    const row = pairEntries(entries).find((candidate) => candidate.started !== ''
-        && candidate.done !== '' && roundPattern.test(candidate.step)
-        && candidate.note.includes(`→ ${artifact}`));
-    if (!row)
-        return null;
-    const doneIndex = ordered.findIndex(({ entry }) => entry.time === row.done
-        && entry.step === row.step && entry.note === row.note);
-    return doneIndex < 0 ? null : doneIndex;
+    const fact = parseCompletionFacts(parseTypedTaskFrontmatter(taskContent).completion_facts)
+        .find((candidate) => candidate.event === event && candidate.output === artifact);
+    return fact && fact.requestId.length > 0 ? fact : null;
+}
+function validateOutput(taskDir, artifact, fact) {
+    const outputPath = path.join(taskDir, artifact);
+    const stat = fs.lstatSync(outputPath);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        return false;
+    const content = fs.readFileSync(outputPath, 'utf8');
+    return sha256File(outputPath) === fact.outputSha256
+        && canonicalSemanticDigest(content) === fact.semanticDigest;
 }
 //# sourceMappingURL=completion-facts.js.map

package/dist/lib/task/control-authority.js

@@ -1,24 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { isAgentClientId } from '../agent-clients/types.js';
 import { sandboxControlPaths } from '../sandbox/workspace-view.js';
-import { getAgentClientAdapter } from '../agent-clients/registry.js';
-import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle } from './lifecycle.js';
-import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { verifyTaskEvent } from './verification.js';
 import { releaseStaleShortIdRegistry } from './short-id.js';
-export function taskControlOperationKey(operation) {
-    if (operation.family === 'task-finalization')
-        return 'complete';
-    if (operation.family === 'task-lifecycle')
-        return operation.request.intent;
-    return operation.intent === 'route'
-        ? operation.input && operation.input.completed === true ? 'route.clean-completion' : 'route.read'
-        : operation.intent;
-}
 function invalidContext(message) {
     throw new Error(`TASK_CONTROL_CONTEXT_INVALID: ${message}`);
 }
@@ -85,20 +73,6 @@ export function assertTaskControlExecutionContext(context) {
 function boundTaskRef(context, taskRef) {
     return context.source === 'sandbox-executor' ? context.taskId : taskRef;
 }
-function autoTaskOptions(context, options) {
-    if (context.source === 'sandbox-executor')
-        return { ...options, taskId: context.taskId };
-    const resolved = resolveTaskContext(undefined, { repoRoot: context.repoRoot });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return { ...options, taskId: resolved.taskId };
-}
-function domainOptions(context, options) {
-    return {
-        ...options,
-        repoRoot: context.repoRoot
-    };
-}
 function lifecycleTaskId(request, repoRoot) {
     if (request.intent === 'restore')
         return TASK_ID_RE.test(request.taskRef) ? request.taskRef : null;
@@ -114,19 +88,6 @@ async function applyLifecycleWithAuthority(context, request) {
     const taskId = lifecycleTaskId(request, context.repoRoot);
     const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
     const execute = async () => {
-        if (request.intent === 'recover-started') {
-            const adapter = isAgentClientId(request.agent)
-                ? getAgentClientAdapter(request.agent).orchestrationAdapter
-                : undefined;
-            if (!adapter?.recoverStarted) {
-                return {
-                    status: 'no-op', changed: false, targetState: 'active',
-                    requestRef: request.taskRef, intent: 'recover-started', taskId: null,
-                    receiptId: null, childId: null, error: null
-                };
-            }
-            return adapter.recoverStarted(request, { repoRoot: context.repoRoot });
-        }
         return applyTaskLifecycle(request, {
             repoRoot: context.repoRoot,
             ...(controlRoot ? { controlRoot } : {}),
@@ -147,62 +108,6 @@ function controlRootForTask(context, taskId) {
         identity: { mode: 'task-bound', taskId }
     }).root;
 }
-function orchestration(context, operation) {
-    const taskRef = boundTaskRef(context, operation.taskRef);
-    const input = operation.input;
-    const options = domainOptions(context, operation.options);
-    switch (operation.intent) {
-        case 'begin-or-resume':
-            return beginOrResumeOrchestration(taskRef, {
-                ...options,
-                client: input.client,
-                maxSteps: input.maxSteps,
-                modelPolicy: input.modelPolicy
-            });
-        case 'route': return routeOrchestration(taskRef, options);
-        case 'status': return statusOrchestration(taskRef, options);
-        case 'prepare': return prepareTaskOrchestration(context, { ...operation, taskRef }, options);
-        case 'dispatch': return dispatchOrchestrationDelegation(taskRef, options);
-        case 'await-activation':
-            return awaitOrchestrationDelegationActivation(taskRef, input.event, options);
-        case 'recover-prepared': return recoverPreparedOrchestrationDelegation(taskRef, options);
-        case 'hook-start':
-            return input.auto === true
-                ? activateMatchingOrchestrationDelegation(input.client, input.event, autoTaskOptions(context, options))
-                : activateOrchestrationDelegation(taskRef, input.event, options);
-        case 'hook-stop':
-            return input.auto === true
-                ? sealMatchingOrchestrationDelegation(input.client, input.event, autoTaskOptions(context, options))
-                : sealOrchestrationDelegation(taskRef, input.event, undefined, options);
-        case 'advance': return advanceOrchestration(taskRef, options);
-        case 'pause':
-            return pauseOrchestration(taskRef, input.code, input.message, input.recoverable, options);
-    }
-}
-function prepareTaskOrchestration(context, operation, options) {
-    const input = operation.input;
-    const prepareInput = {
-        client: input.client,
-        requestedModel: input.requestedModel,
-        requestedReasoningEffort: input.requestedReasoningEffort,
-    };
-    const prepareDelegation = getAgentClientAdapter(prepareInput.client).orchestrationAdapter?.prepareDelegation;
-    return prepareDelegation
-        ? prepareDelegation(operation.taskRef, prepareInput, {
-            repoRoot: context.repoRoot,
-            orchestrationOptions: options,
-        })
-        : prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
-}
-function orchestrationFailure(error) {
-    if (error instanceof OrchestrationStateError) {
-        return {
-            status: 'failed', changed: false, taskId: error.taskId, run: null, next: null,
-            error: { code: error.code, message: error.message }
-        };
-    }
-    throw error;
-}
 export function dispatchTaskControlOperation(context, operation) {
     assertTaskControlExecutionContext(context);
     assertTaskControlOperation(operation);
@@ -253,13 +158,7 @@ export function dispatchTaskControlOperation(context, operation) {
             }
         });
     }
-    try {
-        const result = orchestration(context, operation);
-        return result instanceof Promise ? result.catch(orchestrationFailure) : result;
-    }
-    catch (error) {
-        return orchestrationFailure(error);
-    }
+    throw new Error('TASK_CONTROL_OPERATION_INVALID: unsupported operation family');
 }
 export function assertTaskControlOperation(operation) {
     if (operation.family === 'task-lifecycle') {
@@ -274,31 +173,20 @@ export function assertTaskControlOperation(operation) {
         }
         return;
     }
-    if (!operation.taskRef || !operation.intent || !operation.input || typeof operation.input !== 'object' || Array.isArray(operation.input)) {
-        throw new Error('TASK_CONTROL_OPERATION_INVALID: orchestration operation is invalid');
-    }
 }
 function operationInvalid(message) {
     throw new Error(`TASK_CONTROL_OPERATION_INVALID: ${message}`);
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--auto', '--dry-run'
+    '--dry-run'
 ]);
 const FINALIZATION_FLAGS = new Set(['--agent']);
-const ORCHESTRATION_FLAGS = new Set([
-    '--agent', '--max-steps', '--executor-model', '--executor-reasoning-effort', '--reviewer-model',
-    '--reviewer-reasoning-effort', '--client', '--requested-model', '--requested-reasoning-effort',
-    '--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'
-]);
 function parseValues(args, start, flags) {
     const values = {};
     for (let index = start; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--dry-run' || flag === '--auto') {
+        if (flag === '--dry-run') {
             if (!flags.has(flag))
                 operationInvalid(`unknown option '${flag}'`);
             if (values[flag] !== undefined)
@@ -321,11 +209,6 @@ function value(values, flag) {
     const current = values[flag];
     return typeof current === 'string' ? current : undefined;
 }
-function required(values, flags) {
-    const missing = flags.find((flag) => value(values, flag) === undefined);
-    if (missing)
-        operationInvalid(`option '${missing}' is required`);
-}
 export function parseTaskControlOperation(family, args) {
     if (family === 'task-finalization') {
         if (args.length !== 4 || args[1] !== 'complete' || args[2] !== '--agent' || !args[0] || !args[3]) {
@@ -341,140 +224,24 @@ export function parseTaskControlOperation(family, args) {
         operationInvalid('task ref and intent are required');
     const taskRef = args[0];
     const intent = args[1];
-    if (family === 'task-lifecycle') {
-        if (intent === 'complete')
-            operationInvalid('complete must use task-finalization');
-        const values = parseValues(args, 2, LIFECYCLE_FLAGS);
-        const agent = normalizeAgentToken(value(values, '--agent') ?? '');
-        if (!agent)
-            operationInvalid('lifecycle agent is invalid');
-        const input = {
-            taskRef,
-            intent,
-            agent,
-            ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
-            ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
-            ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
-            ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
-            ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
-            ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-            ...(values['--auto'] === true ? { auto: true } : {}),
-            ...(values['--dry-run'] === true ? { dryRun: true } : {})
-        };
-        if (intent === 'recover-started') {
-            const recoveryFlags = new Set(['--agent', '--auto']);
-            for (const flag of Object.keys(values)) {
-                if (!recoveryFlags.has(flag))
-                    operationInvalid(`option '${flag}' is not supported for recover-started`);
-            }
-            if (values['--auto'] !== true)
-                operationInvalid('--auto is required for recover-started');
-            return { family, request: input };
-        }
-        else if (values['--auto'] !== undefined) {
-            operationInvalid('--auto is only supported for recover-started');
-        }
-        return { family, request: input };
-    }
-    const values = parseValues(args, 2, ORCHESTRATION_FLAGS);
-    const orchestrationIntents = new Set([
-        'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
-    ]);
-    if (!orchestrationIntents.has(intent)) {
-        operationInvalid(`unknown orchestration intent '${intent}'`);
-    }
-    const client = value(values, '--client');
-    if (client !== undefined && !isAgentClientId(client))
-        operationInvalid(`unknown client '${client}'`);
-    const parsedIntent = intent;
-    const input = {};
-    if (parsedIntent === 'begin-or-resume' || parsedIntent === 'prepare') {
-        required(values, ['--client']);
-        if (!client || !isAgentClientId(client))
-            operationInvalid(`unknown client '${client ?? ''}'`);
-        input.client = client;
-    }
-    if (parsedIntent === 'begin-or-resume') {
-        const maxSteps = value(values, '--max-steps');
-        if (maxSteps !== undefined) {
-            const parsed = Number(maxSteps);
-            if (!Number.isInteger(parsed) || parsed < 1)
-                operationInvalid('--max-steps must be a positive integer');
-            input.maxSteps = parsed;
-        }
-        const policyFlags = ['--executor-model', '--executor-reasoning-effort', '--reviewer-model', '--reviewer-reasoning-effort'];
-        const hasPolicy = policyFlags.some((flag) => value(values, flag) !== undefined);
-        if (hasPolicy && policyFlags.some((flag) => value(values, flag) === undefined)) {
-            operationInvalid('explicit model policy requires executor/reviewer model and reasoning effort');
-        }
-        if (hasPolicy) {
-            input.modelPolicy = {
-                executor: { model: value(values, '--executor-model'), reasoningEffort: value(values, '--executor-reasoning-effort') },
-                reviewer: { model: value(values, '--reviewer-model'), reasoningEffort: value(values, '--reviewer-reasoning-effort') }
-            };
-        }
-    }
-    if (parsedIntent === 'prepare') {
-        input.requestedModel = value(values, '--requested-model');
-        input.requestedReasoningEffort = value(values, '--requested-reasoning-effort');
-    }
-    if (parsedIntent === 'await-activation') {
-        required(values, ['--stage', '--round', '--artifact', '--role']);
-        const round = Number(value(values, '--round'));
-        if (!Number.isSafeInteger(round) || round < 1)
-            operationInvalid('--round must be a positive integer');
-        const role = value(values, '--role');
-        if (role !== 'executor' && role !== 'reviewer')
-            operationInvalid('--role must be executor or reviewer');
-        input.event = { stage: value(values, '--stage'), round, artifact: value(values, '--artifact'), role };
-    }
-    if (parsedIntent === 'hook-start') {
-        required(values, ['--native-agent', '--child-id', '--parent-id']);
-        if (taskRef === 'auto')
-            required(values, ['--client']);
-        input.auto = taskRef === 'auto';
-        input.client = value(values, '--client');
-        input.event = {
-            nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), parentId: value(values, '--parent-id'),
-            spawnMode: value(values, '--spawn-mode'), actualModel: value(values, '--actual-model'),
-            actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-            reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-        };
-    }
-    if (parsedIntent === 'hook-stop') {
-        input.auto = taskRef === 'auto';
-        if (input.auto) {
-            required(values, ['--client', '--native-agent', '--child-id']);
-            input.client = value(values, '--client');
-            input.event = {
-                nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), actualModel: value(values, '--actual-model'),
-                actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-                reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-            };
-        }
-        else {
-            required(values, ['--child-id', '--exit-code', '--after-fingerprint']);
-            const exitCode = Number(value(values, '--exit-code'));
-            if (!Number.isInteger(exitCode))
-                operationInvalid('--exit-code must be an integer');
-            input.event = {
-                childId: value(values, '--child-id'), exitCode, afterFingerprint: value(values, '--after-fingerprint'),
-                changedPaths: value(values, '--changed-paths')?.split(',').filter(Boolean) ?? [], actualModel: value(values, '--actual-model'),
-                actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-                reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-            };
-        }
-    }
-    if (parsedIntent === 'pause') {
-        required(values, ['--code', '--message', '--recoverable']);
-        const recoverable = value(values, '--recoverable');
-        if (recoverable !== 'true' && recoverable !== 'false')
-            operationInvalid('--recoverable must be true or false');
-        input.code = value(values, '--code');
-        input.message = value(values, '--message');
-        input.recoverable = recoverable === 'true';
-    }
-    return { family, taskRef, intent: parsedIntent, input };
+    if (intent === 'complete')
+        operationInvalid('complete must use task-finalization');
+    const values = parseValues(args, 2, LIFECYCLE_FLAGS);
+    const agent = normalizeAgentToken(value(values, '--agent') ?? '');
+    if (!agent)
+        operationInvalid('lifecycle agent is invalid');
+    const request = {
+        taskRef,
+        intent,
+        agent,
+        ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
+        ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
+        ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
+        ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
+        ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
+        ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
+        ...(values['--dry-run'] === true ? { dryRun: true } : {})
+    };
+    return { family, request: request };
 }
 //# sourceMappingURL=control-authority.js.map

package/dist/lib/task/control-recovery.js

@@ -16,7 +16,7 @@ export function parseControlOutput(output) {
 export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
-const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
+const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore'];
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS = Object.freeze([
     ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle', intent, class: 'lifecycle-mutation' })),
     { family: 'task-create', intent: 'create', class: 'task-create' }
@@ -33,13 +33,11 @@ function bindingMatchesResult(binding, result) {
         && (result.taskId === undefined || result.taskId === binding.taskId)
         && (result.intentDigest === undefined || result.intentDigest === binding.intentDigest);
 }
-function domainEvidenceMatches(operation, result, domain) {
+function domainEvidenceMatches(domain) {
     if (!domain)
         return false;
     if (domain.consistent !== true)
         return false;
-    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started')
-        return false;
     return true;
 }
 export function classifySandboxControlRecovery(input) {
@@ -71,7 +69,7 @@ export function classifySandboxControlRecovery(input) {
     if (result.changed === null) {
         return { outcome: 'unknown', responseReconstructable: false, reasonCode: 'RECOVERY_RESULT_CHANGE_FLAG_MISSING' };
     }
-    if (!domainEvidenceMatches(input.operation, result, input.domain)) {
+    if (!domainEvidenceMatches(input.domain)) {
         if (input.journal?.exists && (input.journal.completedSteps?.length ?? 0) > 0) {
             return { outcome: 'in-progress', responseReconstructable: false, reasonCode: 'RECOVERY_DOMAIN_EVIDENCE_INCOMPLETE' };
         }