@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/dist/lib/internal/agent-client.js

@@ -3,10 +3,10 @@ import path from 'node:path';
 import { AgentClientConfigError, normalizeAgentClients } from '../agent-clients/config.js';
 import { normalizeCustomToolInvocations } from '../agent-clients/custom-tool-invocations.js';
 import { renderNextStepCommands } from '../agent-clients/next-steps.js';
-import { getAgentClientModelSelection } from '../agent-clients/registry.js';
+import { getAgentClientAdapter, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection> [options]\n';
+const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection|launch-carrier> [options]\n';
 function failure(code, message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -72,71 +72,113 @@ function parseArgs(args) {
         format
     };
 }
-function agentClient(args = []) {
-    if (!ensureInternalHandlerRoute('agent-client', args))
-        return;
-    if (internalHandlerRoute('agent-client', 'model-selection', args[0] ?? '')) {
-        const values = {};
-        const seen = new Set();
-        for (let index = 1; index < args.length; index += 1) {
-            const flag = args[index];
-            if (!['--client', '--format'].includes(flag) || seen.has(flag)) {
-                failure('AGENT_CLIENT_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
-                return;
-            }
-            const value = args[++index];
-            if (!value || value.startsWith('--')) {
-                failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
-                return;
-            }
-            seen.add(flag);
-            values[flag] = value;
+function parseLaunchCarrierArgs(args) {
+    const allowed = new Set(['--client', '--adapter-context', '--stage', '--round', '--role', '--format']);
+    const values = {};
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!allowed.has(flag) || seen.has(flag)) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
+            return null;
         }
-        const client = values['--client'];
-        const format = values['--format'] ?? 'text';
-        if (!isAgentClientId(client) || !['text', 'json'].includes(format)) {
-            failure('AGENT_CLIENT_PAYLOAD_INVALID', 'model-selection requires a known --client and text|json format');
-            return;
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
+            return null;
         }
-        const context = getAgentClientModelSelection(client);
-        if (format === 'json') {
-            process.stdout.write(`${JSON.stringify({
-                status: 'resolved', changed: false, client, context, error: null
-            })}\n`);
+        seen.add(flag);
+        values[flag] = value;
+    }
+    const round = Number(values['--round']);
+    if (!isAgentClientId(values['--client']) || !values['--adapter-context'] || !values['--stage'] || !values['--role']
+        || !Number.isSafeInteger(round) || round < 1 || (values['--format'] ?? 'json') !== 'json') {
+        failure('AGENT_CLIENT_PAYLOAD_INVALID', 'launch-carrier requires client, adapter context, stage, positive round, role, and json format');
+        return null;
+    }
+    return {
+        client: values['--client'],
+        adapterContext: values['--adapter-context'],
+        stage: values['--stage'],
+        round,
+        role: values['--role']
+    };
+}
+function launchCarrier(args) {
+    const parsed = parseLaunchCarrierArgs(args);
+    if (!parsed)
+        return;
+    const createCarrier = getAgentClientAdapter(parsed.client).orchestrationAdapter?.createLaunchCarrier;
+    if (!createCarrier) {
+        process.stdout.write(`${JSON.stringify({
+            status: 'failed', changed: false, client: parsed.client, carrier: null,
+            error: { code: 'AGENT_CLIENT_LAUNCH_CARRIER_UNSUPPORTED', message: `Agent Client '${parsed.client}' does not support lifecycle launch carriers` }
+        })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const carrier = createCarrier(parsed.adapterContext, { stage: parsed.stage, round: parsed.round, role: parsed.role });
+        process.stdout.write(`${JSON.stringify({ status: 'ready', changed: false, client: parsed.client, carrier, error: null })}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            status: 'failed', changed: false, client: parsed.client, carrier: null,
+            error: { code: error instanceof Error && error.name ? error.name : 'AGENT_CLIENT_LAUNCH_CARRIER_INVALID', message: error instanceof Error ? error.message : String(error) }
+        })}\n`);
+        process.exitCode = 1;
+    }
+}
+function modelSelection(args) {
+    const values = {};
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!['--client', '--format'].includes(flag) || seen.has(flag)) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
             return;
         }
-        if (context.kind === 'interactive-only') {
-            process.stdout.write(`Model selection: interactive-only\nCommand: ${context.command}\n${context.guidance}\n`);
-        }
-        else {
-            process.stdout.write(`Model selection: ${context.completeness} catalog\nSource: ${context.source}\n`);
-            for (const model of context.models) {
-                const efforts = model.reasoningEfforts?.length
-                    ? ` (${model.reasoningEfforts.join(', ')})`
-                    : '';
-                process.stdout.write(`- ${model.id}${efforts}\n`);
-            }
-            if (context.guidance)
-                process.stdout.write(`${context.guidance}\n`);
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
+            return;
         }
+        seen.add(flag);
+        values[flag] = value;
+    }
+    const client = values['--client'];
+    const format = values['--format'] ?? 'text';
+    if (!isAgentClientId(client) || !['text', 'json'].includes(format)) {
+        failure('AGENT_CLIENT_PAYLOAD_INVALID', 'model-selection requires a known --client and text|json format');
         return;
     }
-    const parsed = parseArgs(args);
-    if (!parsed || process.exitCode)
+    const context = getAgentClientModelSelection(client);
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({ status: 'resolved', changed: false, client, context, error: null })}\n`);
         return;
-    let config;
-    try {
-        const configPath = path.join(process.cwd(), '.agents', '.airc.json');
-        const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-            throw new Error('configuration root must be an object');
-        }
-        config = raw;
     }
-    catch (error) {
-        failure('AGENT_CLIENT_CONFIG_INVALID', String(error));
+    renderModelSelection(context);
+}
+function renderModelSelection(context) {
+    if (context.kind === 'interactive-only') {
+        process.stdout.write(`Model selection: interactive-only\nCommand: ${context.command}\n${context.guidance}\n`);
         return;
     }
+    process.stdout.write(`Model selection: ${context.completeness} catalog\nSource: ${context.source}\n`);
+    for (const model of context.models) {
+        const efforts = model.reasoningEfforts?.length ? ` (${model.reasoningEfforts.join(', ')})` : '';
+        process.stdout.write(`- ${model.id}${efforts}\n`);
+    }
+    if (context.guidance)
+        process.stdout.write(`${context.guidance}\n`);
+}
+function renderNextSteps(args) {
+    const parsed = parseArgs(args);
+    if (!parsed || process.exitCode)
+        return;
+    const config = readAgentClientConfig();
+    if (!config)
+        return;
     try {
         const clients = normalizeAgentClients(config);
         const custom = normalizeCustomToolInvocations(config);
@@ -148,22 +190,7 @@ function agentClient(args = []) {
             ...(parsed.taskRef ? { taskRef: parsed.taskRef } : {}),
             ...(parsed.version ? { version: parsed.version } : {})
         });
-        if (parsed.format === 'json') {
-            process.stdout.write(`${JSON.stringify({
-                status: 'rendered',
-                changed: false,
-                commands,
-                diagnostics: custom.diagnostics,
-                error: null
-            })}\n`);
-            return;
-        }
-        for (const command of commands) {
-            process.stdout.write(`  - ${command.displayName}: ${command.command}\n`);
-        }
-        for (const diagnostic of custom.diagnostics) {
-            process.stderr.write(`${diagnostic.code} at ${diagnostic.path}\n`);
-        }
+        writeNextStepOutput(parsed.format, commands, custom.diagnostics);
     }
     catch (error) {
         if (error instanceof AgentClientConfigError) {
@@ -173,5 +200,38 @@ function agentClient(args = []) {
         failure('AGENT_CLIENT_RENDER_INVALID', error instanceof Error ? error.message : String(error));
     }
 }
+function readAgentClientConfig() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(process.cwd(), '.agents', '.airc.json'), 'utf8'));
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            throw new Error('configuration root must be an object');
+        return raw;
+    }
+    catch (error) {
+        failure('AGENT_CLIENT_CONFIG_INVALID', String(error));
+        return null;
+    }
+}
+function writeNextStepOutput(format, commands, diagnostics) {
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({ status: 'rendered', changed: false, commands, diagnostics, error: null })}\n`);
+        return;
+    }
+    for (const command of commands)
+        process.stdout.write(`  - ${command.displayName}: ${command.command}\n`);
+    for (const diagnostic of diagnostics)
+        process.stderr.write(`${diagnostic.code} at ${diagnostic.path}\n`);
+}
+function agentClient(args = []) {
+    if (!ensureInternalHandlerRoute('agent-client', args))
+        return;
+    if (internalHandlerRoute('agent-client', 'launch-carrier', args[0] ?? '')) {
+        return launchCarrier(args);
+    }
+    if (internalHandlerRoute('agent-client', 'model-selection', args[0] ?? '')) {
+        return modelSelection(args);
+    }
+    renderNextSteps(args);
+}
 export { agentClient };
 //# sourceMappingURL=agent-client.js.map

package/dist/lib/internal/cli-route-inventory.js

@@ -33,8 +33,8 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'task-create': ['input'],
     'task-qualification': ['proposal', 'confirm', 'supersede', 'revoke'],
     'sandbox-control': ['serve', 'execute', 'recover', 'client'],
-    'agent-client': ['next-steps', 'model-selection'],
-    'codex-lifecycle': ['preflight', 'capability-arm', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
+    'agent-client': ['next-steps', 'model-selection', 'launch-carrier'],
+    'codex-lifecycle': ['preflight', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
     'codex-sandbox-controller': ['verify-context', 'run'],
     'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
     'task-delivery': ['deliver'],

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

@@ -1,18 +1,8 @@
-import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { recoverSandboxControl, requestSandboxControl, SandboxControlClientError } from '../sandbox/control/client.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.js';
-import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
-function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null, requestId = null) {
-    process.stdout.write(serializeTaskFinalizationEnvelope({ status, changed, accepted, requestId, result, error }));
-}
-function finalizationErrorStatus(error) {
-    if (error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
-        return 'unknown';
-    return error.retryable ? 'blocked' : 'failed';
-}
 function writeClientError(error) {
     process.stderr.write(`${error.detail.message}\n`);
     if (error.requestId)
@@ -31,72 +21,6 @@ function recoveredExitCode(response) {
     }
     return response.exitCode ?? 1;
 }
-function finalizationResponseOutput(response) {
-    try {
-        const value = JSON.parse(response.stdout);
-        if (value.version === 2
-            && value.status
-            && ['completed', 'failed', 'blocked', 'unknown'].includes(value.status)
-            && (typeof value.changed === 'boolean' || value.changed === null)) {
-            return serializeTaskFinalizationEnvelope({
-                status: value.status,
-                changed: value.changed,
-                accepted: true,
-                requestId: response.id,
-                result: value.result ?? null,
-                error: value.error ?? null
-            });
-        }
-    }
-    catch {
-        // Preserve non-envelope output for diagnostics from the executor.
-    }
-    return response.stdout;
-}
-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;
-        const status = finalizationErrorStatus(error.detail);
-        writeFinalizationEnvelope(status, error.accepted, error.detail, status === 'unknown' ? null : false, null, error.requestId);
-        writeClientError(error);
-        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
-        };
-        const status = finalizationErrorStatus(error);
-        writeFinalizationEnvelope(status, error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error, status === 'unknown' ? null : false, null, response.id);
-        process.stderr.write(`${error.message}\n`);
-        process.exitCode = error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.retryable ? 2 : 1;
-        return;
-    }
-    process.stdout.write(finalizationResponseOutput(response));
-    process.stderr.write(response.stderr);
-    process.exitCode = response.exitCode ?? 1;
-}
 async function sandboxControl(args) {
     if (!ensureInternalHandlerRoute('sandbox-control', args))
         return;
@@ -152,10 +76,6 @@ async function sandboxControl(args) {
     }
     if (internalHandlerRoute('sandbox-control', 'client', operation ?? '')) {
         const [family = '', ...commandArgs] = rest;
-        if (family === 'task-finalization') {
-            sandboxFinalizationClient(commandArgs);
-            return;
-        }
         let response;
         try {
             response = requestSandboxControl({ family, args: commandArgs });

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

@@ -1,9 +1,12 @@
+import path from 'node:path';
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { resolveSandboxControlTransport } from './task-operation-registry.js';
-import { requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
+import { quiesceSandboxControlForTaskCompletion } from '../sandbox/control/lifecycle.js';
+import { resolveTaskRuntimeRoot } from '../task/runtime-paths.js';
 import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
+import { verifyTaskEvent } from '../task/verification.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
 function envelope(status, changed, accepted, result, error, requestId = null) {
@@ -64,26 +67,30 @@ async function taskFinalization(args = []) {
     };
     const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
     if (transport.kind === 'sandbox-local') {
-        try {
-            const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
-            process.stdout.write(response.stdout);
-            process.stderr.write(response.stderr);
-            process.exitCode = response.exitCode ?? 1;
-            return;
-        }
-        catch (error) {
-            const clientError = error instanceof SandboxControlClientError ? error : null;
-            const detail = clientError
-                ? clientError.detail
-                : { code: 'SANDBOX_CONTROL_CLIENT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
-            const status = detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-                ? 'unknown'
-                : detail.retryable ? 'blocked' : 'failed';
-            const changed = status === 'unknown' ? null : false;
-            process.stdout.write(envelope(status, changed, clientError?.accepted ?? false, null, detail, clientError?.requestId ?? null));
-            process.exitCode = exitCode(status);
+        const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
+        const taskId = process.env.AGENT_INFRA_TASK_ID;
+        const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
+        const controlRootId = process.env.AGENT_INFRA_CONTROL_ROOT_ID;
+        if (!statusDir || !taskId || !generation || !controlRootId || taskId !== resolved.taskId) {
+            const detail = { code: 'TASK_CONTROL_TRANSPORT_INVALID', message: 'sandbox task control identity is incomplete', retryable: false };
+            process.stdout.write(envelope('failed', false, true, null, detail));
+            process.exitCode = 1;
             return;
         }
+        const result = await applyTaskFinalization(boundOperation.request, {
+            repoRoot,
+            beforeLifecycle: async (currentTaskId) => {
+                if (currentTaskId !== taskId)
+                    throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
+                await quiesceSandboxControlForTaskCompletion(path.join(resolveTaskRuntimeRoot(taskId, { repoRoot }), 'sandbox-control'), { taskId, generation, controlRootId, statusDir });
+            },
+            preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
+        });
+        const status = result.status === 'prepared' ? 'failed' : result.status;
+        process.stdout.write(envelope(status, result.changed, true, result, result.error
+            ?? (result.status === 'prepared' ? { code: 'TASK_FINALIZATION_PREPARATION_INCOMPLETE', message: 'finalization did not commit', retryable: true } : null)));
+        process.exitCode = exitCode(status);
+        return;
     }
     const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), boundOperation);
     if (result.status === 'prepared') {

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

@@ -2,7 +2,7 @@ import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTa
 import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\nrecover-started: --auto\n`;
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);

