@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/dist/lib/agent-clients/adapters/opencode.js

@@ -1,5 +1,6 @@
 import { defineAgentClientAdapter } from '../adapter.js';
 import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+import { opencodeBeforeContainerCreateHook, opencodeRecoveryChecks } from './opencode-sandbox.js';
 const YOLO_PERMISSION = '{"*":"allow","read":"allow","bash":"allow","edit":"allow","webfetch":"allow","external_directory":"allow","doom_loop":"allow"}';
 const opencodeAdapter = defineAgentClientAdapter({
     id: 'opencode',
@@ -15,6 +16,15 @@ const opencodeAdapter = defineAgentClientAdapter({
         sandbox: { level: 'integrated' },
         verification: { level: 'compatible' }
     },
+    modelSelection: {
+        kind: 'interactive-only',
+        command: '/models',
+        guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
+    },
+    delegationEvidence: {
+        actualModel: 'unavailable',
+        actualReasoningEffort: 'unavailable'
+    },
     project: {
         ownedPathPrefixes: ['.opencode/'],
         managed: ['.opencode/commands/'],
@@ -26,9 +36,17 @@ const opencodeAdapter = defineAgentClientAdapter({
                     'zh-CN': '.opencode/commands/update-agent-infra.zh-CN.md'
                 },
                 target: '.opencode/commands/update-agent-infra.md'
-            }]
+            }],
+        customCommand: {
+            target: '.opencode/commands/${skillName}.md',
+            frontmatter: { agent: 'general', subtask: false },
+            argumentsToken: '$ARGUMENTS'
+        }
     },
     sandbox: {
+        image: {
+            dotfilesExclusions: ['.config/opencode']
+        },
         createTool: ({ home }) => ({
             id: 'opencode',
             name: 'OpenCode',
@@ -38,7 +56,9 @@ const opencodeAdapter = defineAgentClientAdapter({
             versionCmd: 'opencode --version',
             setupHint: 'Configure OpenCode credentials inside the container before first use.',
             envVars: {
-                OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json'
+                XDG_DATA_HOME: '/home/devuser/.local/share',
+                XDG_CONFIG_HOME: '/home/devuser/.local/share/opencode/.xdg/config',
+                XDG_STATE_HOME: '/home/devuser/.local/share/opencode/.xdg/state'
             },
             hostLiveMounts: [
                 {
@@ -57,7 +77,8 @@ const opencodeAdapter = defineAgentClientAdapter({
                 command: `OPENCODE_PERMISSION='${YOLO_PERMISSION}' opencode; tput ed`
             }
         ],
-        hooks: []
+        hooks: [opencodeBeforeContainerCreateHook],
+        recoveryChecks: opencodeRecoveryChecks
     }
 });
 export { opencodeAdapter };

package/dist/lib/agent-clients/adapters/runtimes/claude-code.dockerfile

@@ -0,0 +1,65 @@
+RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/cc-token-status
+#!/bin/sh
+set -eu
+
+SETTINGS_FILE="/home/devuser/.claude/settings.json"
+if [ -r "$SETTINGS_FILE" ] && jq -e '
+  def has_nonempty($v):
+    if ($v | type) == "string" then ($v | gsub("^\\s+|\\s+$"; "") | length) > 0 else false end;
+  (if type == "object" then . else {} end) as $settings
+  | (if ($settings.env | type) == "object" then $settings.env else {} end) as $env
+  | has_nonempty($env.ANTHROPIC_AUTH_TOKEN)
+    or has_nonempty($env.ANTHROPIC_API_KEY)
+    or has_nonempty($settings.apiKeyHelper)
+' "$SETTINGS_FILE" >/dev/null 2>&1; then
+  exit 0
+fi
+
+CRED_FILE="/home/devuser/.claude/.credentials.json"
+[ -r "$CRED_FILE" ] || exit 0
+
+EXPIRES_MS=$(jq -r '(.claudeAiOauth.expiresAt // .expiresAt) // empty' "$CRED_FILE" 2>/dev/null || true)
+case "$EXPIRES_MS" in
+  ''|*[!0-9]*) exit 0 ;;
+esac
+
+NOW_MS=$(($(date +%s) * 1000))
+DIFF_MS=$((EXPIRES_MS - NOW_MS))
+DIFF_S=$((DIFF_MS / 1000))
+
+DIM='#[fg=colour245]'
+YELLOW='#[fg=yellow]'
+YELLOW_BOLD='#[fg=yellow,bold]'
+RED_BOLD='#[fg=red,bold]'
+RED_REV='#[fg=red,reverse]'
+RESET='#[default]'
+
+if [ "$DIFF_S" -le 0 ]; then
+  ELAPSED=$(( -DIFF_S ))
+  M=$((ELAPSED / 60))
+  printf '%sClaude Code auth EXPIRED %dm ago%s' "$RED_REV" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 60 ]; then
+  printf '%sClaude Code auth expires in %ds%s' "$RED_BOLD" "$DIFF_S" "$RESET"
+elif [ "$DIFF_S" -lt 300 ]; then
+  M=$((DIFF_S / 60))
+  S=$((DIFF_S % 60))
+  printf '%sClaude Code auth expires in %dm %ds%s' "$RED_BOLD" "$M" "$S" "$RESET"
+elif [ "$DIFF_S" -lt 1800 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW_BOLD" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 3600 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW" "$M" "$RESET"
+else
+  TOTAL_M=$((DIFF_S / 60))
+  H=$((TOTAL_M / 60))
+  M=$((TOTAL_M % 60))
+  printf '%sClaude Code auth expires in %dh %dm%s' "$DIM" "$H" "$M" "$RESET"
+fi
+SCRIPT
+
+RUN test -s /usr/local/bin/cc-token-status && test -x /usr/local/bin/cc-token-status
+
+RUN printf '%s\n' \
+      "set -g status-right '#(/usr/local/bin/cc-token-status) | %H:%M'" \
+    >> /etc/tmux.conf

package/dist/lib/agent-clients/config.js

@@ -20,6 +20,37 @@ function isRecord(value) {
 function fail(code, path) {
     throw new AgentClientConfigError({ code, path });
 }
+function parseExactText(value, path) {
+    if (typeof value !== 'string' || value.length === 0 || value.trim() !== value) {
+        fail('INVALID_AGENT_CLIENTS', path);
+    }
+    return value;
+}
+function parseOrchestrationPolicy(value, path) {
+    if (!isRecord(value))
+        fail('INVALID_AGENT_CLIENTS', path);
+    const keys = Object.keys(value);
+    if (keys.length !== 2
+        || !hasOwn(value, 'executor')
+        || !hasOwn(value, 'reviewer')) {
+        fail('INVALID_AGENT_CLIENTS', path);
+    }
+    const parseRole = (candidate, rolePath) => {
+        if (!isRecord(candidate)
+            || Object.keys(candidate).length !== 2
+            || !hasOwn(candidate, 'model')
+            || !hasOwn(candidate, 'reasoningEffort')) {
+            fail('INVALID_AGENT_CLIENTS', rolePath);
+        }
+        return Object.freeze({
+            model: parseExactText(candidate.model, `${rolePath}.model`),
+            reasoningEffort: parseExactText(candidate.reasoningEffort, `${rolePath}.reasoningEffort`)
+        });
+    };
+    const executor = parseRole(value.executor, `${path}.executor`);
+    const reviewer = parseRole(value.reviewer, `${path}.reviewer`);
+    return Object.freeze({ executor, reviewer });
+}
 function parseCanonical(value) {
     if (!Array.isArray(value))
         fail('INVALID_AGENT_CLIENTS', 'agentClients');
@@ -29,10 +60,11 @@ function parseCanonical(value) {
         if (!isRecord(candidate))
             fail('INVALID_AGENT_CLIENTS', path);
         const keys = Object.keys(candidate);
-        if (keys.length !== 3
+        if ((keys.length !== 3 && keys.length !== 4)
             || !hasOwn(candidate, 'id')
             || !hasOwn(candidate, 'enabled')
-            || !hasOwn(candidate, 'installInSandbox')) {
+            || !hasOwn(candidate, 'installInSandbox')
+            || (keys.length === 4 && !hasOwn(candidate, 'orchestration'))) {
             fail('INVALID_AGENT_CLIENTS', path);
         }
         if (!isAgentClientId(candidate.id)) {
@@ -47,7 +79,10 @@ function parseCanonical(value) {
         }
         entries.set(candidate.id, {
             enabled: candidate.enabled,
-            installInSandbox: candidate.installInSandbox
+            installInSandbox: candidate.installInSandbox,
+            ...(hasOwn(candidate, 'orchestration')
+                ? { orchestration: parseOrchestrationPolicy(candidate.orchestration, `${path}.orchestration`) }
+                : {})
         });
     }
     for (const id of AGENT_CLIENT_IDS) {
@@ -60,7 +95,10 @@ function serializeAgentClients(state) {
     return AGENT_CLIENT_IDS.map((id) => ({
         id,
         enabled: state[id].enabled,
-        installInSandbox: state[id].installInSandbox
+        installInSandbox: state[id].installInSandbox,
+        ...(state[id].orchestration
+            ? { orchestration: structuredClone(state[id].orchestration) }
+            : {})
     }));
 }
 function projectLegacyTuis(value, diagnostics) {

package/dist/lib/agent-clients/next-steps.js

@@ -1,5 +1,6 @@
 import { listEnabledAgentClientAdapters } from './registry.js';
 import { renderAgentClientInvocation } from './invocation.js';
+import semver from 'semver';
 const SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 const SAFE_TASK_REF = /^(?:\d+|TASK-\d{8}-\d{6})$/;
 function requireSafeName(value, field) {
@@ -13,6 +14,14 @@ function renderNextStepCommands(input) {
     if (input.taskRef !== undefined && !SAFE_TASK_REF.test(input.taskRef)) {
         throw new Error('Invalid task ref');
     }
+    if (input.version !== undefined
+        && (!/^[0-9]/.test(input.version) || semver.valid(input.version) !== input.version)) {
+        throw new Error('Invalid version');
+    }
+    const args = [
+        ...(input.taskRef === undefined ? [] : [input.taskRef]),
+        ...(input.version === undefined ? [] : [input.version])
+    ];
     const builtins = listEnabledAgentClientAdapters(input.state).map((adapter) => Object.freeze({
         source: 'builtin',
         clientId: adapter.id,
@@ -20,7 +29,7 @@ function renderNextStepCommands(input) {
         command: renderAgentClientInvocation(adapter.invocation, {
             projectName: input.projectName,
             skillName: input.skillName,
-            args: input.taskRef === undefined ? [] : [input.taskRef]
+            args
         })
     }));
     const custom = input.customTUIs.map((tool) => Object.freeze({
@@ -29,7 +38,7 @@ function renderNextStepCommands(input) {
         command: renderAgentClientInvocation(tool.invocation, {
             projectName: input.projectName,
             skillName: input.skillName,
-            args: input.taskRef === undefined ? [] : [input.taskRef]
+            args
         })
     }));
     return Object.freeze([...builtins, ...custom]);

package/dist/lib/agent-clients/reconcile.js

@@ -158,7 +158,8 @@ function planAgentClientReconciliation(input) {
         skillName: 'update-agent-infra'
     });
     const actionableSeed = seedOperations.some((operation) => operation.kind === 'write' || operation.kind === 'remove');
-    const changed = JSON.stringify(nextConfig) !== JSON.stringify(input.config) || actionableSeed;
+    const changed = JSON.stringify(nextConfig) !== JSON.stringify(input.config)
+        || actionableSeed;
     return Object.freeze({
         source: normalized.source,
         before: normalized.state,

package/dist/lib/agent-clients/registry.js

@@ -52,6 +52,12 @@ function listInstalledAgentClientAdapters(state) {
 function getAgentClientCapability(id, capability) {
     return getAgentClientAdapter(id).capabilities[capability];
 }
+function getAgentClientModelSelection(id) {
+    return getAgentClientAdapter(id).modelSelection;
+}
+function getAgentClientDelegationEvidence(id) {
+    return getAgentClientAdapter(id).delegationEvidence;
+}
 function listEnabledAgentClientAdaptersByCapability(state, capability, acceptedLevels) {
     const accepted = new Set(acceptedLevels);
     return Object.freeze(AGENT_CLIENT_ADAPTERS.filter((adapter) => state[adapter.id].enabled
@@ -65,8 +71,16 @@ function createAgentClientManifest() {
         ownedPathPrefixes: Object.freeze([...adapter.project.ownedPathPrefixes]),
         managed: Object.freeze([...adapter.project.managed]),
         merged: Object.freeze([...adapter.project.merged]),
-        ejected: Object.freeze([...adapter.project.ejected])
+        ejected: Object.freeze([...adapter.project.ejected]),
+        ...(adapter.project.customCommand === undefined
+            ? {}
+            : {
+                customCommand: Object.freeze({
+                    ...adapter.project.customCommand,
+                    frontmatter: Object.freeze({ ...adapter.project.customCommand.frontmatter })
+                })
+            })
     })));
 }
-export { AGENT_CLIENT_REGISTRY, createAgentClientManifest, getAgentClientAdapter, getAgentClientCapability, listAgentClientAdapters, listEnabledAgentClientAdapters, listEnabledAgentClientAdaptersByCapability, listInstalledAgentClientAdapters };
+export { AGENT_CLIENT_REGISTRY, createAgentClientManifest, getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection, listAgentClientAdapters, listEnabledAgentClientAdapters, listEnabledAgentClientAdaptersByCapability, listInstalledAgentClientAdapters };
 //# sourceMappingURL=registry.js.map

package/dist/lib/agent-clients/schema.js

@@ -24,6 +24,15 @@ const AGENT_CLIENTS_SCHEMA = {
                     },
                     installInSandbox: {
                         type: 'boolean'
+                    },
+                    orchestration: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['executor', 'reviewer'],
+                        properties: {
+                            executor: { $ref: '#/definitions/orchestrationRolePolicy' },
+                            reviewer: { $ref: '#/definitions/orchestrationRolePolicy' }
+                        }
                     }
                 }
             }
@@ -43,6 +52,15 @@ const AGENT_CLIENTS_SCHEMA = {
         }
     },
     definitions: {
+        orchestrationRolePolicy: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['model', 'reasoningEffort'],
+            properties: {
+                model: { type: 'string', minLength: 1 },
+                reasoningEffort: { type: 'string', minLength: 1 }
+            }
+        },
         agentClientCapabilityId: {
             type: 'string',
             enum: [...AGENT_CLIENT_CAPABILITY_IDS]

package/dist/lib/agent-clients/tokens.js

@@ -0,0 +1,49 @@
+// Active AI collaborator short tokens — the write-side whitelist for the
+// activity log. Migrated from lib/task/commands/log.ts so that the write-side
+// internal commands and the rendering side share one definition. Historical
+// Gemini tokens remain read-only and are handled by classifyAgent below.
+export const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'antigravity', 'opencode', 'cursor']);
+// Long name -> short name mapping (HD-4, decision A): `claude-code` reuses the
+// existing orchestration precedent, and `antigravity-cli` is the active
+// client. `gemini-cli` is intentionally not writable.
+export const AGENT_LONG_NAMES = {
+    'claude-code': 'claude',
+    'antigravity-cli': 'antigravity'
+};
+export const AGENT_USAGE_HINT = "agent must be a short token (claude/codex/antigravity/opencode/cursor), " +
+    "a long name (claude-code -> claude, antigravity-cli -> antigravity), or 'human'";
+// Read-side historical compatibility for activity-log rendering: `gemini` and
+// `gemini-cli` stay recognizable when displaying old logs, but are never
+// accepted by normalizeAgentToken (write side).
+const READ_KNOWN_AI_AGENTS = new Set([...KNOWN_AI_AGENTS, 'gemini']);
+const READ_AGENT_LONG_NAMES = {
+    ...AGENT_LONG_NAMES,
+    'gemini-cli': 'gemini'
+};
+// Strict write-side validation: the value must be exactly a short token, a
+// long name, or 'human'; returns the normalized short token, or null when
+// the value is not a recognized agent.
+export function normalizeAgentToken(value) {
+    const trimmed = value.trim();
+    if (trimmed === 'human')
+        return 'human';
+    if (KNOWN_AI_AGENTS.has(trimmed))
+        return trimmed;
+    const short = AGENT_LONG_NAMES[trimmed];
+    return short ?? null;
+}
+// Loose rendering-side classification: tolerates historical parenthetical
+// annotations; unknown tokens keep the `human` grouping but get a visible
+// signal. The "known AI token" test is `classifyAgent(value).status === 'ai'`.
+export function classifyAgent(raw) {
+    const token = raw.trim().split(/\s+/)[0]?.replace(/\(.*$/, '') ?? '';
+    if (token === '')
+        return { status: 'unknown', display: 'human' };
+    if (token === 'human')
+        return { status: 'human', display: 'human' };
+    if (READ_KNOWN_AI_AGENTS.has(token))
+        return { status: 'ai', display: token };
+    const short = READ_AGENT_LONG_NAMES[token];
+    return short ? { status: 'ai', display: short } : { status: 'unknown', display: 'human' };
+}
+//# sourceMappingURL=tokens.js.map

package/dist/lib/agent-clients/types.js

@@ -1,7 +1,7 @@
 const AGENT_CLIENT_IDS = [
     'claude-code',
     'codex',
-    'gemini-cli',
+    'antigravity-cli',
     'opencode'
 ];
 const AGENT_CLIENT_CAPABILITY_IDS = [

package/dist/lib/defaults.json

@@ -14,7 +14,7 @@
             "installInSandbox": true
         },
         {
-            "id": "gemini-cli",
+            "id": "antigravity-cli",
             "enabled": true,
             "installInSandbox": true
         },

package/dist/lib/git/workflow.js

@@ -1,4 +1,6 @@
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 const defaultRunner = (args, cwd) => {
     const result = spawnSync('git', [...args], { cwd, encoding: 'utf8' });
     return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
@@ -10,6 +12,9 @@ function value(runner, cwd, args, trim = true) {
     const result = run(runner, cwd, args);
     return result.status === 0 ? (trim ? result.stdout.trim() : result.stdout.replace(/\n$/, '')) : null;
 }
+function cleanMessage(message) {
+    return message.replace(/(https?:\/\/)[^\s/@:]+(?::[^\s/@]*)?@/gi, '$1***@').trim();
+}
 function inspectGitWorkflow(cwd, runner = defaultRunner, remoteInput) {
     const head = value(runner, cwd, ['rev-parse', 'HEAD']);
     const branch = value(runner, cwd, ['branch', '--show-current']);
@@ -97,5 +102,53 @@ function pushGitRefs(input, runner = defaultRunner) {
     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 };
 }
-export { commitExplicitPaths, inspectGitWorkflow, pushGitRefs };
+function pushRebasedBranch(input, runner = defaultRunner) {
+    const sha = /^[0-9a-f]{40}$/i;
+    const refName = /^(?!-)(?!.*\.\.)(?!.*(?:^|\/)\.)(?!.*[~^:?*\[\\\s])(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
+    if (!input.remote || !refName.test(input.remote) || !refName.test(input.branch) || !refName.test(input.baseBranch) ||
+        !sha.test(input.expectedOldHead) || !sha.test(input.newHead) || !sha.test(input.expectedBaseHead)) {
+        return { status: 'failed', changed: false, snapshot: null, operations: [], error: { code: 'GIT_REBASED_INPUT_INVALID', message: 'Remote, branches, and full 40-character SHAs are required' } };
+    }
+    const snapshot = inspectGitWorkflow(input.cwd, runner).snapshot;
+    if (!snapshot)
+        return { status: 'failed', changed: false, snapshot: null, operations: [], error: { code: 'GIT_INSPECT_FAILED', message: 'Unable to inspect Git repository' } };
+    if (snapshot.branch !== input.branch || snapshot.head !== input.newHead) {
+        return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_LOCAL_IDENTITY_MISMATCH', message: 'Current branch or HEAD does not match the rebased intent' } };
+    }
+    const rebasePaths = ['rebase-merge', 'rebase-apply']
+        .map((name) => value(runner, input.cwd, ['rev-parse', '--git-path', name]))
+        .filter((candidate) => Boolean(candidate));
+    if (snapshot.worktree.length > 0 || snapshot.staged.length > 0 ||
+        run(runner, input.cwd, ['rev-parse', '-q', '--verify', 'REBASE_HEAD']).status === 0 ||
+        rebasePaths.some((candidate) => fs.existsSync(path.isAbsolute(candidate) ? candidate : path.join(input.cwd, candidate)))) {
+        return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_LOCAL_STATE_UNSAFE', message: 'Working tree must be clean with no rebase in progress' } };
+    }
+    const remoteRef = `refs/heads/${input.branch}`;
+    const baseRef = `refs/heads/${input.baseBranch}`;
+    const remoteHead = value(runner, input.cwd, ['ls-remote', '--exit-code', input.remote, remoteRef])?.split(/\s+/)[0] ?? null;
+    if (remoteHead !== input.expectedOldHead) {
+        return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_REMOTE_HEAD_MISMATCH', message: `Expected remote head ${input.expectedOldHead}, received ${remoteHead ?? 'unavailable'}` } };
+    }
+    const baseHead = value(runner, input.cwd, ['ls-remote', '--exit-code', input.remote, baseRef])?.split(/\s+/)[0] ?? null;
+    if (baseHead !== input.expectedBaseHead) {
+        return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_REMOTE_BASE_MISMATCH', message: `Expected base head ${input.expectedBaseHead}, received ${baseHead ?? 'unavailable'}` } };
+    }
+    if (run(runner, input.cwd, ['merge-base', '--is-ancestor', input.expectedBaseHead, input.newHead]).status !== 0) {
+        return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_REBASED_ANCESTOR_MISMATCH', message: 'Rebased head does not contain the expected base head' } };
+    }
+    const pushed = run(runner, input.cwd, [
+        'push', `--force-with-lease=${remoteRef}:${input.expectedOldHead}`,
+        input.remote, `${input.newHead}:${remoteRef}`
+    ]);
+    if (pushed.status !== 0) {
+        const message = cleanMessage(pushed.stderr) || 'Rebased branch push was rejected';
+        return { status: 'failed', changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'push-rebased', status: 'failed', ref: input.branch, message }], error: { code: 'GIT_REBASED_PUSH_REJECTED', message } };
+    }
+    const verified = value(runner, input.cwd, ['ls-remote', '--exit-code', input.remote, remoteRef])?.split(/\s+/)[0] ?? null;
+    if (verified !== input.newHead) {
+        return { status: 'failed', changed: true, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'push-rebased', status: 'failed', ref: input.branch, message: 'Remote ref verification failed' }], error: { code: 'GIT_REBASED_VERIFY_FAILED', message: `Expected pushed head ${input.newHead}, received ${verified ?? 'unavailable'}` } };
+    }
+    return { status: 'applied', changed: true, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'push-rebased', status: 'applied', ref: input.branch }], error: null };
+}
+export { commitExplicitPaths, inspectGitWorkflow, pushGitRefs, pushRebasedBranch };
 //# sourceMappingURL=workflow.js.map

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

@@ -3,7 +3,9 @@ import path from 'node:path';
 import { AgentClientConfigError, normalizeAgentClients } from '../agent-clients/config.js';
 import { normalizeCustomTUIs } from '../agent-clients/custom-tuis.js';
 import { renderNextStepCommands } from '../agent-clients/next-steps.js';
-const USAGE = 'Usage: agent-infra-internal agent-client next-steps --skill <skill-name> [--task-ref <NN|TASK-id>] [--format text|json]\n';
+import { getAgentClientModelSelection } from '../agent-clients/registry.js';
+import { isAgentClientId } from '../agent-clients/types.js';
+const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection> [options]\n';
 function failure(code, message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -25,11 +27,12 @@ function parseArgs(args) {
     }
     let skillName;
     let taskRef;
+    let version;
     let format = 'text';
     const seen = new Set();
     for (let index = 1; index < args.length; index += 1) {
         const flag = args[index];
-        if (!['--skill', '--task-ref', '--format'].includes(flag)) {
+        if (!['--skill', '--task-ref', '--version', '--format'].includes(flag)) {
             failure('AGENT_CLIENT_PAYLOAD_INVALID', `unknown option '${flag}'`);
             return null;
         }
@@ -47,6 +50,8 @@ function parseArgs(args) {
             skillName = value;
         if (flag === '--task-ref')
             taskRef = value;
+        if (flag === '--version')
+            version = value;
         if (flag === '--format') {
             if (value !== 'text' && value !== 'json') {
                 failure('AGENT_CLIENT_PAYLOAD_INVALID', "format must be 'text' or 'json'");
@@ -59,9 +64,60 @@ function parseArgs(args) {
         failure('AGENT_CLIENT_PAYLOAD_INVALID', "option '--skill' is required");
         return null;
     }
-    return { skillName, ...(taskRef ? { taskRef } : {}), format };
+    return {
+        skillName,
+        ...(taskRef ? { taskRef } : {}),
+        ...(version ? { version } : {}),
+        format
+    };
 }
 function agentClient(args = []) {
+    if (args[0] === 'model-selection') {
+        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;
+        }
+        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 context = getAgentClientModelSelection(client);
+        if (format === 'json') {
+            process.stdout.write(`${JSON.stringify({
+                status: 'resolved', changed: false, client, context, error: null
+            })}\n`);
+            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`);
+        }
+        return;
+    }
     const parsed = parseArgs(args);
     if (!parsed || process.exitCode)
         return;
@@ -86,7 +142,8 @@ function agentClient(args = []) {
             state: clients.state,
             customTUIs: custom.items,
             skillName: parsed.skillName,
-            ...(parsed.taskRef ? { taskRef: parsed.taskRef } : {})
+            ...(parsed.taskRef ? { taskRef: parsed.taskRef } : {}),
+            ...(parsed.version ? { version: parsed.version } : {})
         });
         if (parsed.format === 'json') {
             process.stdout.write(`${JSON.stringify({

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

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

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { fetchPlatformCheckLogs, inspectRequiredChecks, resolvePlatformCheckRun, watchPlatformChecks } from '../platform/pr-checks.js';
+import { fetchPlatformCheckLogs, inspectPullRequestReadiness, resolvePlatformCheckRun, watchPullRequestReadiness } from '../platform/pr-checks.js';
 const USAGE = `Usage: agent-infra-internal platform-checks inspect <task-ref> [--cwd <path>]
        agent-infra-internal platform-checks watch <task-ref> --interval-seconds <N> --deadline-seconds <N> [--cwd <path>]
        agent-infra-internal platform-checks resolve-run <task-ref> --check-name <name> [--details-url <url>] [--cwd <path>]
@@ -76,7 +76,7 @@ async function platformChecks(args = []) {
         return;
     }
     if (operation === 'inspect') {
-        finish(inspectRequiredChecks(taskRef, { cwd }));
+        finish(inspectPullRequestReadiness(taskRef, { cwd }));
         return;
     }
     if (operation === 'resolve-run') {
@@ -108,7 +108,7 @@ async function platformChecks(args = []) {
     process.once('SIGINT', abort);
     process.once('SIGTERM', abort);
     try {
-        finish(await watchPlatformChecks(taskRef, { cwd, intervalSeconds, deadlineSeconds, signal: controller.signal }));
+        finish(await watchPullRequestReadiness(taskRef, { cwd, intervalSeconds, deadlineSeconds, signal: controller.signal }));
     }
     finally {
         process.removeListener('SIGINT', abort);