@fitlab-ai/agent-infra 0.9.2 → 0.9.4

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

@@ -1,8 +1,11 @@
 import fs from 'node:fs';
 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>]
        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>]
 `;
 function fail(message) {
@@ -50,7 +53,7 @@ function platformComment(args = []) {
         return;
     }
     const operation = args[0];
-    if (!operation || !['list', 'owner', 'sync'].includes(operation)) {
+    if (!operation || !['list', 'owner', 'backfill', 'sync'].includes(operation)) {
         fail('a valid operation is required');
         return;
     }
@@ -89,6 +92,25 @@ function platformComment(args = []) {
         finish(checkPlatformCommentOwner(taskRef, { cwd }));
         return;
     }
+    if (operation === 'backfill') {
+        const unexpected = Object.keys(parsed.values).find((key) => !['cwd', 'agent'].includes(key));
+        if (unexpected) {
+            fail(`backfill does not accept '--${unexpected}'`);
+            return;
+        }
+        const agent = parsed.values.agent;
+        if (typeof agent !== 'string' || !agent) {
+            fail('backfill requires --agent');
+            return;
+        }
+        const normalizedAgent = normalizeAgentToken(agent);
+        if (!normalizedAgent) {
+            fail(`invalid --agent '${agent}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        finish(backfillCompletionComments(taskRef, { cwd, agent: normalizedAgent }));
+        return;
+    }
     const kind = parsed.values.kind;
     const agent = parsed.values.agent;
     if (!['task', 'artifact', 'summary', 'cancel'].includes(String(kind))) {
@@ -99,6 +121,11 @@ function platformComment(args = []) {
         fail('sync requires --agent');
         return;
     }
+    const normalizedAgent = normalizeAgentToken(agent);
+    if (!normalizedAgent) {
+        fail(`invalid --agent '${agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
     if (kind === 'artifact' && typeof parsed.values.artifact !== 'string') {
         fail('artifact sync requires --artifact');
         return;
@@ -118,7 +145,7 @@ function platformComment(args = []) {
     }
     finish(syncPlatformComment(taskRef, {
         kind: kind,
-        agent,
+        agent: normalizedAgent,
         artifact: typeof parsed.values.artifact === 'string' ? parsed.values.artifact : undefined,
         body,
         backfill: parsed.values.backfill === true,

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

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { bindPlatformIssue, createPlatformIssue, inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.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>]
@@ -92,6 +93,12 @@ function platformIssue(args = []) {
         fail(`${operation} requires --agent`);
         return;
     }
+    const agent = normalizeAgentToken(values.agent);
+    if (!agent) {
+        fail(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    values.agent = agent;
     if (operation === 'create') {
         finish(createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true }));
         return;

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

@@ -0,0 +1,132 @@
+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>]
+`;
+const BOOLEAN_FLAGS = new Set(['--dry-run']);
+const VALUE_FLAGS = new Set(['--cwd', '--pr', '--scope', '--round', '--commit', '--event', '--body-file']);
+function key(flag) {
+    return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PR_REVIEW_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    if (output.status === 'failed')
+        process.exitCode = 1;
+    if (output.status === 'blocked')
+        process.exitCode = 2;
+}
+function parse(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!BOOLEAN_FLAGS.has(flag) && !VALUE_FLAGS.has(flag))
+            return { values, error: `unknown option '${flag}'` };
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        if (BOOLEAN_FLAGS.has(flag)) {
+            values[key(flag)] = true;
+            continue;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[key(flag)] = value;
+    }
+    return { values };
+}
+function readBodyFile(value, cwd) {
+    return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
+}
+function platformPrReview(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['inspect', 'list', 'publish'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const parsed = parse(args, 1);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+    const allowed = {
+        inspect: ['cwd', 'pr'],
+        list: ['cwd', 'pr'],
+        publish: ['cwd', 'pr', 'scope', 'round', 'commit', 'event', 'bodyFile', 'dryRun']
+    };
+    const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
+    if (unexpected) {
+        fail(`${operation} does not accept --${unexpected}`);
+        return;
+    }
+    const pr = Number(values.pr);
+    if (!Number.isInteger(pr) || pr <= 0) {
+        fail(`${operation} requires a positive --pr`);
+        return;
+    }
+    if (operation === 'inspect') {
+        finish(inspectPlatformPullRequestByNumber(pr, { cwd }));
+        return;
+    }
+    if (operation === 'list') {
+        finish(listPrReviews(pr, { cwd }));
+        return;
+    }
+    const scope = typeof values.scope === 'string' ? values.scope : '';
+    const round = Number(values.round);
+    const commit = typeof values.commit === 'string' ? values.commit : '';
+    const event = values.event;
+    if (!scope || !/^(?:pr\d+|TASK-\d{8}-\d{6})$/.test(scope)) {
+        fail('publish requires --scope <taskId|pr{N}>');
+        return;
+    }
+    if (!Number.isInteger(round) || round <= 0) {
+        fail('publish requires a positive --round');
+        return;
+    }
+    if (!/^[0-9a-f]{7,40}$/i.test(commit)) {
+        fail('publish requires --commit <sha>');
+        return;
+    }
+    if (!['COMMENT', 'APPROVE', 'REQUEST_CHANGES'].includes(event)) {
+        fail('publish requires --event <COMMENT|APPROVE|REQUEST_CHANGES>');
+        return;
+    }
+    if (typeof values.bodyFile !== 'string') {
+        fail('publish requires --body-file');
+        return;
+    }
+    let body;
+    try {
+        body = readBodyFile(values.bodyFile, cwd);
+    }
+    catch (error) {
+        fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    finish(publishPrReview({
+        cwd,
+        prNumber: pr,
+        identity: { scope, round, commitSha: commit },
+        event: event,
+        body,
+        dryRun: values.dryRun === true
+    }));
+}
+export { platformPrReview };
+//# sourceMappingURL=platform-pr-review.js.map

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

@@ -1,8 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, resolveExternalPullRequest, 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 sync <task-ref> --agent <agent> [--metadata] [--closing-issue] [--dry-run] [--cwd <path>]
@@ -56,7 +58,7 @@ function platformPr(args = []) {
         return;
     }
     const operation = args[0];
-    if (!operation || !['inspect', 'create', 'bind', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
+    if (!operation || !['inspect', 'resolve-external', 'create', 'bind', 'sync', 'summary-context', 'summary-sync'].includes(operation)) {
         fail('a valid operation is required');
         return;
     }
@@ -74,6 +76,7 @@ function platformPr(args = []) {
     const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
     const allowed = {
         inspect: ['cwd'],
+        'resolve-external': ['cwd', 'agent', 'pr', 'dryRun'],
         create: ['cwd', 'agent', 'base', 'head', 'titleFile', 'bodyFile', 'draft', 'dryRun'],
         bind: ['cwd', 'agent', 'pr', 'dryRun'],
         sync: ['cwd', 'agent', 'metadata', 'closingIssue', 'dryRun'],
@@ -97,6 +100,21 @@ function platformPr(args = []) {
         fail(`${operation} requires --agent`);
         return;
     }
+    const agent = normalizeAgentToken(values.agent);
+    if (!agent) {
+        fail(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    values.agent = agent;
+    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');
+            return;
+        }
+        finish(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) {

package/dist/lib/internal/platform-release-notes.js

@@ -1,9 +1,28 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { publishReleaseNotes, releaseNoteContext } from '../platform/release-notes.js';
-function option(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 && args[index + 1] ? args[index + 1] : null;
+import { publishReleaseNotes, releaseNoteContext, stageReleaseNotes } from '../platform/release-notes.js';
+function parseOptions(args, valueFlags, switchFlags = []) {
+    const values = new Map();
+    const switches = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const flag = args[index];
+        if (values.has(flag) || switches.has(flag))
+            return null;
+        if (switchFlags.includes(flag)) {
+            switches.add(flag);
+            continue;
+        }
+        if (!valueFlags.includes(flag))
+            return null;
+        const value = args[++index];
+        if (!value || value.startsWith('--'))
+            return null;
+        values.set(flag, value);
+    }
+    return { values, switches };
+}
+function invalidInput(message) {
+    return { status: 'failed', changed: false, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message, retryable: false } };
 }
 function finish(result) {
     process.stdout.write(`${JSON.stringify(result)}\n`);
@@ -11,21 +30,37 @@ function finish(result) {
 }
 function platformReleaseNotes(args = []) {
     const [action, ...rest] = args;
-    const cwd = path.resolve(option(rest, '--cwd') || process.cwd());
     if (action === 'context') {
-        const historyRaw = option(rest, '--history-limit');
+        const parsed = parseOptions(rest, ['--cwd', '--history-limit', '--from-tag', '--to-tag', '--branch']);
+        if (!parsed)
+            return finish(invalidInput('invalid context options'));
+        const cwd = path.resolve(parsed.values.get('--cwd') || process.cwd());
+        const historyRaw = parsed.values.get('--history-limit') ?? null;
         finish(releaseNoteContext({
-            fromTag: option(rest, '--from-tag') || '',
-            toTag: option(rest, '--to-tag') || '',
-            branch: option(rest, '--branch') || '',
+            fromTag: parsed.values.get('--from-tag') || '',
+            toTag: parsed.values.get('--to-tag') || '',
+            branch: parsed.values.get('--branch') || '',
             historyLimit: historyRaw === null ? undefined : Number(historyRaw)
         }, { cwd }));
         return;
     }
+    if (action === 'stage') {
+        const parsed = parseOptions(rest, ['--cwd', '--notes-file']);
+        if (!parsed)
+            return finish(invalidInput('invalid stage options'));
+        const notesFile = parsed.values.get('--notes-file');
+        if (!notesFile)
+            return finish(invalidInput('notes-file is required'));
+        finish(stageReleaseNotes({ notesFile }, { cwd: path.resolve(parsed.values.get('--cwd') || process.cwd()) }));
+        return;
+    }
     if (action === 'publish') {
-        const notesPath = option(rest, '--notes-file');
+        const parsed = parseOptions(rest, ['--cwd', '--notes-file', '--tag', '--title', '--expected-sha256'], ['--dry-run']);
+        if (!parsed)
+            return finish(invalidInput('invalid publish options'));
+        const notesPath = parsed.values.get('--notes-file');
         if (!notesPath) {
-            finish({ status: 'failed', changed: false, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'notes-file is required', retryable: false } });
+            finish(invalidInput('notes-file is required'));
             return;
         }
         let resolvedNotesPath = notesPath;
@@ -35,11 +70,12 @@ function platformReleaseNotes(args = []) {
         }
         try {
             finish(publishReleaseNotes({
-                tag: option(rest, '--tag') || '',
-                title: option(rest, '--title') || option(rest, '--tag') || '',
+                tag: parsed.values.get('--tag') || '',
+                title: parsed.values.get('--title') || parsed.values.get('--tag') || '',
                 notesFile: resolvedNotesPath,
-                dryRun: rest.includes('--dry-run')
-            }, { cwd }));
+                expectedSha256: parsed.values.get('--expected-sha256') || '',
+                dryRun: parsed.switches.has('--dry-run')
+            }, { cwd: path.resolve(parsed.values.get('--cwd') || process.cwd()) }));
         }
         finally {
             if (notesPath === '-')
@@ -47,7 +83,7 @@ function platformReleaseNotes(args = []) {
         }
         return;
     }
-    finish({ status: 'failed', changed: false, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'Usage: platform-release-notes context|publish', retryable: false } });
+    finish(invalidInput('Usage: platform-release-notes context|stage|publish'));
 }
 export { platformReleaseNotes };
 //# sourceMappingURL=platform-release-notes.js.map

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

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { collectHostCandidates, decide, deriveTaskIssueMatches, extractClosingIssueNumbers, resolveHostFromCandidates } from '../pr-review/evidence-grading.js';
+import { inspectPlatformPullRequestByNumber } from '../platform/pull-requests.js';
+import { verifyInProcess } from '../task/verification-engine.js';
+const USAGE = `Usage: agent-infra-internal pr-review-grade decide --input-file <path|-> [--cwd <path>]
+       agent-infra-internal pr-review-grade resolve-host --pr <N> [--cwd <path>]
+       agent-infra-internal pr-review-grade verify-artifact --artifact-file <path> [--cwd <path>]
+`;
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PR_REVIEW_GRADE_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(result, exitCode = 0) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
+}
+function parseFlags(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!['--input-file', '--artifact-file', '--cwd', '--pr'].includes(flag)) {
+            return { values, error: `unknown option '${flag}'` };
+        }
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+    }
+    return { values };
+}
+function readInput(value, cwd) {
+    return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
+}
+function prReviewGrade(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['decide', 'resolve-host', 'verify-artifact'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const parsed = parseFlags(args, 1);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+    const allowed = {
+        decide: ['cwd', 'inputFile'],
+        'resolve-host': ['cwd', 'pr'],
+        'verify-artifact': ['cwd', 'artifactFile']
+    };
+    const unexpected = Object.keys(values).find((key) => !allowed[operation].includes(key));
+    if (unexpected) {
+        fail(`${operation} does not accept '--${unexpected}'`);
+        return;
+    }
+    if (operation === 'decide') {
+        if (typeof values.inputFile !== 'string') {
+            fail('decide requires --input-file');
+            return;
+        }
+        let input;
+        try {
+            input = JSON.parse(readInput(values.inputFile, cwd));
+        }
+        catch (error) {
+            fail(`unable to read decide input: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        try {
+            const record = decide(input);
+            finish(record);
+        }
+        catch (error) {
+            const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : 'DECIDE_FAILED';
+            finish({ status: 'failed', changed: false, error: { code, message: error instanceof Error ? error.message : String(error) } }, 1);
+        }
+        return;
+    }
+    if (operation === 'resolve-host') {
+        const pr = Number(values.pr);
+        if (!Number.isInteger(pr) || pr <= 0) {
+            fail('resolve-host requires a positive --pr');
+            return;
+        }
+        const inspected = inspectPlatformPullRequestByNumber(pr, { cwd });
+        if (!inspected.pullRequest) {
+            finish({
+                status: 'failed', changed: false, host: null, candidates: [], closingIssues: [],
+                error: inspected.error ?? { code: 'PR_INSPECTION_INVALID', message: 'unable to inspect the pull request', retryable: false }
+            }, inspected.status === 'blocked' ? 2 : 1);
+            return;
+        }
+        const closingIssues = extractClosingIssueNumbers(inspected.pullRequest.body);
+        const candidates = collectHostCandidates({ prNumber: pr, closingIssues, workspaceRoot: cwd });
+        const host = resolveHostFromCandidates(candidates);
+        finish({
+            status: 'ok', changed: false,
+            pr: { number: pr, baseSha: inspected.pullRequest.base.sha, headSha: inspected.pullRequest.head.sha, state: inspected.pullRequest.state },
+            closingIssues, candidates, host,
+            taskIssueMatches: deriveTaskIssueMatches(host, closingIssues), error: null
+        });
+        return;
+    }
+    if (typeof values.artifactFile !== 'string') {
+        fail('verify-artifact requires --artifact-file');
+        return;
+    }
+    const artifactPath = path.resolve(cwd, values.artifactFile);
+    let result;
+    try {
+        result = verifyInProcess({
+            mode: 'checks',
+            skillName: 'review-pr',
+            taskDir: path.dirname(artifactPath),
+            artifactFile: path.basename(artifactPath),
+            checks: ['artifact'],
+            repositoryRoot: cwd
+        });
+    }
+    catch (error) {
+        finish({ status: 'failed', changed: false, error: { code: 'VERIFY_ARTIFACT_INVALID', message: error instanceof Error ? error.message : String(error) } }, 1);
+        return;
+    }
+    const status = result.status;
+    finish(result, { pass: 0, fail: 1, blocked: 2 }[status]);
+}
+export { prReviewGrade };
+//# sourceMappingURL=pr-review-grade.js.map

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

@@ -139,9 +139,10 @@ function runOptionalDemo(cwd, run = command) {
     writeDigestAtomically(cwd, digest);
     return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
-function git(cwd, args, run = command) {
+function git(cwd, args, run = command, trim = true) {
     const result = run(cwd, 'git', args);
-    return result.status === 0 ? String(result.stdout).trim() : null;
+    const stdout = String(result.stdout);
+    return result.status === 0 ? (trim ? stdout.trim() : stdout) : null;
 }
 function inspectLocalReleaseFacts(cwd, version, run = command) {
     const tag = `v${version}`;
@@ -216,9 +217,15 @@ async function inspectFacts(cwd, version) {
         npm: npm.published, homebrew: homebrew.published, smoke
     };
 }
-function changedPaths(cwd) {
-    const output = git(cwd, ['status', '--porcelain=v1']) || '';
-    return output.split('\n').filter(Boolean).map((line) => line.slice(3)).filter((value, index, all) => all.indexOf(value) === index);
+function parsePorcelainPath(record) {
+    const match = /^.. (.+)$/.exec(record);
+    if (!match)
+        throw new Error('Invalid git status --porcelain=v1 record');
+    return match[1];
+}
+function changedPaths(cwd, run = command) {
+    const output = git(cwd, ['status', '--porcelain=v1'], run, false) || '';
+    return output.split(/\r?\n/).filter(Boolean).map(parsePorcelainPath).filter((value, index, all) => all.indexOf(value) === index);
 }
 function updateReleaseMetadata(cwd, version) {
     const [major = '0', minor = '0'] = version.split('.');
@@ -371,5 +378,5 @@ async function releaseWorkflow(args = []) {
     process.stdout.write(`${JSON.stringify({ ...pushed, demo, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`);
     process.exitCode = pushed.status === 'failed' ? 1 : pushed.status === 'degraded' ? 2 : 0;
 }
-export { computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

package/dist/lib/internal/sandbox-control.js

@@ -0,0 +1,24 @@
+import { requestSandboxControl } from '../sandbox/control/client.js';
+import { serveSandboxControl } from '../sandbox/control/server.js';
+function sandboxControl(args) {
+    const [operation, ...rest] = args;
+    if (operation === 'serve') {
+        const manifestIndex = rest.indexOf('--manifest');
+        const manifest = manifestIndex >= 0 ? rest[manifestIndex + 1] : undefined;
+        if (!manifest)
+            throw new Error('sandbox-control serve requires --manifest');
+        serveSandboxControl(manifest);
+        return;
+    }
+    if (operation === 'client') {
+        const [family = '', ...commandArgs] = rest;
+        const response = requestSandboxControl({ family, args: commandArgs });
+        process.stdout.write(response.stdout);
+        process.stderr.write(response.stderr);
+        process.exitCode = response.exitCode;
+        return;
+    }
+    throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | client <family> [args...]');
+}
+export { sandboxControl };
+//# sourceMappingURL=sandbox-control.js.map