@fitlab-ai/agent-infra 0.9.8 → 0.9.10

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

@@ -7,12 +7,12 @@ const USAGE = `Usage: agent-infra-internal platform-pr inspect <task-ref> [--cwd
        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>]
+       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|-> [--dry-run] [--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>]
 `;
 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']);
+const VALUE_FLAGS = new Set(['--cwd', '--agent', '--base', '--head', '--title-file', '--body-file', '--pr', '--result']);
 function key(flag) {
     return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
@@ -79,9 +79,9 @@ function platformPr(args = []) {
         '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'],
+        sync: ['cwd', 'agent', 'metadata', 'closingIssue', 'result', 'dryRun'],
         'summary-context': ['cwd'],
-        'summary-sync': ['cwd', 'agent', 'bodyFile', 'dryRun']
+        'summary-sync': ['cwd', 'agent', 'bodyFile', 'result', 'dryRun']
     };
     const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
     if (unexpected) {
@@ -106,6 +106,11 @@ function platformPr(args = []) {
         return;
     }
     values.agent = agent;
+    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');
+        return;
+    }
     if (operation === 'resolve-external') {
         const pr = values.pr === undefined ? undefined : Number(values.pr);
         if (pr !== undefined && (!Number.isInteger(pr) || pr <= 0)) {
@@ -129,7 +134,11 @@ function platformPr(args = []) {
             fail('sync requires --metadata or --closing-issue');
             return;
         }
-        finish(syncPlatformPullRequest(taskRef, { cwd, agent: values.agent, metadata: values.metadata === true, closingIssue: values.closingIssue === true, dryRun: values.dryRun === true }));
+        if (!primaryResult) {
+            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 }));
         return;
     }
     if (operation === 'summary-sync') {
@@ -137,8 +146,12 @@ function platformPr(args = []) {
             fail('summary-sync requires --body-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), dryRun: values.dryRun === true }));
+            finish(syncPullRequestSummary(taskRef, { cwd, agent: values.agent, body: readFile(values.bodyFile, cwd), primaryResult: primaryResult, dryRun: values.dryRun === true }));
         }
         catch (error) {
             fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);

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

@@ -10,12 +10,13 @@ import { releaseSnapshot } from '../release/workflow.js';
 function command(cwd, executable, args) {
     return spawnSync(executable, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
 }
+// The tape is the canonical init interaction contract. Do not hash all of
+// lib/init.ts: non-visual config serialization changes must not re-record it.
 const DEMO_INPUT_PATHS = [
     'assets/demo-init.tape',
     'scripts/demo-regen.sh',
     'scripts/normalize-gif-duration.py',
     'bin/cli.ts',
-    'lib/init.ts',
     'lib/log.ts',
     'lib/prompt.ts',
     'lib/paths.ts',

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

@@ -1,6 +1,70 @@
-import { requestSandboxControl, SandboxControlClientError } from '../sandbox/control/client.js';
+import { requestSandboxControl, requestSandboxTaskFinalization, requestSandboxTaskControl, SandboxControlClientError } from '../sandbox/control/client.js';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
+import { controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+function isCanonicalCodexPrepare(args) {
+    if (args[1] !== 'prepare')
+        return false;
+    const clients = [];
+    for (let index = 2; index < args.length; index += 1) {
+        if (args[index] === '--client')
+            clients.push(args[index + 1] ?? '');
+        else if (args[index]?.startsWith('--client='))
+            clients.push(args[index].slice('--client='.length));
+    }
+    return clients.length === 1 && clients[0] === 'codex';
+}
+function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null) {
+    process.stdout.write(`${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`);
+}
+function finalizationErrorStatus(error) {
+    if (error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
+        return 'unknown';
+    return error.retryable ? 'blocked' : 'failed';
+}
+function sandboxFinalizationClient(args) {
+    if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
+        const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'task ref, complete intent, and --agent are required', retryable: false };
+        writeFinalizationEnvelope('failed', false, error);
+        process.stderr.write('Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n');
+        process.exitCode = 1;
+        return;
+    }
+    const agent = normalizeAgentToken(args[3]);
+    if (!agent) {
+        const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: `invalid --agent: ${AGENT_USAGE_HINT}`, retryable: false };
+        writeFinalizationEnvelope('failed', false, error);
+        process.exitCode = 1;
+        return;
+    }
+    let response;
+    try {
+        response = requestSandboxTaskFinalization({ agent });
+    }
+    catch (error) {
+        if (!(error instanceof SandboxControlClientError))
+            throw error;
+        writeFinalizationEnvelope(finalizationErrorStatus(error.detail), error.accepted, error.detail);
+        process.stderr.write(`${error.detail.message}\n`);
+        process.exitCode = error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.detail.retryable ? 2 : 1;
+        return;
+    }
+    if (response.phase === 'rejected') {
+        const error = response.error ?? {
+            code: 'SANDBOX_CONTROL_REJECTED',
+            message: 'sandbox control rejected the finalization request',
+            retryable: false
+        };
+        writeFinalizationEnvelope(finalizationErrorStatus(error), error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error);
+        process.stderr.write(`${error.message}\n`);
+        process.exitCode = error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.retryable ? 2 : 1;
+        return;
+    }
+    process.stdout.write(response.stdout);
+    process.stderr.write(response.stderr);
+    process.exitCode = response.exitCode ?? 1;
+}
 async function sandboxControl(args) {
     const [operation, ...rest] = args;
     if (operation === 'serve') {
@@ -33,9 +97,22 @@ async function sandboxControl(args) {
     }
     if (operation === 'client') {
         const [family = '', ...commandArgs] = rest;
+        if (family === 'task-finalization') {
+            sandboxFinalizationClient(commandArgs);
+            return;
+        }
         let response;
         try {
-            response = requestSandboxControl({ family, args: commandArgs });
+            if (family === 'task-orchestration' && isCanonicalCodexPrepare(commandArgs)) {
+                const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+                const proof = contextPath
+                    ? controllerProofFromContext(verifyCodexSandboxControllerContextWithWarnings(contextPath).context)
+                    : null;
+                response = requestSandboxTaskControl({ family, args: commandArgs, controllerProof: proof });
+            }
+            else {
+                response = requestSandboxControl({ family, args: commandArgs });
+            }
         }
         catch (error) {
             if (!(error instanceof SandboxControlClientError))

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

@@ -0,0 +1,54 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { applyTaskFinalization } from '../task/finalization.js';
+import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
+import { verifyTaskEvent } from '../task/verification.js';
+const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
+function envelope(status, changed, accepted, result, error) {
+    return `${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`;
+}
+function exitCode(status) {
+    return status === 'completed' ? 0 : status === 'blocked' ? 2 : 1;
+}
+function fail(message) {
+    const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message, retryable: false };
+    process.stdout.write(envelope('failed', false, false, null, error));
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function taskFinalization(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
+        fail('task ref, complete intent, and --agent are required');
+        return;
+    }
+    const agent = normalizeAgentToken(args[3]);
+    if (!agent) {
+        fail(`invalid --agent: ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    let repoRoot;
+    try {
+        repoRoot = detectRepoRoot();
+    }
+    catch (error) {
+        const detail = { code: 'REPO_ROOT_NOT_FOUND', message: error instanceof Error ? error.message : String(error), retryable: false };
+        process.stdout.write(envelope('failed', false, true, null, detail));
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTaskRef(args[0], { repoRoot });
+    if (!resolved.ok) {
+        const detail = { code: resolved.code, message: resolved.message, retryable: false };
+        process.stdout.write(envelope('failed', false, true, null, detail));
+        process.exitCode = 1;
+        return;
+    }
+    const result = applyTaskFinalization({ taskRef: resolved.taskId, intent: 'complete', agent }, { repoRoot, preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options) });
+    process.stdout.write(envelope(result.status, result.changed, true, result, result.error));
+    process.exitCode = exitCode(result.status);
+}
+export { taskFinalization };
+//# sourceMappingURL=task-finalization.js.map