@fitlab-ai/agent-infra 0.9.11 → 0.9.12

package/README.md

@@ -71,11 +71,11 @@ Just fix it at the application layer in LoginService.
 > AI re-runs `/plan-task` to update the plan accordingly and confirms.
 
 ```bash
-/code-task <task-id>       # AI writes the fix, adds a test for user+tag@example.com — green
+/code-task <task-id>       # AI writes the fix, tests it, and creates a local checkpoint commit
 /review-code <task-id>     # A fresh isolated reviewer reports one minor finding
-/code-task <task-id>       # AI fixes the minor issue and re-validates
-/commit
-/create-pr <task-id>       # PR opened, auto-linked to issue #42
+/code-task <task-id>       # AI fixes the minor issue, re-validates, and creates a new checkpoint
+/review-code <task-id>     # The reviewer approves the current checkpoint
+/create-pr <task-id>       # The reviewed branch is published to its task-bound target; PR links issue #42
 /complete-task <task-id>   # task archived
 ```
 
@@ -189,8 +189,8 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 | `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; Codex now has an experimental Hooks + App Server evidence channel, but orchestration remains disabled until that channel is connected to delegation receipts |
 | `analyze-task` → `review-analysis` | Capture scope and risks, then review the analysis |
 | `plan-task` → `review-plan` | Design the approach, then review the plan |
-| `code-task` → `review-code` | Implement and test, then run a structured code review |
-| `commit` → `create-pr` → `complete-task` | Commit, open a PR, and archive the task |
+| `code-task` → `review-code` | Implement and test; `code-task` creates a local checkpoint, then a structured review checks that checkpoint |
+| `create-pr` → `complete-task` | Publish the approved checkpoint to the task-bound target branch, then archive after merge and final gates |
 
 Start with one atomic role policy, for example: `$run-task 42 --executor-model <id> --executor-reasoning-effort <value> --reviewer-model <id> --reviewer-reasoning-effort <value>`. Both roles may use the same model. With no explicit policy, `run-task` reads the current Agent Client's optional `agentClients[].orchestration`; if neither source is complete, it shows the host model-selection guidance before creating any run. Re-entry uses the persisted run policy. Finish or clear active runs before upgrading agent-infra; unsupported disk state fails closed without rewriting.
 

package/README.zh-CN.md

@@ -70,11 +70,11 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 > AI 按你的要求重跑 `/plan-task` 更新方案并确认。
 
 ```bash
-/code-task <task-id>       # AI 编写修复代码，添加 user+tag@example.com 测试 —— 通过
+/code-task <task-id>       # AI 编写修复代码、测试，并创建本地 checkpoint commit
 /review-code <task-id>     # fresh 隔离 reviewer 报告一个次要问题
-/code-task <task-id>       # AI 修复次要问题并重新验证
-/commit
-/create-pr <task-id>       # PR 已创建，自动关联 Issue #42
+/code-task <task-id>       # AI 修复次要问题、重新验证，并创建新的 checkpoint
+/review-code <task-id>     # reviewer 审查并通过当前 checkpoint
+/create-pr <task-id>       # 将已审查分支发布到任务绑定目标分支；PR 自动关联 Issue #42
 /complete-task <task-id>   # 任务归档
 ```
 
@@ -188,8 +188,8 @@ ai agent-client configure
 | `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
 | `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
 | `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
