@fitlab-ai/agent-infra 0.9.12 → 0.9.14

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { fetchPlatformCheckLogs, inspectPullRequestReadiness, resolvePlatformCheckRun, watchPullRequestReadiness } from '../platform/pr-checks.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal platform-checks inspect <task-ref> [--cwd <path>]
        agent-infra-internal platform-checks watch <task-ref> --interval-seconds <N> --deadline-seconds <N> [--cwd <path>]
        agent-infra-internal platform-checks resolve-run <task-ref> --check-name <name> [--details-url <url>] [--cwd <path>]
@@ -43,12 +44,19 @@ function positive(value) {
     return Number.isFinite(number) && number > 0 ? number : null;
 }
 async function platformChecks(args = []) {
+    if (!ensureInternalHandlerRoute('platform-checks', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'watch', 'resolve-run', 'logs'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('platform-checks', 'inspect', operation),
+        internalHandlerRoute('platform-checks', 'watch', operation),
+        internalHandlerRoute('platform-checks', 'resolve-run', operation),
+        internalHandlerRoute('platform-checks', 'logs', operation)
+    ].some(Boolean)) {
         fail('a valid operation is required');
         return;
     }
@@ -75,26 +83,30 @@ async function platformChecks(args = []) {
         fail(`${operation} does not accept --${unexpected}`);
         return;
     }
-    if (operation === 'inspect') {
-        finish(inspectPullRequestReadiness(taskRef, { cwd }));
+    if (internalHandlerRoute('platform-checks', 'inspect', operation)) {
+        finish(await inspectPullRequestReadiness(taskRef, { cwd }));
         return;
     }
-    if (operation === 'resolve-run') {
+    if (internalHandlerRoute('platform-checks', 'resolve-run', operation)) {
         if (!values.checkName) {
             fail('resolve-run requires --check-name');
             return;
         }
-        finish(resolvePlatformCheckRun(taskRef, { cwd, checkName: values.checkName, detailsUrl: values.detailsUrl }));
+        finish(await resolvePlatformCheckRun(taskRef, { cwd, checkName: values.checkName, detailsUrl: values.detailsUrl }));
         return;
     }
-    if (operation === 'logs') {
+    if (internalHandlerRoute('platform-checks', 'logs', operation)) {
         const run = positive(values.run);
         const job = values.job === undefined ? undefined : positive(values.job);
         if (!run || values.job !== undefined && !job) {
             fail('logs requires a positive --run and optional positive --job');
             return;
         }
-        finish(fetchPlatformCheckLogs(taskRef, { cwd, run, job: job || undefined }));
+        finish(await fetchPlatformCheckLogs(taskRef, { cwd, run, job: job || undefined }));
+        return;
+    }
+    if (!internalHandlerRoute('platform-checks', 'watch', operation)) {
+        fail('operation is not registered');
         return;
     }
     const intervalSeconds = positive(values.intervalSeconds);

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

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { checkPlatformCommentOwner, listPlatformComments, syncPlatformComment } from '../platform/issue-comments.js';
 import { backfillCompletionComments } from '../platform/completion-backfill.js';
-const USAGE = `Usage: agent-infra-internal platform-comment list --issue <N> [--cwd <path>]
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = `Usage: agent-infra-internal platform-comment list --issue <token> [--cwd <path>]
        agent-infra-internal platform-comment owner <task-ref> [--cwd <path>]
        agent-infra-internal platform-comment backfill <task-ref> --agent <agent> [--cwd <path>]
        agent-infra-internal platform-comment sync <task-ref> --kind <kind> --agent <agent> [--artifact <file>] [--body-file <path|->] [--status-label <label>] [--backfill] [--cwd <path>]
@@ -47,13 +48,20 @@ function readBodyFile(value, cwd) {
         return fs.readFileSync(0, 'utf8');
     return fs.readFileSync(path.resolve(cwd, value), 'utf8');
 }
-function platformComment(args = []) {
+async function platformComment(args = []) {
+    if (!ensureInternalHandlerRoute('platform-comment', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['list', 'owner', 'backfill', 'sync'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('platform-comment', 'list', operation),
+        internalHandlerRoute('platform-comment', 'owner', operation),
+        internalHandlerRoute('platform-comment', 'backfill', operation),
+        internalHandlerRoute('platform-comment', 'sync', operation)
+    ].some(Boolean)) {
         fail('a valid operation is required');
         return;
     }
@@ -69,10 +77,10 @@ function platformComment(args = []) {
         return;
     }
     const cwd = path.resolve(typeof parsed.values.cwd === 'string' ? parsed.values.cwd : process.cwd());
-    if (operation === 'list') {
-        const issue = Number(parsed.values.issue);
-        if (!Number.isInteger(issue) || issue <= 0) {
-            fail('list requires a positive --issue');
+    if (internalHandlerRoute('platform-comment', 'list', operation)) {
+        const issue = parsed.values.issue;
+        if (typeof issue !== 'string' || !issue) {
+            fail('list requires --issue <token>');
             return;
         }
         const unexpected = Object.keys(parsed.values).find((key) => !['issue', 'cwd'].includes(key));
@@ -80,19 +88,19 @@ function platformComment(args = []) {
             fail(`list does not accept '--${unexpected}'`);
             return;
         }
-        finish(listPlatformComments(issue, cwd));
+        finish(await listPlatformComments(issue, cwd));
         return;
     }
-    if (operation === 'owner') {
+    if (internalHandlerRoute('platform-comment', 'owner', operation)) {
         const unexpected = Object.keys(parsed.values).find((key) => key !== 'cwd');
         if (unexpected) {
             fail(`owner does not accept '--${unexpected}'`);
             return;
         }
-        finish(checkPlatformCommentOwner(taskRef, { cwd }));
+        finish(await checkPlatformCommentOwner(taskRef, { cwd }));
         return;
     }
-    if (operation === 'backfill') {
+    if (internalHandlerRoute('platform-comment', 'backfill', operation)) {
         const unexpected = Object.keys(parsed.values).find((key) => !['cwd', 'agent'].includes(key));
         if (unexpected) {
             fail(`backfill does not accept '--${unexpected}'`);
@@ -108,7 +116,11 @@ function platformComment(args = []) {
             fail(`invalid --agent '${agent}': ${AGENT_USAGE_HINT}`);
             return;
         }
-        finish(backfillCompletionComments(taskRef, { cwd, agent: normalizedAgent }));
+        finish(await backfillCompletionComments(taskRef, { cwd, agent: normalizedAgent }));
+        return;
+    }
+    if (!internalHandlerRoute('platform-comment', 'sync', operation)) {
+        fail('operation is not registered');
         return;
     }
     const kind = parsed.values.kind;
@@ -143,7 +155,7 @@ function platformComment(args = []) {
         fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
         return;
     }
-    finish(syncPlatformComment(taskRef, {
+    finish(await syncPlatformComment(taskRef, {
         kind: kind,
         agent: normalizedAgent,
         artifact: typeof parsed.values.artifact === 'string' ? parsed.values.artifact : undefined,

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

@@ -1,17 +1,20 @@
 import path from 'node:path';
 import { resolvePlatformContext } from '../platform/context.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal platform-context resolve [--cwd <path>]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PLATFORM_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-function platformContext(args = []) {
+async function platformContext(args = []) {
+    if (!ensureInternalHandlerRoute('platform-context', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args[0] !== 'resolve') {
+    if (!internalHandlerRoute('platform-context', 'resolve', args[0] ?? '')) {
         fail("operation must be 'resolve'");
         return;
     }
@@ -35,7 +38,7 @@ function platformContext(args = []) {
         seen.add(flag);
         cwd = path.resolve(value);
     }
-    const result = resolvePlatformContext({ cwd });
+    const result = await resolvePlatformContext({ cwd });
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

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

@@ -1,9 +1,10 @@
 import path from 'node:path';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { bindPlatformIssue, createPlatformIssue, inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal platform-issue inspect <task-ref> [--cwd <path>]
        agent-infra-internal platform-issue create <task-ref> --agent <agent> [--dry-run] [--cwd <path>]
-       agent-infra-internal platform-issue bind <task-ref> --issue <N> --agent <agent> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-issue bind <task-ref> --issue <token> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-issue sync <task-ref> --agent <agent> [--status <suffix|none>] [--assignees current|none] [--milestone initial|specific|none] [--issue-type] [--fields] [--requirements] [--in-labels from-diff|none] [--base <branch>] [--state open|closed] [--close-reason completed|not_planned] [--dry-run] [--cwd <path>]
 `;
 const BOOLEAN_FLAGS = new Set(['--dry-run', '--issue-type', '--fields', '--requirements']);
@@ -54,13 +55,20 @@ function oneOf(values, name, allowed) {
         throw new Error(`--${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)} must be one of ${allowed.join('|')}`);
     return value;
 }
-function platformIssue(args = []) {
+async function platformIssue(args = []) {
+    if (!ensureInternalHandlerRoute('platform-issue', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'create', 'bind', 'sync'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('platform-issue', 'inspect', operation),
+        internalHandlerRoute('platform-issue', 'create', operation),
+        internalHandlerRoute('platform-issue', 'bind', operation),
+        internalHandlerRoute('platform-issue', 'sync', operation)
+    ].some(Boolean)) {
         fail('a valid operation is required');
         return;
     }
@@ -85,8 +93,8 @@ function platformIssue(args = []) {
         fail(`${operation} does not accept --${unexpected}`);
         return;
     }
-    if (operation === 'inspect') {
-        finish(inspectPlatformIssue(taskRef, { cwd }));
+    if (internalHandlerRoute('platform-issue', 'inspect', operation)) {
+        finish(await inspectPlatformIssue(taskRef, { cwd }));
         return;
     }
     if (typeof values.agent !== 'string' || !values.agent) {
@@ -99,17 +107,16 @@ function platformIssue(args = []) {
         return;
     }
     values.agent = agent;
-    if (operation === 'create') {
-        finish(createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true }));
+    if (internalHandlerRoute('platform-issue', 'create', operation)) {
+        finish(await createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true }));
         return;
     }
-    if (operation === 'bind') {
-        const issue = Number(values.issue);
-        if (!Number.isInteger(issue) || issue <= 0) {
-            fail('bind requires a positive --issue');
+    if (internalHandlerRoute('platform-issue', 'bind', operation)) {
+        if (typeof values.issue !== 'string' || !values.issue) {
+            fail('bind requires --issue <token>');
             return;
         }
-        finish(bindPlatformIssue(taskRef, { cwd, agent: values.agent, issue, dryRun: values.dryRun === true }));
+        finish(await bindPlatformIssue(taskRef, { cwd, agent: values.agent, issue: values.issue, dryRun: values.dryRun === true }));
         return;
     }
     try {
@@ -127,7 +134,7 @@ function platformIssue(args = []) {
         const desiredKeys = ['status', 'assignees', 'milestone', 'issueType', 'fields', 'requirements', 'inLabels', 'state'];
         if (!desiredKeys.some((name) => values[name] !== undefined))
             throw new Error('sync requires at least one desired-state option');
-        finish(syncPlatformIssue(taskRef, {
+        finish(await syncPlatformIssue(taskRef, {
             cwd, agent: values.agent, dryRun: values.dryRun === true,
             status: typeof values.status === 'string' ? values.status : undefined,
             assignees: assignees,

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

@@ -0,0 +1,88 @@
+import path from 'node:path';
+import { initializeLabels, initializeMilestones } from '../platform/repository-metadata.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = `Usage: agent-infra-internal platform-metadata init-labels [--cleanup-stale-in] [--cwd <path>]
+       agent-infra-internal platform-metadata init-milestones [--history] [--cwd <path>]
+`;
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'METADATA_INPUT_INVALID', message, retryable: false } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(result, preserveMilestoneFallback = false) {
+    if (preserveMilestoneFallback && result.error && typeof result.error === 'object'
+        && result.error.code === 'PLATFORM_CAPABILITY_UNSUPPORTED') {
+        process.stderr.write('Milestone initialization skipped for unsupported platform.\n');
+        process.exitCode = 0;
+        return;
+    }
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+}
+function parseOptions(args) {
+    let cwd = process.cwd();
+    let cleanup = false;
+    let history = false;
+    const seen = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const flag = args[index];
+        if (seen.has(flag))
+            return null;
+        seen.add(flag);
+        if (flag === '--cleanup-stale-in') {
+            cleanup = true;
+            continue;
+        }
+        if (flag === '--history') {
+            history = true;
+            continue;
+        }
+        if (flag === '--cwd') {
+            const value = args[++index];
+            if (!value || value.startsWith('--'))
+                return null;
+            cwd = path.resolve(value);
+            continue;
+        }
+        return null;
+    }
+    return { cwd: path.resolve(cwd), cleanup, history };
+}
+async function platformMetadata(args = []) {
+    if (!ensureInternalHandlerRoute('platform-metadata', args))
+        return;
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const action = args[0];
+    if (!internalHandlerRoute('platform-metadata', 'init-labels', action ?? '')
+        && !internalHandlerRoute('platform-metadata', 'init-milestones', action ?? '')) {
+        fail('a valid operation is required');
+        return;
+    }
+    if (action !== 'init-labels' && action !== 'init-milestones') {
+        fail('a valid operation is required');
+        return;
+    }
+    const parsed = parseOptions(args.slice(1));
+    if (!parsed) {
+        fail('invalid metadata options');
+        return;
+    }
+    if (action === 'init-labels' && parsed.history) {
+        fail('init-labels does not accept --history');
+        return;
+    }
+    if (action === 'init-milestones' && parsed.cleanup) {
+        fail('init-milestones does not accept --cleanup-stale-in');
+        return;
+    }
+    if (action === 'init-labels') {
+        finish(await initializeLabels({ cleanupStaleIn: parsed.cleanup }, { cwd: parsed.cwd }));
+        return;
+    }
+    finish(await initializeMilestones({ history: parsed.history }, { cwd: parsed.cwd }), true);
+}
+export { platformMetadata };
+//# sourceMappingURL=platform-metadata.js.map

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

@@ -2,9 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { inspectPlatformPullRequestByNumber } from '../platform/pull-requests.js';
 import { listPrReviews, publishPrReview } from '../platform/pr-review.js';
-const USAGE = `Usage: agent-infra-internal platform-pr-review inspect --pr <N> [--cwd <path>]
-       agent-infra-internal platform-pr-review list --pr <N> [--cwd <path>]
-       agent-infra-internal platform-pr-review publish --pr <N> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--dry-run] [--cwd <path>]
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = `Usage: agent-infra-internal platform-pr-review inspect --pr <token> [--cwd <path>]
+       agent-infra-internal platform-pr-review list --pr <token> [--cwd <path>]
+       agent-infra-internal platform-pr-review publish --pr <token> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--dry-run] [--cwd <path>]
 `;
 const BOOLEAN_FLAGS = new Set(['--dry-run']);
 const VALUE_FLAGS = new Set(['--cwd', '--pr', '--scope', '--round', '--commit', '--event', '--body-file']);
@@ -47,13 +48,19 @@ function parse(args, start) {
 function readBodyFile(value, cwd) {
     return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
 }
-function platformPrReview(args = []) {
+async function platformPrReview(args = []) {
+    if (!ensureInternalHandlerRoute('platform-pr-review', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'list', 'publish'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('platform-pr-review', 'inspect', operation),
+        internalHandlerRoute('platform-pr-review', 'list', operation),
+        operation === 'publish'
+    ].some(Boolean)) {
         fail('a valid operation is required');
         return;
     }
@@ -74,20 +81,21 @@ function platformPrReview(args = []) {
         fail(`${operation} does not accept --${unexpected}`);
         return;
     }
-    const pr = Number(values.pr);
-    if (!Number.isInteger(pr) || pr <= 0) {
-        fail(`${operation} requires a positive --pr`);
+    const pr = values.pr;
+    if (typeof pr !== 'string' || !pr) {
+        fail(`${operation} requires --pr <token>`);
         return;
     }
-    if (operation === 'inspect') {
-        finish(inspectPlatformPullRequestByNumber(pr, { cwd }));
+    if (internalHandlerRoute('platform-pr-review', 'inspect', operation)) {
+        finish(await inspectPlatformPullRequestByNumber(pr, { cwd }));
         return;
     }
-    if (operation === 'list') {
-        finish(listPrReviews(pr, { cwd }));
+    if (internalHandlerRoute('platform-pr-review', 'list', operation)) {
+        finish(await listPrReviews(pr, { cwd }));
         return;
     }
     const scope = typeof values.scope === 'string' ? values.scope : '';
+    const publishSelector = /^TASK-\d{8}-\d{6}$/u.test(scope) ? 'publish-task' : /^pr\d+$/u.test(scope) ? 'publish-pr' : '';
     const round = Number(values.round);
     const commit = typeof values.commit === 'string' ? values.commit : '';
     const event = values.event;
@@ -95,6 +103,11 @@ function platformPrReview(args = []) {
         fail('publish requires --scope <taskId|pr{N}>');
         return;
     }
+    if (!internalHandlerRoute('platform-pr-review', 'publish-task', publishSelector)
+        && !internalHandlerRoute('platform-pr-review', 'publish-pr', publishSelector)) {
+        fail('publish scope is not registered');
+        return;
+    }
     if (!Number.isInteger(round) || round <= 0) {
         fail('publish requires a positive --round');
         return;
@@ -119,7 +132,7 @@ function platformPrReview(args = []) {
         fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
         return;
     }
-    finish(publishPrReview({
+    finish(await publishPrReview({
         cwd,
         prNumber: pr,
         identity: { scope, round, commitSha: commit },

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

@@ -1,19 +1,22 @@
 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, skipPlatformPullRequestFact, syncPlatformPullRequest } from '../platform/pull-requests.js';
-import { summaryContext, syncPullRequestSummary } from '../platform/pr-summary.js';
+import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, resolveExternalPullRequest, skipPlatformPullRequestFact, syncPlatformPullRequest, syncPlatformPullRequestInLabels } from '../platform/pull-requests.js';
+import { reportWrite, summaryContext, syncPullRequestSummary } from '../platform/pr-summary.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.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 resolve-external <task-ref> --agent <agent> [--pr <token>] [--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 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 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>]
+       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> [--strict] [--dry-run] [--cwd <path>]
 `;
-const BOOLEAN_FLAGS = new Set(['--draft', '--dry-run', '--metadata', '--closing-issue']);
-const VALUE_FLAGS = new Set(['--cwd', '--agent', '--base', '--head', '--title-file', '--body-file', '--pr', '--result']);
+const BOOLEAN_FLAGS = new Set(['--draft', '--dry-run', '--metadata', '--closing-issue', '--strict']);
+const VALUE_FLAGS = new Set(['--cwd', '--agent', '--base', '--head', '--title-file', '--body-file', '--change-report-file', '--mechanical-file', '--precheck-file', '--pr', '--result']);
 function key(flag) {
     return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
@@ -53,16 +56,50 @@ function parse(args, start) {
 function readFile(value, cwd) {
     return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
 }
-function platformPr(args = []) {
+async function platformPr(args = []) {
+    if (!ensureInternalHandlerRoute('platform-pr', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'resolve-external', 'create', 'bind', 'skip', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('platform-pr', 'inspect', operation),
+        internalHandlerRoute('platform-pr', 'resolve-external', operation),
+        internalHandlerRoute('platform-pr', 'create', operation),
+        internalHandlerRoute('platform-pr', 'bind', operation),
+        internalHandlerRoute('platform-pr', 'skip', operation),
+        internalHandlerRoute('platform-pr', 'sync', operation),
+        internalHandlerRoute('platform-pr', 'sync-in-labels', operation),
+        internalHandlerRoute('platform-pr', 'summary-context', operation),
+        internalHandlerRoute('platform-pr', 'change-report', operation),
+        internalHandlerRoute('platform-pr', 'summary-sync', operation)
+    ].some(Boolean)) {
         fail('a valid operation is required');
         return;
     }
+    if (internalHandlerRoute('platform-pr', 'sync-in-labels', operation)) {
+        const parsed = parse(args, 1);
+        if (parsed.error) {
+            fail(parsed.error);
+            return;
+        }
+        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;
+        }
+        const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+        finish(await syncPlatformPullRequestInLabels(pr, { cwd, dryRun: values.dryRun === true }));
+        return;
+    }
     const taskRef = args[1];
     if (!taskRef || taskRef.startsWith('--')) {
         fail(`${operation} requires a task ref`);
@@ -82,20 +119,22 @@ function platformPr(args = []) {
         bind: ['cwd', 'agent', 'pr', 'dryRun'],
         skip: ['cwd', 'agent', 'dryRun'],
         sync: ['cwd', 'agent', 'metadata', 'closingIssue', 'result', 'dryRun'],
+        'sync-in-labels': ['cwd', 'pr', 'dryRun'],
         'summary-context': ['cwd'],
-        'summary-sync': ['cwd', 'agent', 'bodyFile', 'result', 'dryRun']
+        'change-report': ['cwd', 'agent', 'mechanicalFile', 'precheckFile', 'dryRun'],
+        'summary-sync': ['cwd', 'agent', 'bodyFile', 'changeReportFile', 'result', 'dryRun', 'strict']
     };
     const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
     if (unexpected) {
         fail(`${operation} does not accept --${unexpected}`);
         return;
     }
-    if (operation === 'inspect') {
-        finish(inspectPlatformPullRequest(taskRef, { cwd }));
+    if (internalHandlerRoute('platform-pr', 'inspect', operation)) {
+        finish(await inspectPlatformPullRequest(taskRef, { cwd }));
         return;
     }
-    if (operation === 'summary-context') {
-        finish(summaryContext(taskRef, { cwd }));
+    if (internalHandlerRoute('platform-pr', 'summary-context', operation)) {
+        finish(await summaryContext(taskRef, { cwd }));
         return;
     }
     if (typeof values.agent !== 'string' || !values.agent) {
@@ -108,8 +147,18 @@ function platformPr(args = []) {
         return;
     }
     values.agent = agent;
-    if (operation === 'skip') {
-        finish(skipPlatformPullRequestFact(taskRef, { cwd, agent, dryRun: values.dryRun === true }));
+    if (internalHandlerRoute('platform-pr', 'change-report', operation)) {
+        if (typeof values.mechanicalFile !== 'string' || typeof values.precheckFile !== 'string') {
+            fail('change-report requires --mechanical-file and --precheck-file');
+            return;
+        }
+        finish(await reportWrite(taskRef, {
+            cwd, agent: values.agent, mechanicalFile: values.mechanicalFile, precheckFile: values.precheckFile, dryRun: values.dryRun === true
+        }));
+        return;
+    }
+    if (internalHandlerRoute('platform-pr', 'skip', operation)) {
+        finish(await skipPlatformPullRequestFact(taskRef, { cwd, agent, dryRun: values.dryRun === true }));
         return;
     }
     const primaryResult = values.result === undefined ? undefined : values.result;
@@ -117,25 +166,25 @@ function platformPr(args = []) {
         fail('--result must be pr_created, pr_reused, or no_op');
         return;
     }
-    if (operation === 'resolve-external') {
-        const pr = values.pr === undefined ? undefined : Number(values.pr);
-        if (pr !== undefined && (!Number.isInteger(pr) || pr <= 0)) {
-            fail('resolve-external requires a positive --pr');
+    if (internalHandlerRoute('platform-pr', 'resolve-external', operation)) {
+        const pr = values.pr === undefined ? undefined : values.pr;
+        if (pr !== undefined && (typeof pr !== 'string' || !pr)) {
+            fail('resolve-external requires --pr <token>');
             return;
         }
-        finish(resolveExternalPullRequest(taskRef, { cwd, agent: values.agent, pr, dryRun: values.dryRun === true }));
+        finish(await resolveExternalPullRequest(taskRef, { cwd, agent: values.agent, pr, dryRun: values.dryRun === true }));
         return;
     }
-    if (operation === 'bind') {
-        const pr = Number(values.pr);
-        if (!Number.isInteger(pr) || pr <= 0) {
-            fail('bind requires a positive --pr');
+    if (internalHandlerRoute('platform-pr', 'bind', operation)) {
+        const pr = values.pr;
+        if (typeof pr !== 'string' || !pr) {
+            fail('bind requires --pr <token>');
             return;
         }
-        finish(bindPlatformPullRequest(taskRef, { cwd, agent: values.agent, pr, dryRun: values.dryRun === true }));
+        finish(await bindPlatformPullRequest(taskRef, { cwd, agent: values.agent, pr, dryRun: values.dryRun === true }));
         return;
     }
-    if (operation === 'sync') {
+    if (internalHandlerRoute('platform-pr', 'sync', operation)) {
         if (values.metadata !== true && values.closingIssue !== true) {
             fail('sync requires --metadata or --closing-issue');
             return;
@@ -144,20 +193,24 @@ function platformPr(args = []) {
             fail('sync requires --result pr_created, pr_reused, or no_op');
             return;
         }
-        finish(syncPlatformPullRequest(taskRef, { cwd, agent: values.agent, metadata: values.metadata === true, closingIssue: values.closingIssue === true, primaryResult: primaryResult, dryRun: values.dryRun === true }));
+        finish(await syncPlatformPullRequest(taskRef, { cwd, agent: values.agent, metadata: values.metadata === true, closingIssue: values.closingIssue === true, primaryResult: primaryResult, dryRun: values.dryRun === true }));
         return;
     }
-    if (operation === 'summary-sync') {
+    if (internalHandlerRoute('platform-pr', 'summary-sync', operation)) {
         if (typeof values.bodyFile !== 'string') {
             fail('summary-sync requires --body-file');
             return;
         }
+        if (typeof values.changeReportFile !== 'string') {
+            fail('summary-sync requires --change-report-file');
+            return;
+        }
         if (!primaryResult) {
             fail('summary-sync requires --result pr_created, pr_reused, or no_op');
             return;
         }
         try {
-            finish(syncPullRequestSummary(taskRef, { cwd, agent: values.agent, body: readFile(values.bodyFile, cwd), primaryResult: primaryResult, dryRun: values.dryRun === true }));
+            finish(await syncPullRequestSummary(taskRef, { cwd, agent: values.agent, body: readFile(values.bodyFile, cwd), changeReportFile: values.changeReportFile, primaryResult: primaryResult, dryRun: values.dryRun === true, strict: values.strict === true }));
         }
         catch (error) {
             fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
@@ -169,7 +222,7 @@ function platformPr(args = []) {
         return;
     }
     try {
-        finish(createPlatformPullRequest(taskRef, {
+        finish(await createPlatformPullRequest(taskRef, {
             cwd, agent: values.agent, base: values.base, head: values.head,
             title: readFile(values.titleFile, cwd), body: readFile(values.bodyFile, cwd),
             draft: values.draft === true, dryRun: values.dryRun === true