@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/dist/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.js

@@ -5,11 +5,11 @@ import os from 'node:os';
 import path from 'node:path';
 import semver from 'semver';
 import * as toml from 'smol-toml';
-import { requestSandboxControl } from '../../../sandbox/control/client.js';
+import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify, requestSandboxControl } from '../../../sandbox/control/client.js';
 import { readSandboxControlStatus } from '../../../sandbox/control/state.js';
-import { getProcessStartTime, isProcessAlive } from '../../../server/process-state.js';
+import { getProcessStartTime } from '../../../server/process-state.js';
 import { computeLifecycleBuildIdentity } from './build-identity.js';
-const CONTEXT_TTL_MS = 4 * 60 * 60 * 1_000;
+import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContext as verifyContextFile, writeCodexSandboxControllerContext } from './controller-context.js';
 function digestFiles(files) {
     const hash = crypto.createHash('sha256');
     for (const file of [...files].sort()) {
@@ -38,12 +38,39 @@ function controlFromEnvironment() {
     const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
     const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
     const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
-    if (!token || !generation || !channelDir || !statusDir) {
+    const runtimeDir = process.env.AGENT_INFRA_RUNTIME_DIR;
+    if (!token || !generation || !channelDir || !statusDir || !runtimeDir) {
         throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_MISSING');
     }
-    return { token, generation, channelDir, statusDir };
+    return { token, generation, channelDir, statusDir, runtimeDir };
+}
+function verifyRuntime(runtimeDir) {
+    let stat;
+    try {
+        stat = fs.lstatSync(runtimeDir);
+    }
+    catch {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+    }
+    const probe = path.join(runtimeDir, `.controller-${process.pid}-${crypto.randomUUID()}.probe`);
+    try {
+        fs.writeFileSync(probe, 'runtime-probe\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        if (fs.readFileSync(probe, 'utf8') !== 'runtime-probe\n') {
+            throw new Error('probe mismatch');
+        }
+    }
+    catch {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+    }
+    finally {
+        fs.rmSync(probe, { force: true });
+    }
 }
 function verifyControl(taskId, control) {
+    verifyRuntime(control.runtimeDir);
     let status = null;
     let lastError = null;
     for (let attempt = 0; attempt < 5; attempt += 1) {
@@ -81,6 +108,26 @@ function verifyControl(taskId, control) {
     if (payload.taskId !== taskId)
         throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
+function verifyCodexSandboxControllerContext(contextPath, options = {}) {
+    const control = options.control ?? controlFromEnvironment();
+    const context = verifyContextFile(contextPath, {
+        repoRoot: options.repoRoot,
+        now: options.now,
+        generation: control.generation,
+        probeProcess: options.probeProcess
+    });
+    const verified = (options.requestControllerVerify ?? requestCodexControllerVerify)({
+        controllerProof: controllerProofFromContext(context),
+        ...control,
+        timeoutMs: 30_000
+    });
+    if (verified.binding.taskId !== context.taskId
+        || verified.binding.controlGeneration !== context.controlGeneration
+        || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    return context;
+}
 function detectedCodexVersion() {
     const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
     const version = /codex-cli\s+(\d+\.\d+\.\d+)/u.exec(result.stdout ?? '')?.[1];
@@ -153,6 +200,7 @@ function isolatedEnvironment(home, shimDir, contextPath, taskId, control, provid
         AGENT_INFRA_CONTROL_GENERATION: control.generation,
         AGENT_INFRA_CONTROL_DIR: control.channelDir,
         AGENT_INFRA_CONTROL_STATUS_DIR: control.statusDir,
+        AGENT_INFRA_RUNTIME_DIR: control.runtimeDir,
         AGENT_INFRA_CODEX_CONTROLLER_CONTEXT: contextPath
     };
 }
@@ -163,7 +211,6 @@ function prepareCodexSandboxController(input, options = {}) {
     const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
     const sourceHome = path.resolve(options.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'));
     const control = options.control ?? controlFromEnvironment();
-    (options.verifyTaskBinding ?? verifyControl)(input.taskId, control);
     const version = (options.codexVersion ?? detectedCodexVersion)();
     if (!semver.gte(version, '0.147.0'))
         throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNSUPPORTED');
@@ -172,48 +219,36 @@ function prepareCodexSandboxController(input, options = {}) {
     fs.mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
     fs.chmodSync(runtimeRoot, 0o700);
     const key = crypto.createHash('sha256')
-        .update(`${input.taskId}\0${control.generation}`)
+        .update(`${process.pid}\0${control.generation}`)
         .digest('hex');
-    const leasePath = path.join(runtimeRoot, `${key}.lease.json`);
-    if (fs.existsSync(leasePath)) {
-        const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
-        if (Number.isSafeInteger(lease.pid) && typeof lease.startTime === 'number'
-            && getProcessStartTime(lease.pid) === lease.startTime) {
-            throw new Error('CODEX_SANDBOX_CONTROLLER_BUSY');
-        }
-        fs.unlinkSync(leasePath);
-    }
     const parentStartTime = getProcessStartTime(process.pid);
     if (!parentStartTime)
         throw new Error('CODEX_SANDBOX_CONTROLLER_PROCESS_IDENTITY_INVALID');
-    const instanceDigest = crypto.randomBytes(32).toString('hex');
-    fs.writeFileSync(leasePath, `${JSON.stringify({
-        version: 1,
-        pid: process.pid,
-        startTime: parentStartTime,
-        taskId: input.taskId,
-        generation: control.generation,
-        instanceDigest
-    })}\n`, { mode: 0o600, flag: 'wx' });
     const home = fs.mkdtempSync(path.join(runtimeRoot, `${key}-`));
     fs.chmodSync(home, 0o700);
     let cleaned = false;
+    let context = null;
     const cleanup = () => {
         if (cleaned)
             return;
         cleaned = true;
+        if (context) {
+            try {
+                (options.closeController ?? requestCodexControllerClose)({
+                    controllerProcess: context.controllerProcess,
+                    controllerProof: controllerProofFromContext(context),
+                    ...control,
+                    timeoutMs: 30_000
+                });
+            }
+            catch {
+                // The wrapper is exiting; dead-process recovery safely handles an unknown close result.
+            }
+        }
         const relative = path.relative(runtimeRoot, home);
         if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
             fs.rmSync(home, { recursive: true, force: true });
         }
-        try {
-            const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
-            if (lease.instanceDigest === instanceDigest)
-                fs.unlinkSync(leasePath);
-        }
-        catch {
-            // A missing or replaced lease is owned by another cleanup path.
-        }
     };
     try {
         const auth = path.join(sourceHome, 'auth.json');
@@ -235,22 +270,25 @@ function prepareCodexSandboxController(input, options = {}) {
             throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
         }
         const buildIdentity = computeLifecycleBuildIdentity(repoRoot);
-        const now = (options.now ?? Date.now)();
-        const context = Object.freeze({
-            version: 1,
-            taskId: input.taskId,
-            controlGeneration: control.generation,
-            controllerInstanceDigest: instanceDigest,
-            parentPid: process.pid,
-            parentStartTime,
-            issuedAt: now,
-            expiresAt: now + CONTEXT_TTL_MS,
-            buildIdentity,
+        const opened = (options.openController ?? requestCodexControllerOpen)({
+            controllerProcess: { pid: process.pid, startTime: parentStartTime },
+            ...control,
+            timeoutMs: 30_000
+        });
+        const taskId = opened.lease.taskId;
+        context = contextFromControllerLease(opened.lease, {
             hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex'),
             lifecycleProfilesHash: digestFiles([executor, reviewer])
         });
+        if (opened.lease.controlGeneration !== control.generation
+            || opened.lease.controllerProcess.pid !== process.pid
+            || opened.lease.controllerProcess.startTime !== parentStartTime
+            || JSON.stringify(opened.lease.buildIdentity) !== JSON.stringify(buildIdentity)) {
+            throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
+        }
+        (options.verifyTaskBinding ?? verifyControl)(taskId, control);
         const contextPath = path.join(home, 'controller-context.json');
-        fs.writeFileSync(contextPath, `${JSON.stringify(context, null, 2)}\n`, { mode: 0o600 });
+        writeCodexSandboxControllerContext(contextPath, context);
         const shimDir = path.join(home, 'bin');
         fs.mkdirSync(shimDir, { mode: 0o700 });
         const internalCli = path.resolve(process.argv[1] ?? path.join(repoRoot, 'bin', 'internal-cli.ts'));
@@ -264,7 +302,7 @@ function prepareCodexSandboxController(input, options = {}) {
             input.reviewerModel ? `--reviewer-model ${input.reviewerModel}` : '',
             input.reviewerReasoningEffort ? `--reviewer-reasoning-effort ${input.reviewerReasoningEffort}` : ''
         ].filter(Boolean).join(' ');
-        const prompt = `$run-task ${input.taskRef}${policy ? ` ${policy}` : ''}`;
+        const prompt = `$run-task ${taskId}${policy ? ` ${policy}` : ''}`;
         const args = Object.freeze([
             'exec',
             '--enable', 'hooks',
@@ -275,7 +313,7 @@ function prepareCodexSandboxController(input, options = {}) {
             '-C', repoRoot,
             prompt
         ]);
-        const env = isolatedEnvironment(home, shimDir, contextPath, input.taskId, control, providerEnvironment, options.environment ?? process.env);
+        const env = isolatedEnvironment(home, shimDir, contextPath, taskId, control, providerEnvironment, options.environment ?? process.env);
         return Object.freeze({
             command: 'codex',
             args,
@@ -291,27 +329,6 @@ function prepareCodexSandboxController(input, options = {}) {
         throw error;
     }
 }
-function verifyCodexSandboxControllerContext(contextPath, taskId, options = {}) {
-    const stat = fs.lstatSync(contextPath);
-    if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-    }
-    const context = JSON.parse(fs.readFileSync(contextPath, 'utf8'));
-    const generation = options.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
-    if (context.version !== 1
-        || context.taskId !== taskId
-        || context.controlGeneration !== generation
-        || context.expiresAt < (options.now ?? Date.now())
-        || getProcessStartTime(context.parentPid) !== context.parentStartTime
-        || !isProcessAlive(context.parentPid)) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-    }
-    const current = computeLifecycleBuildIdentity(options.repoRoot ?? process.cwd());
-    if (JSON.stringify(current) !== JSON.stringify(context.buildIdentity)) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-    }
-    return Object.freeze(context);
-}
 async function runCodexSandboxController(input, options = {}) {
     const prepared = prepareCodexSandboxController(input, options);
     try {
@@ -366,5 +383,5 @@ async function runCodexSandboxController(input, options = {}) {
         prepared.cleanup();
     }
 }
-export { prepareCodexSandboxController, runCodexSandboxController, verifyCodexSandboxControllerContext };
+export { prepareCodexSandboxController, runCodexSandboxController, verifyCodexSandboxControllerContext, controllerProofFromContext };
 //# sourceMappingURL=sandbox-controller.js.map

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

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent } from './evidence.js';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
 const LOCK_RETRY_MS = 10;
 const LOCK_TIMEOUT_MS = 1_000;
 const LOCK_STALE_MS = 30_000;
@@ -58,7 +59,7 @@ function writeRecord(file, record, expectedRevision) {
     }
 }
 function createCodexLifecycleStore(options) {
-    const root = options.root ?? path.join(process.cwd(), '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+    const root = options.root ?? resolveAgentRuntimeStoreRoot({ store: 'lifecycle' });
     const now = options.now ?? (() => new Date().toISOString());
     fs.mkdirSync(root, { recursive: true, mode: 0o700 });
     fs.chmodSync(root, 0o700);

package/dist/lib/decide.js

@@ -2,25 +2,44 @@ import { VERSION } from './version.js';
 import { parseTaskScope } from './task/command-options.js';
 import { applyHumanDecision } from './task/decision-intents.js';
 import { canonicalTimestamp } from './task/write.js';
+import { consumeHumanOverride, failureId } from './task/human-override.js';
+import { resolveTaskRef } from './task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from './task/task-execution-lock.js';
 function parseDecisionParts(parts) {
     const decision = [];
     let needsImplementation;
+    let overrideTicket;
+    let overrideTarget;
+    let overrideScope;
     for (let index = 0; index < parts.length; index += 1) {
-        if (parts[index] !== '--needs-implementation') {
-            decision.push(parts[index]);
-            continue;
+        const part = parts[index];
+        if (part === '--needs-implementation') {
+            if (needsImplementation !== undefined)
+                throw new Error("duplicate option '--needs-implementation'");
+            const value = parts[++index];
+            if (value !== 'true' && value !== 'false') {
+                throw new Error("--needs-implementation must be 'true' or 'false'");
+            }
+            needsImplementation = value === 'true';
         }
-        if (needsImplementation !== undefined)
-            throw new Error("duplicate option '--needs-implementation'");
-        const value = parts[++index];
-        if (value !== 'true' && value !== 'false') {
-            throw new Error("--needs-implementation must be 'true' or 'false'");
+        else if (part === '--override-ticket' || part === '--override-target' || part === '--override-scope') {
+            const value = parts[++index];
+            if (!value)
+                throw new Error(`${part} requires a value`);
+            if (part === '--override-ticket')
+                overrideTicket = value;
+            else if (part === '--override-target')
+                overrideTarget = value;
+            else
+                overrideScope = value;
+        }
+        else {
+            decision.push(parts[index]);
         }
-        needsImplementation = value === 'true';
     }
     if (decision.length === 0)
         throw new Error('decision content is required');
-    return { decision: decision.join(' '), needsImplementation };
+    return { decision: decision.join(' '), needsImplementation, overrideTicket, overrideTarget, overrideScope };
 }
 export async function decide(args, options = {}) {
     let scope;
@@ -79,19 +98,54 @@ export async function decide(args, options = {}) {
     try {
         const parsedDecision = parseDecisionParts(decisionParts);
         const now = (options.now ?? canonicalTimestamp)();
-        const result = applyHumanDecision({
+        const request = {
             taskRef, selector, decision: parsedDecision.decision,
             needsImplementation: parsedDecision.needsImplementation
-        }, {
+        };
+        const writeOptions = {
             repoRoot: options.repoRoot,
             metadataProvider: () => ({ timestamp: now, agentInfraVersion: options.version ?? VERSION })
-        });
+        };
+        const resolved = taskRef ? resolveTaskRef(taskRef, { repoRoot: options.repoRoot }) : null;
+        let result;
+        const execute = () => {
+            let current = applyHumanDecision(request, writeOptions);
+            if (current.status !== 'failed' || !parsedDecision.overrideTicket)
+                return current;
+            if (!parsedDecision.overrideTarget || !parsedDecision.overrideScope)
+                throw new Error('override ticket requires --override-target and --override-scope');
+            const consumed = consumeHumanOverride({
+                taskRef: resolved?.ok ? resolved.taskId : String(taskRef ?? ''),
+                ticketId: parsedDecision.overrideTicket,
+                failureId: failureId('decision-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
+                target: parsedDecision.overrideTarget,
+                scope: parsedDecision.overrideScope
+            }, {
+                ...writeOptions,
+                effectExecutor: (capability) => {
+                    const retried = applyHumanDecision(request, { ...writeOptions, manualOverride: capability });
+                    current = retried;
+                    return retried.status === 'failed' || retried.status === 'planned'
+                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no decision effect was committed' : `${retried.error?.code ?? 'DECISION_FAILED'}: ${retried.error?.message ?? 'manual decision effect failed'}` }
+                        : null;
+                }
+            });
+            if (consumed.status === 'failed')
+                throw new Error(consumed.error.message);
+            return current;
+        };
+        result = resolved?.ok
+            ? withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute)
+            : execute();
         if (result.error)
             throw new Error(result.error.message);
         return 0;
     }
     catch (error) {
-        process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+        const message = error instanceof TaskExecutionLockError
+            ? `${error.code}: ${error.message}`
+            : error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
         return 1;
     }
 }

package/dist/lib/git/workflow.js

@@ -124,7 +124,16 @@ function pushGitRefs(input, runner = defaultRunner) {
         }
         const canonical = ref.startsWith('refs/') ? ref : `refs/heads/${ref}`;
         const remoteFact = run(runner, input.cwd, ['ls-remote', '--exit-code', input.remote, canonical]);
-        operations.push({ name: 'push', ref, status: remoteFact.status === 0 ? 'applied' : 'failed', message: remoteFact.status === 0 ? undefined : 'Remote ref verification failed' });
+        const remoteSha = remoteFact.status === 0 ? remoteFact.stdout.trim().split(/\s+/)[0] ?? null : null;
+        const verified = remoteFact.status === 0 && (!input.expectedSha || remoteSha === input.expectedSha);
+        operations.push({
+            name: 'push',
+            ref,
+            status: verified ? 'applied' : 'failed',
+            message: verified ? undefined : input.expectedSha
+                ? `Remote ref verification failed: expected ${input.expectedSha}, received ${remoteSha ?? 'unavailable'}`
+                : 'Remote ref verification failed'
+        });
     }
     const failures = operations.filter((item) => item.status === 'failed').length;
     return { status: failures === 0 ? 'applied' : failures === operations.length ? 'failed' : 'degraded', changed: failures < operations.length, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations, error: failures ? { code: 'GIT_PUSH_PARTIAL', message: `${failures} ref push operation(s) failed` } : null };

package/dist/lib/init.js

@@ -180,7 +180,7 @@ async function cmdInit() {
         agentClients: serializeAgentClients(defaultState)
     };
     if (sandboxEngine)
-        config.sandbox.engine = sandboxEngine;
+        config.sandbox.engine = { [currentPlatform]: sandboxEngine };
     if (templateSources.length > 0)
         config.templates = { sources: templateSources };
     if (skillSources.length > 0)

package/dist/lib/internal/codex-lifecycle.js

@@ -8,6 +8,7 @@ import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-life
 import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { hasSealableOrchestrationDelegation } from '../task/orchestration.js';
 import { activateCodexOrchestrationDelegation, activateCodexSpawnDelegation, reconcileCodexOrchestrationDelegation, sealCodexOrchestrationDelegation, sealCodexParentDelegation } from '../task/codex-orchestration.js';
 const USAGE = 'Usage: agent-infra-internal codex-lifecycle <capability-arm|hook-event|resolve-start|resolve-stop|preflight|consume> [options]\n';
 const MANAGED_AGENT = /^agent-infra-lifecycle-(executor|reviewer)$/;
@@ -80,7 +81,7 @@ function controllerBinding(taskId) {
     const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
     if (!contextPath)
         return undefined;
-    const context = verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot: process.cwd() });
+    const context = verifyCodexSandboxControllerContext(contextPath, { repoRoot: process.cwd() });
     return {
         instanceDigest: context.controllerInstanceDigest,
         controlGeneration: context.controlGeneration
@@ -121,7 +122,8 @@ function recordFromPayload(phase, payload) {
             sessionId: text('sessionId'),
             turnId: text('turnId'),
             childThreadId: text('childThreadId'),
-            nativeAgent: text('nativeAgent')
+            nativeAgent: text('nativeAgent'),
+            source: 'hook'
         };
     if (phase === 'subagent-stop')
         return {
@@ -314,8 +316,17 @@ async function codexLifecycle(args = []) {
             }
             const result = store.apply(event);
             if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop') {
-                const bridged = await sealCodexOrchestrationDelegation(event.childThreadId, { store });
-                outputBridgeResult(bridged);
+                if (!hasSealableOrchestrationDelegation('codex', event.childThreadId, { repoRoot: process.cwd() })) {
+                    output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+                    return;
+                }
+                output({
+                    status: result.state.status,
+                    changed: true,
+                    evidence: result.state,
+                    diagnostics: [],
+                    error: result.state.error
+                });
                 return;
             }
             output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: [], error: result.state.error });
@@ -341,7 +352,10 @@ async function codexLifecycle(args = []) {
             return;
         }
         if (parsed.operation === 'resolve-stop') {
-            const terminal = await resolveCodexTerminal(childThreadId);
+            const stopTurnId = store.read(childThreadId).state.stop?.turnId;
+            if (!stopTurnId)
+                throw new Error('Codex lifecycle stop hook is not available');
+            const terminal = await resolveCodexTerminal(childThreadId, stopTurnId);
             const latest = store.apply(terminal);
             if (latest.state.status !== 'stop-ready') {
                 throw new Error(`Codex lifecycle stop evidence is not ready (status=${latest.state.status})`);

package/dist/lib/internal/codex-sandbox-controller.js

@@ -20,8 +20,6 @@ function parse(args) {
         return null;
     }
     const allowed = new Set([
-        '--task-id',
-        '--task-ref',
         '--context',
         '--executor-model',
         '--executor-reasoning-effort',
@@ -31,6 +29,11 @@ function parse(args) {
     const values = {};
     for (let index = 1; index < args.length; index += 1) {
         const flag = args[index];
+        if (flag === '--task-id' || flag.startsWith('--task-id=')
+            || flag === '--task-ref' || flag.startsWith('--task-ref=')) {
+            fail('CODEX_SANDBOX_CONTROLLER_IDENTITY_OPTION_UNSUPPORTED', 'controller task identity options are not supported', 2);
+            return null;
+        }
         const value = args[++index];
         if (!allowed.has(flag) || Object.hasOwn(values, flag) || !value || value.startsWith('--')) {
             fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', `invalid option '${flag}'`, 2);
@@ -44,18 +47,13 @@ async function codexSandboxController(args = []) {
     const parsed = parse(args);
     if (!parsed || process.exitCode)
         return;
-    const taskId = parsed.values['--task-id'];
-    if (!taskId) {
-        fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', '--task-id is required', 2);
-        return;
-    }
     try {
         if (parsed.operation === 'verify-context') {
             const contextPath = parsed.values['--context']
                 ?? process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
             if (!contextPath)
                 throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_MISSING');
-            const context = verifyCodexSandboxControllerContext(contextPath, taskId);
+            const context = verifyCodexSandboxControllerContext(contextPath);
             process.stdout.write(`${JSON.stringify({
                 status: 'ready',
                 changed: false,
@@ -72,9 +70,6 @@ async function codexSandboxController(args = []) {
             })}\n`);
             return;
         }
-        const taskRef = parsed.values['--task-ref'];
-        if (!taskRef)
-            throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_REF_REQUIRED');
         const policy = [
             '--executor-model',
             '--executor-reasoning-effort',
@@ -86,8 +81,6 @@ async function codexSandboxController(args = []) {
             throw new Error('CODEX_SANDBOX_CONTROLLER_MODEL_POLICY_INVALID');
         }
         const exitCode = await runCodexSandboxController({
-            taskId,
-            taskRef,
             executorModel: parsed.values['--executor-model'],
             executorReasoningEffort: parsed.values['--executor-reasoning-effort'],
             reviewerModel: parsed.values['--reviewer-model'],

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

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
-import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs, pushRebasedBranch } from '../git/workflow.js';
+import { inspectGitWorkflow, pushRebasedBranch } from '../git/workflow.js';
 import { compareReviewTrees, snapshotReview } from '../git/review-snapshot.js';
 import { resolvePostReviewGlobs } from '../task/review-fingerprint.js';
+import { executeCommitOperation } from '../task/commit-operation.js';
 function output(value) { process.stdout.write(`${JSON.stringify(value)}\n`); }
 function gitWorkflow(args = []) {
     const [action, ...rest] = args;
@@ -16,12 +17,9 @@ function gitWorkflow(args = []) {
     else if (action === 'commit') {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
-        result = input ? commitExplicitPaths({ cwd: cwd ?? process.cwd(), ...input }) : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
-    }
-    else if (action === 'push') {
-        const inputIndex = rest.indexOf('--input');
-        const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
-        result = input ? pushGitRefs({ cwd: cwd ?? process.cwd(), ...input }) : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
+        result = input
+            ? executeCommitOperation({ cwd: cwd ?? process.cwd(), ...input })
+            : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
     }
     else if (action === 'push-rebased') {
         const inputIndex = rest.indexOf('--input');

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,20 +10,19 @@ 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',
     'lib/render.ts',
     'lib/builtin-tuis.ts',
-    'lib/sandbox/engines/',
-    'src/sync-templates.js',
-    'templates/'
+    'lib/sandbox/engines/'
 ];
 const DEMO_DIGEST_PATH = 'assets/demo-init.inputs.sha256';
 const DEMO_OUTPUT_PATH = 'assets/demo-init.gif';