package/dist/lib/internal/task-operation-registry.js

@@ -19,8 +19,8 @@ function internalTaskRoutes() {
         descriptor('internal', 'sandbox-control', 'client', 'conditional', 'progress', 'delegated'),
         descriptor('internal', 'agent-client', 'next-steps', 'non-task', 'diagnostic', 'none'),
         descriptor('internal', 'agent-client', 'model-selection', 'non-task', 'diagnostic', 'none'),
+        descriptor('internal', 'agent-client', 'launch-carrier', 'non-task', 'diagnostic', 'none'),
         descriptor('internal', 'codex-lifecycle', 'preflight', 'non-task', 'diagnostic', 'none'),
-        descriptor('internal', 'codex-lifecycle', 'capability-arm', 'conditional', 'progress'),
         descriptor('internal', 'codex-lifecycle', 'hook-event', 'conditional', 'progress'),
         descriptor('internal', 'codex-lifecycle', 'resolve-start', 'conditional', 'progress'),
         descriptor('internal', 'codex-lifecycle', 'resolve-stop', 'conditional', 'progress'),

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

@@ -152,7 +152,7 @@ function inplaceValidation(config, target, options) {
     if (!row)
         throw new Error('SANDBOX_VALIDATION_CONTAINER_NOT_FOUND');
     const control = sandboxControlPaths({
-        base: config.controlBase, project: config.project,
+        base: config.controlBase, repoRoot: config.repoRoot, project: config.project,
         container: row.name, identity: target.workspace
     });
     const manifest = readSandboxControlManifest(control.manifestPath);

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

@@ -18,6 +18,32 @@ function boundedFailureDetail(result) {
         ? diagnostic
         : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;
 }
+function requestDiagnostics(args, request, attempt, errorMessage) {
+    if (process.env.AGENT_INFRA_GH_DIAGNOSTICS !== '1' && !/rate.?limit/iu.test(errorMessage))
+        return '';
+    const apiIndex = args.indexOf('api');
+    const endpoint = apiIndex < 0
+        ? args.slice(0, 2).filter((arg) => !arg.startsWith('-')).join(' ')
+        : args.slice(apiIndex + 1).find((arg) => !arg.startsWith('-') && !arg.includes('=')) || 'unknown';
+    const safeEndpoint = endpoint.startsWith('http')
+        ? (() => {
+            try {
+                const url = new URL(endpoint);
+                return `${url.host}${url.pathname}`;
+            }
+            catch {
+                return 'unknown';
+            }
+        })()
+        : endpoint.split('?')[0] || 'unknown';
+    const methodIndex = args.findIndex((arg) => arg === '-X' || arg === '--method');
+    const methodFromArgs = methodIndex >= 0 ? args[methodIndex + 1] : undefined;
+    const method = methodFromArgs || request.method || (safeEndpoint === 'graphql' ? 'POST' : 'GET');
+    const tokenEnvironment = ['GH_TOKEN', 'GITHUB_TOKEN', 'GH_ENTERPRISE_TOKEN', 'GITHUB_ENTERPRISE_TOKEN']
+        .filter((name) => Boolean(process.env[name]));
+    const configDirOverride = Boolean(process.env.GH_CONFIG_DIR);
+    return ` [gh-diagnostic endpoint=${safeEndpoint} method=${method} attempt=${attempt} tokenEnv=${tokenEnvironment.join(',') || 'none'} ghConfigDirOverride=${configDirOverride}]`;
+}
 function defaultRunner(args, options) {
     const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
     let prefix = [];
@@ -135,14 +161,18 @@ function createGitHubClient(options = {}) {
             if (result.status === 0)
                 return { ok: true, value: result.stdout };
             const error = classifyGitHubFailure(result);
+            const requestDetail = requestDiagnostics(args, request, attempt + 1, error.message);
+            const contextualError = requestDetail
+                ? { ...error, message: `${error.message}${requestDetail}` }
+                : error;
             if (!retryableMethod || !error.requestRetryable)
-                return { ok: false, error: clientError(error) };
+                return { ok: false, error: clientError(contextualError) };
             if (attempt >= delays.length) {
                 return {
                     ok: false,
                     error: error.code === 'NETWORK_TRANSIENT'
-                        ? { ...clientError(error), code: 'NETWORK_RETRY_EXHAUSTED', message: `${error.message} (retry exhausted)` }
-                        : clientError(error)
+                        ? { ...clientError(contextualError), code: 'NETWORK_RETRY_EXHAUSTED', message: `${contextualError.message} (retry exhausted)` }
+                        : clientError(contextualError)
                 };
             }
             sleep(delays[attempt]);

package/dist/lib/platform/issues.js

@@ -472,7 +472,8 @@ async function syncPlatformIssueImpl(taskRef, options) {
     let providerMetadata = null;
     let repositoryLabels = [];
     let milestones = [];
-    if (base.context.capabilities.triage && (options.status !== undefined || options.inLabels !== undefined || options.milestone !== undefined || options.issueType || options.fields)) {
+    if (base.context.capabilities.triage && (options.status !== undefined || options.inLabels !== undefined || options.milestone !== undefined
+        || (base.context.capabilities.push && (options.issueType || options.fields)))) {
         const metadata = base.provider.issues?.describeRepository
             ? await base.provider.issues.describeRepository({ context: providerOperationContext(base.loadedContext) })
             : unsupportedProviderOperation(base.provider, 'issues.describeRepository');
@@ -551,18 +552,29 @@ async function syncPlatformIssueImpl(taskRef, options) {
         }
     }
     if (options.issueType || options.fields) {
-        plan.operations.push(...(providerMetadata
-            ? planProviderMetadata(inspected.value, providerMetadata, base.frontmatter, options, base.context.capabilities)
-            : [{ name: 'issue-type', status: 'skipped', reasonCode: 'ISSUE_TYPES_UNSUPPORTED' }]));
+        plan.operations.push(...(!base.context.capabilities.push
+            ? [
+                ...(options.issueType ? [{ name: 'issue-type', status: 'skipped', reasonCode: 'PUSH_REQUIRED' }] : []),
+                ...(options.fields ? [{ name: 'fields', status: 'skipped', reasonCode: 'PUSH_REQUIRED' }] : [])
+            ]
+            : providerMetadata
+                ? planProviderMetadata(inspected.value, providerMetadata, base.frontmatter, options, base.context.capabilities)
+                : [{ name: 'issue-type', status: 'skipped', reasonCode: 'ISSUE_TYPES_UNSUPPORTED' }]));
     }
     const failure = plan.operations.find((operation) => operation.status === 'failed');
     if (failure)
         return result('failed', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: { code: failure.reasonCode || 'ISSUE_SYNC_FAILED', message: `Operation ${failure.name} failed`, retryable: false } });
     const planned = plan.operations.filter((operation) => operation.status === 'planned');
     if (options.dryRun)
-        return result(planned.length ? 'planned' : 'no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
+        return result(planned.length ? 'planned' : 'no-op', base.resolved.taskId, base.issueNumber, {
+            platform: base.context.platform, capabilities: base.context.capabilities,
+            issue: snapshot, operations: plan.operations, error: null
+        });
     if (planned.length === 0)
-        return result('no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
+        return result('no-op', base.resolved.taskId, base.issueNumber, {
+            platform: base.context.platform, capabilities: base.context.capabilities,
+            issue: snapshot, operations: plan.operations, error: null
+        });
     const payload = applyRestOperations(snapshot, planned);
     const updated = base.provider.issues?.update
         ? await base.provider.issues.update({ context: providerOperationContext(base.loadedContext), target: base.issueIdentity, currentLabels: snapshot.labels, patch: payload, mutation: { idempotencyKey: `issue:update:${base.resolved.taskId}` } })

package/dist/lib/runtime/agent-runtime.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-const CLIENT_NAMESPACE = /^[a-z][a-z0-9-]{0,31}$/u;
+import { resolveTaskRuntimeRoot } from '../task/runtime-paths.js';
 function runtimeError(code, message) {
     const error = new Error(`${code}: ${message}`);
     error.name = code;
@@ -9,16 +9,9 @@ function boundControlContext(env) {
     return [
         'AGENT_INFRA_CONTROL_TOKEN',
         'AGENT_INFRA_CONTROL_GENERATION',
-        'AGENT_INFRA_EXECUTOR_MANIFEST',
-        'AGENT_INFRA_CODEX_CONTROLLER_CONTEXT'
+        'AGENT_INFRA_EXECUTOR_MANIFEST'
     ].some((key) => typeof env[key] === 'string' && env[key].length > 0);
 }
-function clientNamespace(client) {
-    if (!CLIENT_NAMESPACE.test(client)) {
-        throw runtimeError('AGENT_INFRA_RUNTIME_CLIENT_INVALID', `invalid runtime client namespace '${client}'`);
-    }
-    return client;
-}
 export function resolveAgentRuntimeRoot(options = {}) {
     const env = options.env ?? process.env;
     const configured = env.AGENT_INFRA_RUNTIME_DIR;
@@ -28,29 +21,13 @@ export function resolveAgentRuntimeRoot(options = {}) {
         }
         return path.resolve(configured);
     }
+    const taskId = env.AGENT_INFRA_TASK_ID;
+    if (taskId) {
+        return resolveTaskRuntimeRoot(taskId, { repoRoot: options.repoRoot });
+    }
     if (boundControlContext(env)) {
         throw runtimeError('AGENT_INFRA_RUNTIME_DIR_REQUIRED', 'task-bound control context requires AGENT_INFRA_RUNTIME_DIR');
     }
     return path.join(path.resolve(options.repoRoot ?? process.cwd()), '.agents', 'workspace', '.runtime');
 }
-export function resolveAgentRuntimeStoreRoot(options = {}) {
-    const client = clientNamespace(options.client ?? 'codex');
-    if (options.explicitRoot)
-        return path.resolve(options.explicitRoot);
-    const env = options.env ?? process.env;
-    const runtimeRoot = resolveAgentRuntimeRoot({ repoRoot: options.repoRoot, env });
-    if (env.AGENT_INFRA_RUNTIME_DIR) {
-        if (!options.store) {
-            throw runtimeError('AGENT_INFRA_RUNTIME_STORE_INVALID', 'store kind is required for task-bound runtime');
-        }
-        return path.join(runtimeRoot, 'clients', client, options.store);
-    }
-    if (client === 'codex' && options.store) {
-        return path.join(runtimeRoot, `codex-${options.store}`);
-    }
-    if (!options.store) {
-        throw runtimeError('AGENT_INFRA_RUNTIME_STORE_INVALID', 'store kind is required');
-    }
-    return path.join(runtimeRoot, 'clients', client, options.store);
-}
 //# sourceMappingURL=agent-runtime.js.map

package/dist/lib/sandbox/commands/control-status.js

@@ -8,6 +8,7 @@ export function readSandboxControlStatusForRow(config, row) {
         : { mode: 'branch-only' };
     const control = sandboxControlPaths({
         base: config.controlBase,
+        repoRoot: config.repoRoot,
         project: config.project,
         container: row.name,
         identity