@fitlab-ai/agent-infra 0.9.5 → 0.9.7

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

@@ -154,11 +154,47 @@ function inspectLocalReleaseFacts(cwd, version, run = command) {
     const localTagConflict = Boolean(tagCommit && !localTag && !localTagAncestor);
     const postSubject = `chore: prepare next dev iteration after v${version}`;
     const postLog = localTag || localTagAncestor
-        ? git(cwd, ['log', '--format=%s', `${tag}..HEAD`], run) ?? ''
+        ? git(cwd, ['log', '--format=%H%x00%s', `${tag}..HEAD`], run) ?? ''
         : '';
-    const postCommit = postLog.split('\n').some((subject) => subject === postSubject);
+    const postCommit = postLog.split('\n').map((line) => line.split('\0'))
+        .find(([, subject]) => subject === postSubject)?.[0] ?? null;
     return { localTag, localTagAncestor, localTagConflict, postCommit };
 }
+function inspectPostReleaseFacts(cwd, commit, run = command) {
+    const inspected = inspectGitWorkflow(cwd);
+    const snapshot = inspected.snapshot;
+    const branch = snapshot?.branch ?? '';
+    const remoteLine = branch ? git(cwd, ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`], run) : null;
+    const remoteHead = remoteLine?.split(/\s+/)[0] ?? null;
+    const packageJson = commit ? git(cwd, ['show', `${commit}:package.json`], run, false) : null;
+    let newVersion = null;
+    if (packageJson) {
+        try {
+            const version = JSON.parse(packageJson).version;
+            newVersion = typeof version === 'string' ? version : null;
+        }
+        catch {
+            newVersion = null;
+        }
+    }
+    const paths = commit ? git(cwd, ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', commit], run, false) : null;
+    const changedPaths = paths ? paths.split('\0').filter(Boolean)
+        .sort((left, right) => Buffer.from(left).compare(Buffer.from(right))) : [];
+    const digest = commit ? git(cwd, ['show', `${commit}:${DEMO_DIGEST_PATH}`], run) : null;
+    return {
+        commit,
+        isHead: Boolean(commit && snapshot?.head === commit),
+        published: Boolean(commit && remoteHead === commit),
+        branch,
+        upstream: snapshot?.upstream ?? null,
+        remoteHead,
+        newVersion,
+        changedPaths,
+        demoInputSha256: digest && /^[0-9a-f]{64}$/.test(digest) ? digest : null,
+        worktree: snapshot?.worktree ?? [],
+        staged: snapshot?.staged ?? []
+    };
+}
 function releaseSmokeStatus(workflows, version, tagCommit) {
     const manualTitle = `Post-Release Smoke v${version}`;
     const targets = workflows.filter((run) => {
@@ -209,12 +245,15 @@ async function inspectFacts(cwd, version) {
     const workflows = platform.workflows;
     const smoke = releaseSmokeStatus(workflows, version, localTagTarget);
     return {
-        ...local,
+        localTag: local.localTag,
+        localTagAncestor: local.localTagAncestor,
+        localTagConflict: local.localTagConflict,
         remoteBranch: Boolean(remoteBranch && remoteBranch.split(/\s+/)[0] === head), remoteTag: Boolean(remoteTag),
         githubRelease: platform.platform.type !== 'github'
             ? true
             : platform.status === 'blocked' ? null : Boolean(platform.release?.published),
-        npm: npm.published, homebrew: homebrew.published, smoke
+        npm: npm.published, homebrew: homebrew.published, smoke,
+        post: inspectPostReleaseFacts(cwd, local.postCommit)
     };
 }
 function parsePorcelainPath(record) {
@@ -245,13 +284,21 @@ function updateReleaseMetadata(cwd, version) {
         fs.writeFileSync(filePath, content);
     }
 }
+function optionValues(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === name)
+            values.push(args[index + 1] ?? '');
+    }
+    return values;
+}
 async function releaseWorkflow(args = []) {
     const [action, rawVersion, ...rest] = args;
     const version = String(rawVersion || '').replace(/^v/, '');
     const cwdIndex = rest.indexOf('--cwd');
     const cwd = path.resolve(cwdIndex >= 0 && rest[cwdIndex + 1] ? rest[cwdIndex + 1] : process.cwd());
-    if (!['inspect', 'prepare', 'publish', 'post'].includes(action || '') || !semver.valid(version)) {
-        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'RELEASE_INPUT_INVALID', message: 'Usage: release-workflow inspect|prepare|publish|post <version>' } })}\n`);
+    if (!['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'].includes(action || '') || !semver.valid(version)) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'RELEASE_INPUT_INVALID', message: 'Usage: release-workflow inspect|prepare|publish|post-prepare|post-publish <version>' } })}\n`);
         process.exitCode = 1;
         return;
     }
@@ -331,10 +378,56 @@ async function releaseWorkflow(args = []) {
         process.exitCode = result.status === 'failed' ? 1 : result.status === 'degraded' ? 2 : 0;
         return;
     }
+    if (action === 'post-publish') {
+        const expectedValues = optionValues(rest, '--expected-sha256');
+        if (expectedValues.length !== 1 || !/^sha256:[0-9a-f]{64}$/.test(expectedValues[0])) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_INPUT_INVALID', message: 'post-publish requires one --expected-sha256 sha256:<64 hex>' } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        if (before.phase === 'complete') {
+            process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
+            return;
+        }
+        const confirmation = 'postConfirmation' in before ? before.postConfirmation : null;
+        if (before.phase !== 'post-prepared' || !confirmation) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: confirmation ? 'RELEASE_PHASE_INVALID' : 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Post-release facts cannot authorize publish' } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        if (confirmation.sha256 !== expectedValues[0]) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_POST_SNAPSHOT_MISMATCH', message: 'Post-release confirmation snapshot changed' } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const channelsComplete = before.facts.githubRelease === true && before.facts.npm === true && before.facts.homebrew === true;
+        if (!channelsComplete || before.facts.smoke !== 'success') {
+            process.stdout.write(`${JSON.stringify({ status: before.facts.smoke === 'failed' ? 'failed' : 'blocked', changed: false, snapshot: before, error: { code: 'RELEASE_CHANNELS_PENDING', message: 'Release channels or smoke workflow are not complete' } })}\n`);
+            process.exitCode = before.facts.smoke === 'failed' ? 1 : 2;
+            return;
+        }
+        const pushed = pushGitRefs({ cwd, remote: 'origin', refs: [before.facts.post.branch] });
+        const snapshot = releaseSnapshot(version, await inspectFacts(cwd, version));
+        if (snapshot.phase === 'complete') {
+            process.stdout.write(`${JSON.stringify({ ...pushed, status: 'applied', changed: true, snapshot, error: null })}\n`);
+            return;
+        }
+        const blocked = pushed.status !== 'failed';
+        process.stdout.write(`${JSON.stringify({ ...pushed, status: blocked ? 'blocked' : 'failed', snapshot, error: pushed.error ?? { code: 'RELEASE_PROGRESS_PENDING', message: 'Post-release push is not visible at the expected remote head' } })}\n`);
+        process.exitCode = blocked ? 2 : 1;
+        return;
+    }
     if (before.phase === 'complete') {
         process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
         return;
     }
+    if (before.phase === 'post-prepared') {
+        const confirmation = 'postConfirmation' in before ? before.postConfirmation : null;
+        const status = confirmation ? 'no-op' : 'blocked';
+        process.stdout.write(`${JSON.stringify({ status, changed: false, snapshot: before, error: confirmation ? null : { code: 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Post commit is not the clean current HEAD' } })}\n`);
+        process.exitCode = confirmation ? 0 : 2;
+        return;
+    }
     const channelsComplete = before.facts.githubRelease === true && before.facts.npm === true && before.facts.homebrew === true;
     if (!['published', 'post-pending'].includes(before.phase) || !channelsComplete || before.facts.smoke !== 'success') {
         process.stdout.write(`${JSON.stringify({ status: before.facts.smoke === 'failed' ? 'failed' : 'blocked', changed: false, snapshot: before, error: { code: 'RELEASE_CHANNELS_PENDING', message: 'Release channels or smoke workflow are not complete' } })}\n`);
@@ -373,10 +466,14 @@ async function releaseWorkflow(args = []) {
         process.exitCode = 1;
         return;
     }
-    const branch = git(cwd, ['branch', '--show-current']) || '';
-    const pushed = pushGitRefs({ cwd, remote: 'origin', refs: [branch] });
-    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;
+    const snapshot = releaseSnapshot(version, await inspectFacts(cwd, version));
+    const confirmation = 'postConfirmation' in snapshot ? snapshot.postConfirmation : null;
+    if (snapshot.phase !== 'post-prepared' || !confirmation) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: true, demo, snapshot, error: { code: 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Prepared post commit did not produce a confirmation snapshot' } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(`${JSON.stringify({ status: 'applied', changed: true, demo, snapshot, error: null })}\n`);
 }
-export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

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

@@ -1,24 +1,61 @@
-import { requestSandboxControl } from '../sandbox/control/client.js';
+import { requestSandboxControl, SandboxControlClientError } from '../sandbox/control/client.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
-function sandboxControl(args) {
+import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
+async 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);
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        process.once('SIGINT', abort);
+        process.once('SIGTERM', abort);
+        try {
+            await serveSandboxControl(manifest, controller.signal);
+        }
+        finally {
+            process.off('SIGINT', abort);
+            process.off('SIGTERM', abort);
+        }
+        return;
+    }
+    if (operation === 'execute') {
+        const requestIndex = rest.indexOf('--request');
+        const nonceIndex = rest.indexOf('--nonce');
+        const request = requestIndex >= 0 ? rest[requestIndex + 1] : undefined;
+        const nonce = nonceIndex >= 0 ? rest[nonceIndex + 1] : undefined;
+        if (!request || !nonce)
+            throw new Error('sandbox-control execute requires --request and --nonce');
+        await runSandboxControlExecutor(request, nonce);
         return;
     }
     if (operation === 'client') {
         const [family = '', ...commandArgs] = rest;
-        const response = requestSandboxControl({ family, args: commandArgs });
+        let response;
+        try {
+            response = requestSandboxControl({ family, args: commandArgs });
+        }
+        catch (error) {
+            if (!(error instanceof SandboxControlClientError))
+                throw error;
+            process.stderr.write(`${error.detail.message}\n`);
+            process.exitCode = error.detail.retryable ? 75 : 1;
+            return;
+        }
         process.stdout.write(response.stdout);
         process.stderr.write(response.stderr);
-        process.exitCode = response.exitCode;
+        if (response.phase === 'rejected') {
+            process.stderr.write(response.error?.message ?? response.stderr);
+            process.exitCode = response.error?.retryable ? 75 : 1;
+        }
+        else {
+            process.exitCode = response.exitCode ?? 1;
+        }
         return;
     }
-    throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | client <family> [args...]');
+    throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | execute --request <path> --nonce <nonce> | client <family> [args...]');
 }
 export { sandboxControl };
 //# sourceMappingURL=sandbox-control.js.map

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

@@ -1,13 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { requestSandboxTaskCreate } from '../sandbox/control/client.js';
+import { requestSandboxTaskCreate, SandboxControlClientError } from '../sandbox/control/client.js';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.js';
 import { validateTaskCreateCandidate } from '../task/create.js';
 import { createTask } from '../task/create-service.js';
-function failed(code, message) {
+function failed(code, message, retryable = false) {
     return {
-        status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
-        operations: [], warnings: [], error: { code, message, retryable: false }
+        status: retryable ? 'blocked' : 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+        operations: [], warnings: [], error: { code, message, retryable }
     };
 }
 function output(result) {
@@ -31,6 +31,10 @@ function taskCreate(args) {
         const candidate = validateTaskCreateCandidate(JSON.parse(fs.readFileSync(inputPath, 'utf8')));
         if (process.env.AGENT_INFRA_CONTROL_TOKEN) {
             const response = requestSandboxTaskCreate({ candidate });
+            if (response.phase === 'rejected') {
+                output(failed(response.error?.code ?? 'SANDBOX_CONTROL_REJECTED', response.error?.message ?? response.stderr, response.error?.retryable ?? false));
+                return;
+            }
             process.stdout.write(response.stdout);
             process.stderr.write(response.stderr);
             process.exitCode = response.exitCode;
@@ -39,6 +43,10 @@ function taskCreate(args) {
         output(createTask(candidate, { repoRoot: process.cwd() }));
     }
     catch (error) {
+        if (error instanceof SandboxControlClientError) {
+            output(failed(error.detail.code, error.detail.message, error.detail.retryable));
+            return;
+        }
         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));

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

@@ -1,7 +1,8 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, prepareOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
+import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, dispatchOrchestrationDelegation, pauseOrchestration, recoverCommitIntent, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
+import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -10,7 +11,7 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 2;
 }
-function taskOrchestration(args = []) {
+async function taskOrchestration(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -21,7 +22,8 @@ function taskOrchestration(args = []) {
     }
     const [taskRef, intent] = args;
     if (![
-        'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
+        'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
+        'hook-start', 'hook-stop', 'advance', 'pause', 'status',
         'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
@@ -44,7 +46,9 @@ function taskOrchestration(args = []) {
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
-            '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
+            '--client', '--requested-model', '--requested-reasoning-effort', '--capability-token',
+            '--parent-id', '--before-fingerprint',
+            '--stage', '--round', '--artifact', '--role',
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
             '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
@@ -260,12 +264,41 @@ function taskOrchestration(args = []) {
             usageFailure(`intent 'prepare' requires '${missing}'`);
             return;
         }
-        result = prepareOrchestrationDelegation(taskRef, {
+        result = await prepareCodexOrchestrationDelegation(taskRef, {
             client: values['--client'],
             requestedModel: values['--requested-model'],
-            requestedReasoningEffort: values['--requested-reasoning-effort']
+            requestedReasoningEffort: values['--requested-reasoning-effort'],
+            capabilityToken: values['--capability-token']
+        }, { orchestrationOptions: coreOptions });
+    }
+    else if (intent === 'dispatch') {
+        result = dispatchOrchestrationDelegation(taskRef, coreOptions);
+    }
+    else if (intent === 'await-activation') {
+        const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
+        if (missing) {
+            usageFailure(`intent 'await-activation' requires '${missing}'`);
+            return;
+        }
+        const round = Number(values['--round']);
+        if (!Number.isSafeInteger(round) || round < 1) {
+            usageFailure('--round must be a positive integer');
+            return;
+        }
+        if (!['executor', 'reviewer'].includes(values['--role'])) {
+            usageFailure('--role must be executor or reviewer');
+            return;
+        }
+        result = await awaitOrchestrationDelegationActivation(taskRef, {
+            stage: values['--stage'],
+            round,
+            artifact: values['--artifact'],
+            role: values['--role']
         }, coreOptions);
     }
+    else if (intent === 'recover-prepared') {
+        result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
+    }
     else if (intent === 'hook-start') {
         const missing = requireValues([
             ...(taskRef === 'auto' ? ['--client'] : []),

package/dist/lib/platform/context.js

@@ -5,6 +5,7 @@ import semver from 'semver';
 import { getPlatformAdapter, registerPlatformAdapter } from './adapters.js';
 import { createGitHubClient, MINIMUM_GITHUB_CLI_VERSION } from './github-client.js';
 import { platformResult } from './types.js';
+const CURRENT_USER_QUERY = 'query { viewer { login } }';
 function findRepoRoot(cwd) {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -89,18 +90,19 @@ function resolveGitHubContext(options) {
             error: { code: 'UPSTREAM_UNRESOLVED', message: 'Unable to resolve the upstream repository', retryable: false }
         });
     }
-    const user = client.json(['api', 'user'], { cwd });
+    const user = client.json(['api', 'graphql', '-f', `query=${CURRENT_USER_QUERY}`], { cwd });
     if (!user.ok)
         return failure(user.error, upstream);
     const userValue = user.value;
+    const currentUser = userValue?.data?.viewer?.login || null;
     const permissions = client.json(['api', `repos/${upstream}`], { cwd });
     if (!permissions.ok)
         return failure(permissions.error, upstream);
     const permissionValue = permissions.value;
     const values = permissionValue?.permissions || {};
     const capabilities = {
-        authenticated: Boolean(userValue?.login),
-        comment: Boolean(userValue?.login),
+        authenticated: Boolean(currentUser),
+        comment: Boolean(currentUser),
         triage: Boolean(values.triage || values.push || values.admin),
         push: Boolean(values.push || values.admin),
         admin: Boolean(values.admin)
@@ -108,7 +110,7 @@ function resolveGitHubContext(options) {
     const status = Object.values(capabilities).every(Boolean) ? 'no-op' : 'degraded';
     return platformResult(status, {
         changed: false,
-        platform: { type: platform, repository: upstream, currentUser: userValue?.login || null },
+        platform: { type: platform, repository: upstream, currentUser },
         resource: { kind: 'repository', number: null },
         capabilities,
         operations: [{ name: 'resolve', status: 'no-op', reasonCode: null }]

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

@@ -1,7 +1,9 @@
 import process from 'node:process';
 import spawn from 'cross-spawn';
 import semver from 'semver';
-const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+// closingIssuesReferences (introduced in gh 2.72.0) is the highest-versioned gh feature
+// the platform layer depends on; see github-release-notes.ts:102.
+const MINIMUM_GITHUB_CLI_VERSION = '2.72.0';
 const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
 const ERROR_DETAIL_LIMIT = 4096;
 function boundedFailureDetail(result) {
@@ -76,6 +78,41 @@ function classifyGitHubFailure(result) {
     }
     return { code: 'PLATFORM_REQUEST_FAILED', message: detail || 'GitHub request failed', retryable: false };
 }
+function responseUrl(args) {
+    const endpoint = args.find((arg, index) => index > 0 && !arg.startsWith('-')) || '';
+    return endpoint.startsWith('http') ? endpoint : `https://api.github.com/${endpoint.replace(/^\//, '')}`;
+}
+function parseIncludedResponse(stdout, args) {
+    const statusBlocks = [...stdout.matchAll(/^HTTP\/[^\r\n]+/gim)];
+    const headerStart = statusBlocks.at(-1)?.index;
+    if (headerStart === undefined)
+        return null;
+    const response = stdout.slice(headerStart);
+    const separator = response.match(/\r?\n\r?\n/);
+    if (!separator || separator.index === undefined)
+        return null;
+    const header = response.slice(0, separator.index);
+    const body = response.slice(separator.index + separator[0].length);
+    const status = header.match(/^HTTP\/[^ ]+\s+(\d{3})/mi)?.[1];
+    if (!status)
+        return null;
+    const date = header.match(/^Date:\s*(.+)$/mi)?.[1]?.trim();
+    const links = [...header.matchAll(/^Link:\s*(.+)$/gim)].flatMap((match) => match[1].split(',').map((value) => value.trim()));
+    try {
+        return {
+            value: JSON.parse(body || 'null'),
+            metadata: {
+                status: Number(status),
+                requestUrl: responseUrl(args),
+                ...(date ? { date } : {}),
+                links
+            }
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function createGitHubClient(options = {}) {
     const runner = options.runner || defaultRunner;
     const delays = options.retryDelaysMs || retryDelaysFromEnvironment();
@@ -134,8 +171,24 @@ function createGitHubClient(options = {}) {
                     error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub returned invalid JSON', retryable: true }
                 };
             }
+        },
+        jsonWithMetadata(args, request = {}) {
+            const includeArgs = args[0] === 'api' && args[1] !== '--include'
+                ? [args[0], '--include', ...args.slice(1)]
+                : args;
+            const result = run(includeArgs, request);
+            if (!result.ok)
+                return result;
+            const parsed = parseIncludedResponse(result.value, args);
+            if (!parsed) {
+                return {
+                    ok: false,
+                    error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub response metadata or JSON is invalid', retryable: true }
+                };
+            }
+            return { ok: true, value: parsed };
         }
     };
 }
-export { classifyGitHubFailure, createGitHubClient, MINIMUM_GITHUB_CLI_VERSION };
+export { classifyGitHubFailure, createGitHubClient, MINIMUM_GITHUB_CLI_VERSION, parseIncludedResponse };
 //# sourceMappingURL=github-client.js.map

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

@@ -20,6 +20,7 @@ const ARTIFACT_TITLES = {
     code: '实现报告',
     'review-code': '代码审查',
     'manual-validation': '人工验证报告',
+    'validation-run': '验证运行证据',
     'pr-review': 'PR 审查报告'
 };
 function normalizeCommentContent(content) {
@@ -52,7 +53,7 @@ function renderTaskComment(content, taskId, agent) {
 }
 function artifactIdentity(artifact) {
     const stem = path.basename(artifact, '.md');
-    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|pr-review)(?:-r(\d+))?$/);
+    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r(\d+))?$/);
     if (!match)
         throw new Error(`unsupported artifact '${artifact}'`);
     const base = ARTIFACT_TITLES[match[1]];