-| `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |
-| `commit` → `create-pr` → `complete-task` | 提交、创建 PR、归档任务 |
+| `code-task` → `review-code` | 实现并测试；`code-task` 创建本地 checkpoint，再由结构化审查检视该 checkpoint |
+| `create-pr` → `complete-task` | 将已通过审查的 checkpoint 发布到任务绑定目标分支，并在合并和最终门禁通过后归档 |
 
 启动时可提供原子角色策略，例如：`$run-task 42 --executor-model <id> --executor-reasoning-effort <值> --reviewer-model <id> --reviewer-reasoning-effort <值>`。两个角色可以使用同一模型。完全没有显式策略时，`run-task` 读取当前 Agent Client 可选的 `agentClients[].orchestration`；两个来源都不完整时，会在创建任何 run 前展示宿主模型选择指引。重入使用已持久化的 run 策略。升级 agent-infra 前必须完成或清空 active run；不受支持的磁盘状态会失败关闭且不改写。
 

package/dist/bin/internal-cli.js

@@ -88,6 +88,11 @@ else
             gitWorkflow(process.argv.slice(3));
             break;
         }
+        case 'task-delivery': {
+            const { taskDelivery } = await import('../lib/internal/task-delivery.js');
+            taskDelivery(process.argv.slice(3));
+            break;
+        }
         case 'release-workflow': {
             const { releaseWorkflow } = await import('../lib/internal/release-workflow.js');
             await releaseWorkflow(process.argv.slice(3));

package/dist/lib/agent-clients/adapters/codex-lifecycle/build-identity.js

@@ -16,20 +16,63 @@ function isLifecycleProtocolVersion(value) {
 function normalizeRelativePath(value) {
     return value.replaceAll('\\', '/');
 }
+function isSafeLifecyclePath(value) {
+    return exactText(value)
+        && value === normalizeRelativePath(value)
+        && !path.isAbsolute(value)
+        && !/^[A-Za-z]:[\\/]/u.test(value)
+        && !value.split('/').includes('..');
+}
+function isLifecycleLauncherLine(value) {
+    return typeof value === 'string'
+        && value.length > 1
+        && value.slice(0, -1).trim() === value.slice(0, -1)
+        && value.startsWith('#!')
+        && value.endsWith('\n')
+        && value.indexOf('\n') === value.length - 1
+        && !value.includes('\r');
+}
+function readLifecycleLauncherShebang(value, executableFiles) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+    }
+    const policy = value;
+    if (!isSafeLifecyclePath(policy.sourceFile)
+        || !isSafeLifecyclePath(policy.compiledFile)
+        || !isLifecycleLauncherLine(policy.canonicalLine)
+        || !Array.isArray(policy.acceptedLines)
+        || !policy.acceptedLines.every(isLifecycleLauncherLine)
+        || new Set(policy.acceptedLines).size !== policy.acceptedLines.length
+        || !policy.acceptedLines.includes(policy.canonicalLine)
+        || !executableFiles.includes(policy.sourceFile)
+        || policy.compiledFile !== normalizeRelativePath(path.join('dist', policy.sourceFile.endsWith('.ts')
+            ? policy.sourceFile.replace(/\.ts$/u, '.js')
+            : policy.sourceFile))) {
+        throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+    }
+    return Object.freeze({
+        sourceFile: policy.sourceFile,
+        compiledFile: policy.compiledFile,
+        canonicalLine: policy.canonicalLine,
+        acceptedLines: Object.freeze([...policy.acceptedLines])
+    });
+}
 function readLifecycleManifestFiles(packageRoot) {
     const file = path.join(packageRoot, 'lib', 'agent-clients', 'adapters', 'codex-lifecycle', 'manifest-files.json');
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (!Array.isArray(value.executableFiles)
         || !Array.isArray(value.contractFiles)
-        || !value.executableFiles.every(exactText)
-        || !value.contractFiles.every(exactText)
+        || !value.executableFiles.every(isSafeLifecyclePath)
+        || !value.contractFiles.every(isSafeLifecyclePath)
         || new Set(value.executableFiles).size !== value.executableFiles.length
         || new Set(value.contractFiles).size !== value.contractFiles.length) {
         throw new Error('Lifecycle manifest file list is invalid');
     }
+    const executableFiles = Object.freeze([...value.executableFiles]);
     return Object.freeze({
-        executableFiles: Object.freeze([...value.executableFiles]),
-        contractFiles: Object.freeze([...value.contractFiles])
+        executableFiles,
+        contractFiles: Object.freeze([...value.contractFiles]),
+        launcherShebang: readLifecycleLauncherShebang(value.launcherShebang, executableFiles)
     });
 }
 function executablePackageRoot() {
@@ -47,7 +90,22 @@ function executablePackageRoot() {
         current = parent;
     }
 }
-function hashFiles(root, files) {
+function normalizeLifecycleLauncherBytes(relative, content, policy) {
+    const normalized = normalizeRelativePath(relative);
+    if (normalized !== policy.sourceFile && normalized !== policy.compiledFile)
+        return content;
+    const lineEnd = content.indexOf(0x0a);
+    if (lineEnd < 0)
+        return content;
+    const firstLine = content.subarray(0, lineEnd + 1);
+    if (!policy.acceptedLines.some((line) => Buffer.from(line).equals(firstLine)))
+        return content;
+    return Buffer.concat([
+        Buffer.from(policy.canonicalLine),
+        content.subarray(lineEnd + 1)
+    ]);
+}
+function hashFiles(root, files, launcherShebang) {
     const hash = crypto.createHash('sha256');
     for (const relative of [...new Set(files.map(normalizeRelativePath))].sort()) {
         if (path.isAbsolute(relative) || relative.split(/[\\/]/u).includes('..')) {
@@ -60,7 +118,10 @@ function hashFiles(root, files) {
         }
         hash.update(relative);
         hash.update('\0');
-        hash.update(fs.readFileSync(file));
+        const content = fs.readFileSync(file);
+        hash.update(launcherShebang
+            ? normalizeLifecycleLauncherBytes(relative, content, launcherShebang)
+            : content);
         hash.update('\0');
     }
     return hash.digest('hex');
@@ -107,7 +168,7 @@ function computeLifecycleBuildIdentity(repoRoot, options = {}) {
         throw new Error('Lifecycle package version is invalid');
     let internalExecutableBuildHash;
     if (options.executableFiles) {
-        internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles);
+        internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles, defaults.launcherShebang);
     }
     else {
         const manifestFile = path.join(executableRoot, 'dist', 'lifecycle-build-manifest.json');
@@ -121,17 +182,17 @@ function computeLifecycleBuildIdentity(repoRoot, options = {}) {
             }
             if (fileURLToPath(import.meta.url).split(path.sep).includes('dist')) {
                 const compiledFiles = defaults.executableFiles.map((file) => file.endsWith('.ts') ? path.join('dist', file.replace(/\.ts$/u, '.js')) : file);
-                if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, compiledFiles)) !== manifest.internalExecutableBuildHash) {
+                if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, compiledFiles), defaults.launcherShebang) !== manifest.internalExecutableBuildHash) {
                     throw new Error('Lifecycle compiled executable build does not match its manifest');
                 }
             }
-            else if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles)) !== manifest.sourceInputHash) {
+            else if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles), defaults.launcherShebang) !== manifest.sourceInputHash) {
                 throw new Error('Lifecycle executable build manifest is stale or invalid');
             }
             internalExecutableBuildHash = manifest.internalExecutableBuildHash;
         }
         else
-            internalExecutableBuildHash = hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles));
+            internalExecutableBuildHash = hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles), defaults.launcherShebang);
     }
     return Object.freeze({
         protocolVersion: LIFECYCLE_PROTOCOL_VERSION,

package/dist/lib/defaults.json

@@ -48,6 +48,10 @@
     "task": {
         "shortIdLength": 2
     },
+    "delivery": {
+        "remote": "origin",
+        "baseRef": "main"
+    },
     "labels": {
         "in": {}
     },

package/dist/lib/git/workflow.js

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 const defaultRunner = (args, cwd) => {
     const result = spawnSync('git', [...args], { cwd, encoding: 'utf8' });
@@ -108,6 +109,47 @@ function commitExplicitPaths(input, runner = defaultRunner) {
         return { status: 'failed', changed: false, snapshot: after.snapshot, operations: [{ name: 'commit', status: 'failed', message: commit.stderr.trim() }], error: { code: 'GIT_COMMIT_FAILED', message: commit.stderr.trim() } };
     return { status: 'applied', changed: true, snapshot: after.snapshot, operations: [{ name: 'stage', status: 'applied' }, { name: 'commit', status: 'applied' }], error: null };
 }
+function previewCommitTree(input) {
+    const invalid = validatePaths(input.paths);
+    if (invalid)
+        return { status: 'failed', tree: null, error: { code: 'GIT_COMMIT_INPUT_INVALID', message: invalid } };
+    const before = inspectGitWorkflow(input.cwd);
+    if (!before.snapshot)
+        return { status: 'failed', tree: null, error: { code: 'GIT_INSPECT_FAILED', message: 'Unable to inspect Git repository' } };
+    if (before.snapshot.head !== input.expectedHead) {
+        return { status: 'failed', tree: null, error: { code: 'GIT_HEAD_MISMATCH', message: `Expected HEAD ${input.expectedHead}, received ${before.snapshot.head}` } };
+    }
+    const selected = new Set(input.paths);
+    const unrelatedStaged = before.snapshot.staged.filter((candidate) => !selected.has(candidate));
+    if (unrelatedStaged.length > 0) {
+        return { status: 'failed', tree: null, error: { code: 'GIT_STAGED_SCOPE_MISMATCH', message: `Unrelated staged paths: ${unrelatedStaged.join(', ')}` } };
+    }
+    const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-preview-index-'));
+    const indexFile = path.join(temporaryDirectory, 'index');
+    const temporaryRunner = (args, cwd) => {
+        const result = spawnSync('git', [...args], {
+            cwd,
+            env: { ...process.env, GIT_INDEX_FILE: indexFile },
+            encoding: 'utf8'
+        });
+        return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+    };
+    try {
+        const read = run(temporaryRunner, input.cwd, ['read-tree', input.expectedHead]);
+        if (read.status !== 0)
+            return { status: 'failed', tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: read.stderr.trim() || 'Unable to prepare a temporary Git index' } };
+        const stage = run(temporaryRunner, input.cwd, ['add', '-A', '--', ...input.paths]);
+        if (stage.status !== 0)
+            return { status: 'failed', tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: stage.stderr.trim() || 'Unable to stage the requested paths in a temporary index' } };
+        const tree = value(temporaryRunner, input.cwd, ['write-tree']);
+        if (!tree)
+            return { status: 'failed', tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: 'Unable to write the temporary Git tree' } };
+        return { status: 'planned', tree, error: null };
+    }
+    finally {
+        fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+}
 function pushGitRefs(input, runner = defaultRunner) {
     if (!input.remote || input.refs.length === 0)
         return { status: 'failed', changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [], error: { code: 'GIT_PUSH_INPUT_INVALID', message: 'Remote and refs are required' } };
@@ -185,5 +227,5 @@ function pushRebasedBranch(input, runner = defaultRunner) {
     }
     return { status: 'applied', changed: true, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'push-rebased', status: 'applied', ref: input.branch }], error: null };
 }
-export { commitExplicitPaths, inspectGitWorkflow, pushGitRefs, pushRebasedBranch };
+export { commitExplicitPaths, inspectGitWorkflow, previewCommitTree, pushGitRefs, pushRebasedBranch };
 //# sourceMappingURL=workflow.js.map

package/dist/lib/init.js

@@ -175,6 +175,7 @@ async function cmdInit() {
         templateVersion: VERSION,
         sandbox: structuredClone(defaults.sandbox),
         task: structuredClone(defaults.task),
+        delivery: structuredClone(defaults.delivery),
         labels: structuredClone(defaults.labels),
         files: { managed: [], merged: [], ejected: [] },
         agentClients: serializeAgentClients(defaultState)

package/dist/lib/internal/git-workflow.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { inspectGitWorkflow, pushRebasedBranch } from '../git/workflow.js';
+import { inspectGitWorkflow, previewCommitTree, pushRebasedBranch } from '../git/workflow.js';
 import { compareReviewTrees, snapshotReview } from '../git/review-snapshot.js';
 import { resolvePostReviewGlobs } from '../task/review-fingerprint.js';
 import { executeCommitOperation } from '../task/commit-operation.js';
@@ -26,6 +26,13 @@ function gitWorkflow(args = []) {
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         result = input ? pushRebasedBranch({ cwd: cwd ?? process.cwd(), ...input }) : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
     }
+    else if (action === 'preview-tree') {
+        const inputIndex = rest.indexOf('--input');
+        const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
+        result = input
+            ? previewCommitTree({ cwd: cwd ?? process.cwd(), paths: input.paths, expectedHead: input.expectedHead })
+            : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
+    }
     else if (action === 'snapshot' || action === 'compare-trees') {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;

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

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, resolveExternalPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, resolveExternalPullRequest, skipPlatformPullRequestFact, syncPlatformPullRequest } from '../platform/pull-requests.js';
 import { summaryContext, syncPullRequestSummary } from '../platform/pr-summary.js';
 const USAGE = `Usage: agent-infra-internal platform-pr inspect <task-ref> [--cwd <path>]
        agent-infra-internal platform-pr resolve-external <task-ref> --agent <agent> [--pr <N>] [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr create <task-ref> --agent <agent> --base <branch> --head <branch> --title-file <path|-> --body-file <path|-> [--draft] [--dry-run] [--cwd <path>]
        agent-infra-internal platform-pr bind <task-ref> --pr <N> --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 summary-context <task-ref> [--cwd <path>]
        agent-infra-internal platform-pr summary-sync <task-ref> --agent <agent> --body-file <path|-> --result <pr_created|pr_reused|no_op> [--dry-run] [--cwd <path>]
@@ -58,7 +59,7 @@ function platformPr(args = []) {
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'resolve-external', 'create', 'bind', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
+    if (!operation || !['inspect', 'resolve-external', 'create', 'bind', 'skip', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
         fail('a valid operation is required');
         return;
     }
@@ -79,6 +80,7 @@ function platformPr(args = []) {
         'resolve-external': ['cwd', 'agent', 'pr', 'dryRun'],
         create: ['cwd', 'agent', 'base', 'head', 'titleFile', 'bodyFile', 'draft', 'dryRun'],
         bind: ['cwd', 'agent', 'pr', 'dryRun'],
+        skip: ['cwd', 'agent', 'dryRun'],
         sync: ['cwd', 'agent', 'metadata', 'closingIssue', 'result', 'dryRun'],
         'summary-context': ['cwd'],
         'summary-sync': ['cwd', 'agent', 'bodyFile', 'result', 'dryRun']
@@ -106,6 +108,10 @@ function platformPr(args = []) {
         return;
     }
     values.agent = agent;
+    if (operation === 'skip') {
+        finish(skipPlatformPullRequestFact(taskRef, { cwd, agent, dryRun: values.dryRun === true }));
+        return;
+    }
     const primaryResult = values.result === undefined ? undefined : values.result;
     if (primaryResult !== undefined && !['pr_created', 'pr_reused', 'no_op'].includes(primaryResult)) {
         fail('--result must be pr_created, pr_reused, or no_op');

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

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { deliverTaskBranch } from '../task/delivery.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 = []) {
+    const taskRef = args[0];
+    const operation = args[1];
+    if (!taskRef || operation !== 'deliver') {
+        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;
+        return;
+    }
+    let agent = '';
+    let remote;
+    let baseRef;
+    let cwd = process.cwd();
+    let dryRun = false;
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--')) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'DELIVERY_PAYLOAD_INVALID', message: `${flag} requires a value` } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        if (flag === '--agent')
+            agent = value;
+        else if (flag === '--remote')
+            remote = value;
+        else if (flag === '--base')
+            baseRef = value;
+        else if (flag === '--cwd')
+            cwd = path.resolve(value);
+        else {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'DELIVERY_PAYLOAD_INVALID', message: `unknown option '${flag}'` } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const normalized = normalizeAgentToken(agent);
+    if (!normalized) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'DELIVERY_PAYLOAD_INVALID', message: `invalid --agent '${agent}': ${AGENT_USAGE_HINT}` } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = deliverTaskBranch(taskRef, { repoRoot: cwd, agent: normalized, remote, baseRef, dryRun });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+    if (result.status === 'blocked')
+        process.exitCode = 2;
+}
+export { taskDelivery };
+//# sourceMappingURL=task-delivery.js.map

package/dist/lib/platform/github-client.js

@@ -6,8 +6,14 @@ import semver from 'semver';
 const MINIMUM_GITHUB_CLI_VERSION = '2.72.0';
 const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
 const ERROR_DETAIL_LIMIT = 4096;
+function redactDiagnostic(value) {
+    return value
+        .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)\b/g, '[REDACTED_TOKEN]')
+        .replace(/\b(bearer|token)\s+[A-Za-z0-9._~+\/-]+/gi, '$1 [REDACTED_TOKEN]')
+        .replace(/([?&](?:access_token|token|client_secret|password)=)[^&\s]+/gi, '$1[REDACTED]');
+}
 function boundedFailureDetail(result) {
-    const diagnostic = `${result.stderr}\n${result.error?.message || ''}`.trim() || result.stdout.trim();
+    const diagnostic = redactDiagnostic(`${result.stderr}\n${result.error?.message || ''}`).trim() || redactDiagnostic(result.stdout.trim());
     return diagnostic.length <= ERROR_DETAIL_LIMIT
         ? diagnostic
         : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;

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

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
-import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { inspectPlatformRequiredChecks, registerPlatformCapabilities } from './adapters.js';
 import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
 import { inspectPlatformPullRequest } from './pull-requests.js';
 import { platformResult } from './types.js';
+import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
 function classifyRequiredChecks(required) {
     if (required.length === 0)
         return { state: 'no-required', required };
@@ -97,11 +98,13 @@ function resolvedTask(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return { ok: false, output: checksResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }) };
-    const frontmatter = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-    const pr = Number(frontmatter.pr_number);
-    const prNumber = Number.isInteger(pr) && pr > 0 ? pr : null;
+    const frontmatter = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    const fact = readPrDeliveryFact(frontmatter);
+    if (fact.status === 'invalid')
+        return { ok: false, output: checksResult('failed', { error: { code: 'PR_DELIVERY_FACT_INVALID', message: fact.error.message, retryable: false } }) };
+    const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
     if (!prNumber)
-        return { ok: false, output: checksResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } }) };
+        return { ok: false, output: checksResult('failed', { error: { code: fact.status === 'missing' ? 'PR_DELIVERY_FACT_MISSING' : 'PR_NOT_LINKED', message: 'Task has no verified bound pull request', retryable: false } }) };
     const client = options.client || createGitHubClient();
     const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
     if (!context.platform.repository || !['no-op', 'degraded'].includes(context.status))

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

