@fitlab-ai/agent-infra 0.11.10 → 0.11.11

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

@@ -274,7 +274,6 @@ export function createSandboxExecutorExecutionContext(params) {
         generation: params.generation,
         manifestPath: absolute('manifestPath', params.manifestPath),
         requestId: params.requestId,
-        handoffDirectory: absolute('handoffDirectory', params.handoffDirectory ?? path.join(params.worktreeRoot, '.agent-infra-handoff')),
         ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
         ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
             lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -302,7 +301,6 @@ export function assertTaskControlExecutionContext(context) {
     absolute('worktreeRoot', context.worktreeRoot);
     absolute('runtimeDir', context.runtimeDir);
     absolute('manifestPath', context.manifestPath);
-    absolute('handoffDirectory', context.handoffDirectory);
     if (path.resolve(context.runtimeDir) !== path.join(path.dirname(path.resolve(context.manifestPath)), 'runtime')) {
         invalidContext('runtimeDir is not bound to the manifest control root');
     }

package/dist/lib/task/events.js

@@ -113,7 +113,7 @@ function validateTaskEventRequest(request) {
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'initiator is invalid' };
     if (request.requestId !== undefined && (!request.requestId.trim() || /[\r\n]/.test(request.requestId)))
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'requestId must be a non-empty single line' };
-    if (request.reasonCode && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'].includes(request.reasonCode))
+    if (request.reasonCode && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'manual-review-supplement', 'retry', 'validation-rerun'].includes(request.reasonCode))
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'reasonCode is invalid' };
     for (const [name, value] of [['sourceFinding', request.sourceFinding], ['sourceArtifact', request.sourceArtifact], ['sourceSha256', request.sourceSha256]]) {
         if (value !== undefined && (!value.trim() || /[\r\n]/.test(value)))

package/dist/lib/task/finalization.js

@@ -10,22 +10,45 @@ import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { recoverPlatformOperations } from './platform-operation-recovery.js';
 import { applyTaskLifecycle, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
-import { resolveTaskRef } from './resolve-ref.js';
+import { enumerateAllTaskDirs, resolveTaskRef } from './resolve-ref.js';
 import { inspectShortIdRegistry } from './short-id.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-import { readTaskFinalizationHandoff } from './finalization-handoff.js';
 import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { validateSandboxControlIdentity } from '../sandbox/control/identity-sentinel.js';
 const RECEIPT_VERSION = 4;
 const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'];
-function finalizationRoot(repoRoot) {
-    return path.join(repoRoot, '.agents', 'workspace', '.task-finalization');
+export function resolveTaskFinalizationDirectory(repoRoot, taskId) {
+    const tasks = enumerateAllTaskDirs(repoRoot).filter((task) => task.taskId === taskId);
+    if (tasks.length === 0)
+        return null;
+    if (tasks.length !== 1)
+        throw new Error(`FINALIZATION_TASK_IDENTITY_AMBIGUOUS: ${taskId}`);
+    const task = tasks[0];
+    let canonicalDir;
+    try {
+        canonicalDir = fs.realpathSync.native(task.taskDir);
+    }
+    catch (error) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_UNAVAILABLE: ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let frontmatter;
+    try {
+        frontmatter = parseTaskFrontmatter(fs.readFileSync(path.join(canonicalDir, 'task.md'), 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_INVALID: ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (task.taskId !== taskId || frontmatter.id !== taskId) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_INVALID: task directory and task.md must identify ${taskId}`);
+    }
+    return canonicalDir;
 }
 function receiptPath(repoRoot, taskId) {
-    return path.join(finalizationRoot(repoRoot), `${taskId}.json`);
+    const taskDir = resolveTaskFinalizationDirectory(repoRoot, taskId);
+    return taskDir ? path.join(taskDir, '.task-finalization.json') : null;
 }
 function now() {
     return new Date().toISOString();
@@ -89,7 +112,7 @@ function validWarning(value) {
         && (warning.status === 'open' || warning.status === 'resolved')
         && (warning.resolvedAt === null || typeof warning.resolvedAt === 'string');
 }
-function validateReceipt(value, taskId) {
+export function validateTaskFinalizationReceipt(value, taskId) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('receipt must be an object');
     const receipt = value;
@@ -128,18 +151,18 @@ function validateReceipt(value, taskId) {
 }
 function readReceipt(repoRoot, taskId) {
     const file = receiptPath(repoRoot, taskId);
-    if (!fs.existsSync(file))
+    if (!file || !fs.existsSync(file))
         return null;
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return validateReceipt(value, taskId);
+    return validateTaskFinalizationReceipt(value, taskId);
 }
 function readTaskFinalizationReceipt(repoRoot, taskId) {
     return readReceipt(path.resolve(repoRoot), taskId);
 }
 function writeReceipt(repoRoot, receipt) {
-    const directory = finalizationRoot(repoRoot);
-    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     const target = receiptPath(repoRoot, receipt.taskId);
+    if (!target)
+        throw new Error(`TASK_FINALIZATION_TASK_NOT_FOUND: ${receipt.taskId}`);
     const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
     try {
         fs.writeFileSync(temporary, `${JSON.stringify(receipt)}\n`, { mode: 0o600, flag: 'wx' });
@@ -670,7 +693,7 @@ async function prepareUnderLock(request, taskId, options) {
     let receipt;
     try {
         const file = receiptPath(repoRoot, taskId);
-        const existed = fs.existsSync(file);
+        const existed = file !== null && fs.existsSync(file);
         receipt = readReceipt(repoRoot, taskId) ?? emptyReceipt(taskId, options.controlBinding);
         if (!existed)
             writeReceipt(repoRoot, receipt);
@@ -969,34 +992,13 @@ async function commitPreparedTaskFinalization(request, options) {
                 }
             }
             let receipt = readReceipt(repoRoot, resolved.taskId);
-            let importedHandoff = false;
-            if (!receipt && options.controlBinding && options.handoffDirectory && request.handoffSha256) {
-                try {
-                    const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
-                    receipt = validateReceipt(handoff.receipt, resolved.taskId);
-                    if (receipt.lifecycle !== 'pending')
-                        throw new Error('handoff lifecycle must be pending');
-                    if (inspectTaskLifecycleProgress(repoRoot, resolved.taskId, request.agent) === 'unknown') {
-                        throw new Error('TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE');
-                    }
-                    writeReceipt(repoRoot, receipt);
-                    importedHandoff = true;
-                    try {
-                        handoff.cleanup();
-                    }
-                    catch { /* keep the persisted canonical receipt usable */ }
-                }
-                catch (error) {
-                    return failed(resolved.taskId, {
-                        code: 'TASK_FINALIZATION_HANDOFF_INVALID',
-                        message: error instanceof Error ? error.message : String(error), retryable: false
-                    });
-                }
-            }
             if (!receipt)
                 return failed(resolved.taskId, {
                     code: 'TASK_FINALIZATION_PREPARATION_REQUIRED', message: 'sandbox preparation receipt is unavailable', retryable: true
                 });
+            if (options.controlBinding && !receipt.controlBinding) {
+                receipt = updateReceipt(repoRoot, receipt, { controlBinding: options.controlBinding });
+            }
             if (receipt.lifecycle === 'done' && receipt.verification !== 'pending' && resolved.state === 'completed') {
                 return terminalResult(resolved.taskId, receipt, { lifecycle: { status: 'no-op', changed: false, error: null } }, false);
             }
@@ -1008,25 +1010,6 @@ async function commitPreparedTaskFinalization(request, options) {
                         message: 'task lifecycle progress cannot be verified', retryable: false
                     });
                 }
-                if (!importedHandoff && options.handoffDirectory && request.handoffSha256) {
-                    try {
-                        const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
-                        const nextReceipt = validateReceipt(handoff.receipt, resolved.taskId);
-                        if (nextReceipt.receiptId !== receipt.receiptId || nextReceipt.intent !== receipt.intent
-                            || nextReceipt.lifecycle !== receipt.lifecycle)
-                            throw new Error('handoff is not continuous with canonical receipt');
-                        try {
-                            handoff.cleanup();
-                        }
-                        catch { /* keep the persisted canonical receipt usable */ }
-                    }
-                    catch (error) {
-                        return failed(resolved.taskId, {
-                            code: 'TASK_FINALIZATION_HANDOFF_INVALID',
-                            message: error instanceof Error ? error.message : String(error), retryable: false
-                        });
-                    }
-                }
             }
             if (receipt.taskComment === 'pending' || receipt.summary === 'pending' || receipt.warningProjection === 'pending') {
                 return failed(resolved.taskId, {

package/dist/lib/task/frontmatter.js

@@ -53,6 +53,29 @@ function serializeScalar(value) {
     }
     return serialized;
 }
+function stripInlineComment(value) {
+    const first = value.search(/\S/u);
+    let activeQuote = first >= 0 && (value[first] === '"' || value[first] === "'") ? value[first] : null;
+    for (let index = activeQuote ? first + 1 : Math.max(first, 0); index < value.length; index += 1) {
+        const character = value[index];
+        if (activeQuote === '"' && character === '\\') {
+            index += 1;
+            continue;
+        }
+        if (activeQuote && character === activeQuote) {
+            if (activeQuote === "'" && value[index + 1] === "'") {
+                index += 1;
+                continue;
+            }
+            activeQuote = null;
+            continue;
+        }
+        if (!activeQuote && character === '#' && (index === 0 || /\s/u.test(value[index - 1]))) {
+            return value.slice(0, index).trimEnd();
+        }
+    }
+    return value;
+}
 function parseTaskFrontmatter(content) {
     const result = {};
     if (!content.startsWith('---'))
@@ -69,7 +92,7 @@ function parseTaskFrontmatter(content) {
         if (colon === -1)
             continue;
         const key = line.slice(0, colon).trim();
-        const value = line.slice(colon + 1).trim();
+        const value = stripInlineComment(line.slice(colon + 1).trim());
         if (key)
             result[key] = value;
     }

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

@@ -336,7 +336,8 @@ function applyLedgerIntent(intent, options = {}) {
                         ? new Set(['confirmed', 'open', 'needs-human-decision'])
                         : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
                 const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
-                if (!sameRoundMinorClose && !allowed.has(intent.status)) {
+                const refreshOpenEvidence = before.status === 'open' && intent.status === 'open';
+                if (!sameRoundMinorClose && !refreshOpenEvidence && !allowed.has(intent.status)) {
                     return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
                 }
                 after = { ...before, status: intent.status, evidence };

package/dist/lib/task/platform-operation-journal.js

@@ -69,6 +69,18 @@ function parseJournal(file, taskId) {
                 ? !item.pullRequestSummary || typeof item.pullRequestSummary.body !== 'string'
                     || !item.pullRequestSummary.body.trim() || typeof item.pullRequestSummary.changeReportFile !== 'string'
                     || !item.pullRequestSummary.changeReportFile.trim()
+                    || (item.pullRequestSummary.manualValidation !== undefined && (!item.pullRequestSummary.manualValidation
+                        || typeof item.pullRequestSummary.manualValidation !== 'object'
+                        || Array.isArray(item.pullRequestSummary.manualValidation)
+                        || !['pending', 'final'].includes(item.pullRequestSummary.manualValidation.phase)
+                        || typeof item.pullRequestSummary.manualValidation.transactionId !== 'string'
+                        || !item.pullRequestSummary.manualValidation.transactionId.trim()
+                        || (item.pullRequestSummary.manualValidation.receiptDigest !== undefined && !/^[a-f0-9]{64}$/u.test(item.pullRequestSummary.manualValidation.receiptDigest))
+                        || (item.pullRequestSummary.manualValidation.prHeadSha !== undefined && !/^[a-f0-9]{40}$/u.test(item.pullRequestSummary.manualValidation.prHeadSha))
+                        || (item.pullRequestSummary.manualValidation.authority !== undefined && item.pullRequestSummary.manualValidation.authority !== 'coordinator')
+                        || (item.pullRequestSummary.manualValidation.phase === 'final' && (!/^[a-f0-9]{64}$/u.test(item.pullRequestSummary.manualValidation.receiptDigest ?? '')
+                            || !/^[a-f0-9]{40}$/u.test(item.pullRequestSummary.manualValidation.prHeadSha ?? '')
+                            || item.pullRequestSummary.manualValidation.authority !== 'coordinator'))))
                 : item.pullRequestSummary !== undefined)
             || (item.kind === 'pull-request-review'
                 ? !item.pullRequestReview || typeof item.pullRequestReview.prNumber !== 'string'

package/dist/lib/task/platform-operation-recovery.js

@@ -193,6 +193,16 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
     catch {
         return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Queued pull-request summary identity is invalid', retryable: false } });
     }
+    const summary = operation.pullRequestSummary;
+    if (!summary)
+        return platformResult('blocked', { error: {
+                code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
+            } });
+    const manualValidationHeading = /^###\s+(?:⏳\s+(?:Manual Validation Pending|人工验证待收尾)|✅\s+(?:Manual Validation Passed|人工验证已通过))\s*$/mu.test(summary.body);
+    if (manualValidationHeading && !summary.manualValidation)
+        return platformResult('blocked', { error: {
+                code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'Queued manual-validation summary has no persisted transaction context', retryable: false
+            } });
     const resolved = await resolvePlatformProviderContext({ cwd, client });
     if (!resolved.ok)
         return resolved.context;
@@ -207,13 +217,9 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         return platformResult('blocked', { error: {
                 code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple pull-request comments contain the queued summary marker', retryable: false
             } });
-    if (summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
+    if (!summary.manualValidation && summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
         return platformResult('no-op');
     }
-    if (!operation.pullRequestSummary)
-        return platformResult('blocked', { error: {
-                code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
-            } });
     const bound = await inspectPlatformPullRequest(taskId, { cwd, client });
     if (!bound.pullRequest || !resourceIdentityEquals(bound.pullRequest.identity, identity))
         return platformResult('blocked', { error: bound.error ?? {
@@ -223,8 +229,9 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         agent,
         cwd,
         client,
-        body: operation.pullRequestSummary.body,
-        changeReportFile: operation.pullRequestSummary.changeReportFile,
+        body: summary.body,
+        changeReportFile: summary.changeReportFile,
+        ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
         primaryResult: 'no_op',
         strict: true,
         skipQueue: true,

package/dist/lib/task/resolve-ref.js

@@ -98,16 +98,21 @@ function enumerateTaskDirs(repoRoot) {
  */
 function enumerateAllTaskDirs(repoRoot) {
     const out = [];
-    const seen = new Set();
+    const seen = new Map();
     const add = (taskId, taskDir, state) => {
         if (!TASK_ID_RE.test(taskId))
             return;
         const stat = fs.lstatSync(taskDir);
         if (!stat.isDirectory() || stat.isSymbolicLink() || !fs.existsSync(path.join(taskDir, 'task.md')))
             return;
-        if (seen.has(taskId))
+        const canonicalDir = fs.realpathSync.native(taskDir);
+        const previousDir = seen.get(taskId);
+        if (previousDir !== undefined) {
+            if (previousDir === canonicalDir)
+                return;
             throw new Error(`duplicate task identity: ${taskId}`);
-        seen.add(taskId);
+        }
+        seen.set(taskId, canonicalDir);
         out.push({ taskId, taskDir, state });
     };
     for (const state of FLAT_WORKSPACE_DIRS) {

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.10",
-  "sourceInputHash": "3500e8eb7fac8bbad3d95124002f8042af3d160185a5b635eb9b4d8f88a991cb",
-  "internalExecutableBuildHash": "51a4c472b6a54b3ca3c28ab049683175d3ea4730fe560868f853cd603b5a98f1"
+  "packageVersion": "0.11.11",
+  "sourceInputHash": "576098e3f88ceca11a0a0f94573a3ceca2b14c97b29a6b934ae07849e214c889",
+  "internalExecutableBuildHash": "065375c31d3564a65236fc43bad9947395ea0873ae2531d9b05f42956ef30f1e"
 }

package/lib/agent-clients/adapter.ts

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import {
   AGENT_CLIENT_CAPABILITY_IDS,
   AGENT_CLIENT_SUPPORT_LEVELS,
@@ -216,6 +217,26 @@ function freezeTool(tool: SandboxTool): SandboxTool {
   if (!tool.containerMount.startsWith('/')) {
     throw new Error(`Sandbox tool '${tool.id}' containerMount must be absolute`);
   }
+  if (tool.hostStateMounts !== undefined && !Array.isArray(tool.hostStateMounts)) {
+    throw new Error(`Agent Client '${tool.id}' hostStateMounts must be an array`);
+  }
+  const hostStateMounts = tool.hostStateMounts?.map((entry) => {
+    if (!entry || typeof entry.hostSubdir !== 'string' || typeof entry.containerSubpath !== 'string') {
+      throw new Error(`Agent Client '${tool.id}' hostStateMounts must contain relative path pairs`);
+    }
+    for (const value of [entry.hostSubdir, entry.containerSubpath]) {
+      const normalized = path.posix.normalize(value);
+      if (
+        value === ''
+        || path.posix.isAbsolute(value)
+        || normalized === '..'
+        || normalized.startsWith('../')
+      ) {
+        throw new Error(`Agent Client '${tool.id}' hostStateMounts must stay within the tool directories`);
+      }
+    }
+    return Object.freeze({ ...entry });
+  });
   if (!tool.versionCmd) {
     throw new Error(`Sandbox tool '${tool.id}' requires versionCmd`);
   }
@@ -233,6 +254,7 @@ function freezeTool(tool: SandboxTool): SandboxTool {
     ...(tool.hostLiveMounts ? {
       hostLiveMounts: Object.freeze(tool.hostLiveMounts.map((entry) => Object.freeze({ ...entry })))
     } : {}),
+    ...(hostStateMounts ? { hostStateMounts: Object.freeze(hostStateMounts) } : {}),
     ...(tool.postSetupCmds ? { postSetupCmds: Object.freeze([...tool.postSetupCmds]) } : {}),
     ...(tool.tmpfs ? {
       tmpfs: Object.freeze({

package/lib/agent-clients/adapters/codex-sandbox.ts

@@ -285,6 +285,19 @@ const codexRecoveryChecks: readonly AgentClientSandboxRecoveryCheck[] = [
       path: '/home/devuser/.codex'
     }
   },
+  {
+    id: 'app-server-package-writable',
+    probe: {
+      script: 'probe="$1/.agent-infra-app-server-package-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
+      args: ['/home/devuser/.codex/packages/app-server-daemon'],
+      user: 'devuser'
+    },
+    finding: {
+      repairKind: 'hard-failure',
+      message: 'Codex app-server package directory is not writable by devuser.',
+      path: '/home/devuser/.codex/packages/app-server-daemon'
+    }
+  },
   {
     id: 'prompts-link',
     when: {

package/lib/agent-clients/adapters/codex.ts

@@ -55,6 +55,10 @@ const codexAdapter = defineAgentClientAdapter({
       versionCmd: 'codex --version',
       setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
       tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'], exec: true },
+      hostStateMounts: [{
+        hostSubdir: 'packages/app-server-daemon',
+        containerSubpath: 'packages/app-server-daemon'
+      }],
       hostLiveMounts: [
         {
           hostPath: hostJoin(home, '.codex', 'auth.json'),

package/lib/internal/manual-validation.ts

@@ -206,7 +206,7 @@ async function executeManualValidationTransactionLocked(
     if (transaction.phase === 'prepared') {
       const staged = await syncPullRequestSummary(taskRef, {
         cwd, client: options.client, agent, body: pendingBody, changeReportFile: path.resolve(cwd, values.changeReportFile!), primaryResult: primaryResult as 'pr_created' | 'pr_reused' | 'no_op', strict: true,
-        manualValidation: { phase: 'pending' }, lockAlreadyHeld: true
+        manualValidation: { phase: 'pending', transactionId: transaction.transactionId }, lockAlreadyHeld: true
       });
       if (!['applied', 'no-op'].includes(staged.status)) transactionFailure(staged.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'pending summary staging failed' });
       transitionAndPersist('summary-staged');
@@ -264,7 +264,7 @@ async function executeManualValidationTransactionLocked(
       try {
         await syncPullRequestSummary(taskRef, {
           cwd, client: options.client, agent, body: pendingBody, changeReportFile: path.resolve(cwd, values.changeReportFile!), primaryResult: primaryResult as 'pr_created' | 'pr_reused' | 'no_op', strict: true,
-          manualValidation: { phase: 'pending' }, lockAlreadyHeld: true
+          manualValidation: { phase: 'pending', transactionId: transaction.transactionId }, lockAlreadyHeld: true
         });
       } catch {
         // Preserve recovery-required when pending compensation cannot be confirmed.

package/lib/internal/platform-pr.ts

@@ -22,7 +22,7 @@ const USAGE = `Usage: agent-infra-internal platform-pr inspect <task-ref> [--cwd
        agent-infra-internal platform-pr bind <task-ref> --pr <token> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr skip <task-ref> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr sync <task-ref> --agent <agent> [--metadata] [--closing-issue] --result <pr_created|pr_reused|no_op> [--dry-run] [--cwd <path>]
-       agent-infra-internal platform-pr sync-in-labels --pr <N> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr sync-in-labels --pr <token> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr summary-context <task-ref> [--cwd <path>]
        agent-infra-internal platform-pr change-report <task-ref> --agent <agent> --mechanical-file <path> --precheck-file <path> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr summary-sync <task-ref> --agent <agent> --body-file <path|-> --change-report-file <path> --result <pr_created|pr_reused|no_op> [--manual-phase pending|final ...] [--strict] [--dry-run] [--cwd <path>]
@@ -89,10 +89,9 @@ async function platformPr(args: string[] = []): Promise<void> {
     const values = parsed.values;
     const unexpected = Object.keys(values).find((name) => !['cwd', 'pr', 'dryRun'].includes(name));
     if (unexpected) { fail(`sync-in-labels does not accept --${unexpected}`); return; }
-    const pr = Number(values.pr);
-    if (!Number.isInteger(pr) || pr <= 0) { fail('sync-in-labels requires a positive --pr'); return; }
+    if (typeof values.pr !== 'string' || !values.pr || values.pr.trim() !== values.pr) { fail('sync-in-labels requires a non-empty --pr token'); return; }
     const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
-    finish(await syncPlatformPullRequestInLabels(pr, { cwd, dryRun: values.dryRun === true }));
+    finish(await syncPlatformPullRequestInLabels(values.pr, { cwd, dryRun: values.dryRun === true }));
     return;
   }
   const taskRef = args[1];

package/lib/internal/task-artifact.ts

@@ -1,7 +1,7 @@
 import { parseArtifactCommand, executeArtifactCommand } from '../task/artifact-command.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family> [--source-finding <id> --source-artifact <name> --source-sha256 <digest>]\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> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize workflow artifact facts.\n`;
+const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family> [--reason-code <reason>] [--source-finding <id> --source-artifact <name> --source-sha256 <digest>]\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> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize workflow artifact facts.\n`;
 
 
 function taskArtifact(args: string[] = []): void {

package/lib/internal/task-create.ts

@@ -7,7 +7,7 @@ import {
   SandboxControlClientError
 } from '../sandbox/control/client.ts';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.ts';
-import { validateTaskCreateCandidate } from '../task/create.ts';
+import { validateTaskCreateCandidate, type TaskCreateCandidateV1 } from '../task/create.ts';
 import {
   createTask,
   parseTaskCreateResult,
@@ -82,7 +82,20 @@ async function taskCreate(args: string[]): Promise<void> {
     const stat = fs.lstatSync(inputPath);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('TASK_CREATE_INPUT_INVALID: input must be a regular file');
     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')));
+    const inputContent = fs.readFileSync(inputPath, 'utf8');
+    let candidate: TaskCreateCandidateV1;
+    try {
+      candidate = validateTaskCreateCandidate(JSON.parse(inputContent));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_INPUT_INVALID';
+      output(failed(code, message, false, {
+        requestId: null,
+        accepted: false,
+        recovery: 'new-request-id'
+      }));
+      return;
+    }
     const environment = resolveSandboxControlTransport();
     if (environment.kind === 'fail-closed') {
       output(failed(environment.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID', 'sandbox client control configuration is invalid'));

package/lib/internal/task-finalization.ts

@@ -80,9 +80,7 @@ async function taskFinalization(args: string[] = []): Promise<void> {
   const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
   if (transport.kind === 'sandbox-local') {
     try {
-      const response = requestSandboxTaskFinalization({
-        agent: boundOperation.request.agent
-      });
+      const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
       process.stdout.write(response.stdout);
       process.stderr.write(response.stderr);
       process.exitCode = response.exitCode ?? 1;