@@ -1,13 +1,14 @@
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { enumerateArtifacts } from '../task/artifacts.js';
-import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { parseTypedTaskFrontmatter } 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';
 import { listRemoteComments, normalizeCommentContent, writeComment } from './issue-comments.js';
 import { platformResult } from './types.js';
+import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
 function warningResultForPrimary(primaryResult) {
     if (primaryResult === 'pr_created')
         return 'pr_created_with_warnings';
@@ -52,9 +53,9 @@ function summaryContext(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return { ...platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }), task: { id: resolved.taskId, prNumber: null }, artifacts: [] };
-    const frontmatter = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-    const value = Number(frontmatter.pr_number);
-    const prNumber = Number.isInteger(value) && value > 0 ? value : null;
+    const frontmatter = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    const fact = readPrDeliveryFact(frontmatter);
+    const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
     return { ...platformResult('no-op'), task: { id: resolved.taskId, prNumber }, artifacts: canonicalArtifacts(resolved.taskDir) };
 }
 function syncPullRequestSummary(taskRef, options) {
@@ -90,10 +91,13 @@ function syncPullRequestSummary(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return softenFailure(platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }));
-    const frontmatter = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-    const prNumber = Number(frontmatter.pr_number);
-    if (!Number.isInteger(prNumber) || prNumber <= 0)
-        return softenFailure(platformResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } }));
+    const frontmatter = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    const fact = readPrDeliveryFact(frontmatter);
+    if (fact.status === 'invalid')
+        return softenFailure(platformResult('failed', { error: { code: 'PR_DELIVERY_FACT_INVALID', message: fact.error.message, retryable: false } }));
+    const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
+    if (!prNumber)
+        return softenFailure(platformResult('failed', { error: { code: fact.status === 'missing' ? 'PR_DELIVERY_FACT_MISSING' : 'PR_NOT_LINKED', message: 'Task has no verified bound pull request', retryable: false } }));
     knownPrNumber = prNumber;
     const client = options.client || createGitHubClient();
     const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });