@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/dist/lib/git/review-snapshot.js

@@ -41,22 +41,37 @@ function projectStaged(repoRoot, baseline, globs, env) {
         });
     }
 }
-function snapshotReview(input) {
-    const repoRoot = String(git(input.cwd, ['rev-parse', '--show-toplevel'])).trim();
-    const resolvedBaseline = String(git(repoRoot, ['rev-parse', '--verify', `${input.baseline}^{commit}`])).trim();
-    return withTemporaryIndex(repoRoot, resolvedBaseline, (env) => {
-        if (input.mode === 'worktree')
-            projectWorktree(repoRoot, resolvedBaseline, input.globs, env);
+function projectSnapshot(repoRoot, mode, baseline, globs) {
+    return withTemporaryIndex(repoRoot, baseline, (env) => {
+        if (mode === 'worktree')
+            projectWorktree(repoRoot, baseline, globs, env);
         else
-            projectStaged(repoRoot, resolvedBaseline, input.globs, env);
-        const diff = execFileSync('git', ['diff', '--cached', '--binary', resolvedBaseline, '--', ...input.globs], { cwd: repoRoot, encoding: 'buffer', env });
+            projectStaged(repoRoot, baseline, globs, env);
         return {
-            baseline: resolvedBaseline,
-            fingerprint: `sha256:${crypto.createHash('sha256').update(diff).digest('hex')}`,
+            diff: execFileSync('git', ['diff', '--cached', '--binary', baseline, '--', ...globs], {
+                cwd: repoRoot,
+                encoding: 'buffer',
+                env
+            }),
             tree: String(git(repoRoot, ['write-tree'], { env })).trim()
         };
     });
 }
+function snapshotReview(input) {
+    const repoRoot = String(git(input.cwd, ['rev-parse', '--show-toplevel'])).trim();
+    const resolvedBaseline = String(git(repoRoot, ['rev-parse', '--verify', `${input.baseline}^{commit}`])).trim();
+    const resolvedDiffBase = String(git(repoRoot, ['rev-parse', '--verify', `${input.diffBase || resolvedBaseline}^{commit}`])).trim();
+    const reviewed = projectSnapshot(repoRoot, input.mode, resolvedBaseline, input.globs);
+    const fingerprintSource = resolvedDiffBase === resolvedBaseline
+        ? reviewed.diff
+        : projectSnapshot(repoRoot, input.mode, resolvedDiffBase, input.globs).diff;
+    return {
+        baseline: resolvedBaseline,
+        diffBase: resolvedDiffBase,
+        fingerprint: `sha256:${crypto.createHash('sha256').update(fingerprintSource).digest('hex')}`,
+        tree: reviewed.tree
+    };
+}
 function compareReviewTrees(input) {
     const repoRoot = String(git(input.cwd, ['rev-parse', '--show-toplevel'])).trim();
     git(repoRoot, ['rev-parse', '--verify', `${input.expected}^{tree}`]);

package/dist/lib/git/reviewed-commit-equivalence.js

@@ -0,0 +1,110 @@
+import { execFileSync, spawnSync } from "node:child_process";
+const SHA_PATTERN = /^[0-9a-f]{40}$/i;
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+}
+function commitExists(gitRoot, sha) {
+    try {
+        git(gitRoot, ["cat-file", "-e", `${sha}^{commit}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isAncestor(gitRoot, ancestor, descendant) {
+    const result = spawnSync("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+        cwd: gitRoot,
+        encoding: "utf8"
+    });
+    if (result.status === 0)
+        return true;
+    if (result.status === 1)
+        return false;
+    return null;
+}
+export function resolveLocalReviewedCommitRelation(input) {
+    const { gitRoot, localHead, lastReviewedCommit, rewrittenCommit, pathspecs } = input;
+    const shas = [localHead, lastReviewedCommit, rewrittenCommit];
+    if (shas.some((sha) => !SHA_PATTERN.test(sha) || !commitExists(gitRoot, sha))) {
+        return {
+            status: "blocked",
+            code: "LOCAL_REWRITE_OBJECT_MISSING",
+            message: "Required local rewrite Git objects are unavailable"
+        };
+    }
+    const ancestor = isAncestor(gitRoot, rewrittenCommit, localHead);
+    if (ancestor === false) {
+        return {
+            status: "failed",
+            code: "LOCAL_REWRITE_TOPOLOGY_INVALID",
+            message: "Local rewritten commit is not in the current HEAD history"
+        };
+    }
+    if (ancestor === null) {
+        return {
+            status: "blocked",
+            code: "LOCAL_REWRITE_GIT_EVIDENCE_UNAVAILABLE",
+            message: "Unable to verify local rewrite ancestry"
+        };
+    }
+    try {
+        const parents = git(gitRoot, ["rev-parse", `${rewrittenCommit}^@`])
+            .split(/\r?\n/)
+            .filter((line) => line.trim() !== "");
+        if (parents.length !== 1) {
+            return {
+                status: "failed",
+                code: "LOCAL_REWRITE_TOPOLOGY_INVALID",
+                message: "Local rewritten commit is not a single-parent commit"
+            };
+        }
+        const reviewedTree = git(gitRoot, ["rev-parse", `${lastReviewedCommit}^{tree}`]).trim();
+        const rewrittenTree = git(gitRoot, ["rev-parse", `${rewrittenCommit}^{tree}`]).trim();
+        if (reviewedTree !== rewrittenTree) {
+            const protectedDiff = git(gitRoot, [
+                "diff",
+                "--no-renames",
+                "--binary",
+                "--full-index",
+                lastReviewedCommit,
+                rewrittenCommit,
+                "--",
+                ...pathspecs
+            ]);
+            if (protectedDiff !== "") {
+                return {
+                    status: "failed",
+                    code: "LOCAL_REWRITE_CONTENT_MISMATCH",
+                    message: "Local rewritten commit differs from the reviewed protected content"
+                };
+            }
+        }
+        const postRewrite = git(gitRoot, [
+            "rev-list",
+            `${rewrittenCommit}..${localHead}`,
+            "--",
+            ...pathspecs
+        ]).trim();
+        if (postRewrite) {
+            return {
+                status: "failed",
+                code: "POST_LOCAL_REWRITE_CHANGES",
+                message: "Protected paths changed after the equivalent local rewrite"
+            };
+        }
+    }
+    catch {
+        return {
+            status: "blocked",
+            code: "LOCAL_REWRITE_GIT_EVIDENCE_UNAVAILABLE",
+            message: "Unable to verify local rewrite topology or content"
+        };
+    }
+    return {
+        status: "local-equivalent",
+        reviewedHead: lastReviewedCommit,
+        rewrittenCommit
+    };
+}
+//# sourceMappingURL=reviewed-commit-equivalence.js.map

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/init.js

@@ -8,30 +8,15 @@ import { resolveTemplateDir } from './paths.js';
 import { renderFile, copySkillDir, KNOWN_PLATFORMS } from './render.js';
 import { enginesForPlatform } from './sandbox/engines/index.js';
 import { VERSION } from './version.js';
-import { BUILTIN_TUI_IDS, BUILTIN_TUI_DISPLAY, isPathOwnedByDisabledTUI, resolveEnabledTUIs } from './builtin-tuis.js';
+import { listAgentClientAdapters } from './agent-clients/registry.js';
+import { serializeAgentClients } from './agent-clients/config.js';
+import { applyAgentClientReconciliation, planAgentClientReconciliation } from './agent-clients/reconcile.js';
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const PLATFORM_DEFAULT_ENGINES = Object.freeze({
     linux: 'native',
     darwin: 'colima',
     win32: 'wsl2'
 });
-function isPathOwnedByOtherPlatform(relativePath, platformType) {
-    const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
-    if (!top.startsWith('.'))
-        return false;
-    const candidate = top.slice(1);
-    if (!KNOWN_PLATFORMS.has(candidate))
-        return false;
-    return candidate !== platformType;
-}
-function buildDefaultFiles(platformType, enabledTUIs) {
-    const ownedByDisabled = (entry) => isPathOwnedByDisabledTUI(entry, enabledTUIs);
-    return {
-        managed: (defaults.files.managed || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType) && !ownedByDisabled(entry)),
-        merged: (defaults.files.merged || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType) && !ownedByDisabled(entry)),
-        ejected: structuredClone(defaults.files.ejected || [])
-    };
-}
 function detectProjectName() {
     try {
         const url = execSync('git remote get-url origin', { stdio: ['pipe', 'pipe', 'pipe'] })
@@ -158,9 +143,10 @@ async function cmdInit() {
         info(`Custom platform '${platformType}' selected. Built-in templates are only complete for github;`
             + ` provide matching '.${platformType}.' or generic templates before running update-agent-infra.`);
     }
-    let enabledTUIs;
+    const adapters = listAgentClientAdapters();
+    let enabledClientIds;
     try {
-        enabledTUIs = await multiSelect('Built-in TUI command files to install/manage', BUILTIN_TUI_IDS.map((id) => ({ id, label: BUILTIN_TUI_DISPLAY[id] })));
+        enabledClientIds = await multiSelect('Agent Client project integrations to enable', adapters.map((adapter) => ({ id: adapter.id, label: adapter.displayName })));
     }
     catch (e) {
         err(e instanceof Error ? e.message : String(e));
@@ -168,53 +154,19 @@ async function cmdInit() {
         process.exitCode = 1;
         return;
     }
-    const enabledTUISet = resolveEnabledTUIs(enabledTUIs);
+    const enabledClientSet = new Set(enabledClientIds);
     const templateSources = parseLocalSources(await prompt('Template sources (optional, comma-separated local paths, e.g. ~/my-templates; Enter to skip)', ''));
     const skillSources = parseLocalSources(await prompt('Skill sources (optional, comma-separated local paths, e.g. ~/my-skills; Enter to skip)', ''));
     closePrompt();
     const project = projectName;
     const replacements = { project, org: orgName };
-    console.log('');
-    if (orgName) {
-        info(`Installing update-agent-infra seed command for: ${projectName} (${orgName})`);
-    }
-    else {
-        info(`Installing update-agent-infra seed command for: ${projectName}`);
-    }
-    console.log('');
-    // select language-specific template filenames
-    let claudeSrc, geminiSrc, opencodeSrc;
-    if (language === 'zh-CN') {
-        claudeSrc = 'update-agent-infra.zh-CN.md';
-        geminiSrc = 'update-agent-infra.zh-CN.toml';
-        opencodeSrc = 'update-agent-infra.zh-CN.md';
-    }
-    else {
-        claudeSrc = 'update-agent-infra.en.md';
-        geminiSrc = 'update-agent-infra.en.toml';
-        opencodeSrc = 'update-agent-infra.en.md';
-    }
-    // install skill
-    copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
-    ok('Installed .agents/skills/update-agent-infra/');
-    renderFile(path.join(templateDir, '.agents', 'scripts', 'lib', 'agent-infra-package.js'), path.join('.agents', 'scripts', 'lib', 'agent-infra-package.js'), replacements);
-    ok('Installed .agents/scripts/lib/agent-infra-package.js');
-    // install Claude command (only if enabled)
-    if (enabledTUISet.has('claude-code')) {
-        renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
-        ok('Installed .claude/commands/update-agent-infra.md');
-    }
-    // install Gemini command (only if enabled)
-    if (enabledTUISet.has('gemini-cli')) {
-        renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
-        ok(`Installed .gemini/commands/${project}/update-agent-infra.toml`);
-    }
-    // install OpenCode command (only if enabled)
-    if (enabledTUISet.has('opencode')) {
-        renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
-        ok('Installed .opencode/commands/update-agent-infra.md');
-    }
-    // generate .agents/.airc.json
+    const defaultState = Object.fromEntries(defaults.agentClients.map((entry) => [
+        entry.id,
+        {
+            enabled: enabledClientSet.has(entry.id),
+            installInSandbox: entry.installInSandbox
+        }
+    ]));
     const config = {
         project: projectName,
         org: orgName,
@@ -224,24 +176,39 @@ async function cmdInit() {
         sandbox: structuredClone(defaults.sandbox),
         task: structuredClone(defaults.task),
         labels: structuredClone(defaults.labels),
-        files: buildDefaultFiles(platformType, enabledTUISet),
-        tuis: enabledTUIs
+        files: { managed: [], merged: [], ejected: [] },
+        agentClients: serializeAgentClients(defaultState)
     };
-    if (sandboxEngine) {
+    if (sandboxEngine)
         config.sandbox.engine = sandboxEngine;
+    if (templateSources.length > 0)
+        config.templates = { sources: templateSources };
+    if (skillSources.length > 0)
+        config.skills = { sources: skillSources };
+    const workflowPlan = planAgentClientReconciliation({
+        config: config,
+        mutation: { type: 'none' },
+        projectRoot: process.cwd(),
+        templateRoot: templateDir,
+        platformType,
+        language
+    });
+    console.log('');
+    if (orgName) {
+        info(`Installing update-agent-infra seed command for: ${projectName} (${orgName})`);
     }
-    if (templateSources.length > 0) {
-        config.templates = {
-            sources: templateSources
-        };
-    }
-    if (skillSources.length > 0) {
-        config.skills = {
-            sources: skillSources
-        };
+    else {
+        info(`Installing update-agent-infra seed command for: ${projectName}`);
     }
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    console.log('');
+    // install skill
+    copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
+    ok('Installed .agents/skills/update-agent-infra/');
+    renderFile(path.join(templateDir, '.agents', 'scripts', 'lib', 'agent-infra-package.js'), path.join('.agents', 'scripts', 'lib', 'agent-infra-package.js'), replacements);
+    ok('Installed .agents/scripts/lib/agent-infra-package.js');
+    const reconcileResult = applyAgentClientReconciliation(workflowPlan);
+    for (const target of reconcileResult.applied)
+        ok(`Installed ${target}`);
     ok(`Generated ${configPath}`);
     // done
     console.log('');
@@ -250,27 +217,16 @@ async function cmdInit() {
     console.log('  If this init used npx, install agent-infra persistently before update or validation:');
     console.log('    npm install -g @fitlab-ai/agent-infra');
     console.log('');
-    if (enabledTUISet.size === 0) {
-        console.log('  No built-in TUI selected.');
+    if (workflowPlan.nextSteps.length === 0) {
+        console.log('  No Agent Client project integration enabled.');
         console.log(`  Configure "customTUIs" in ${configPath} before running update-agent-infra.`);
         console.log('');
     }
     else {
         console.log('  Next step: open this project in any AI TUI and run:');
         console.log('');
-        const claudeOrOpencode = [];
-        if (enabledTUISet.has('claude-code'))
-            claudeOrOpencode.push('Claude Code');
-        if (enabledTUISet.has('opencode'))
-            claudeOrOpencode.push('OpenCode');
-        if (claudeOrOpencode.length > 0) {
-            console.log(`    ${claudeOrOpencode.join(' / ')}:  /update-agent-infra`);
-        }
-        if (enabledTUISet.has('gemini-cli')) {
-            console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
-        }
-        if (enabledTUISet.has('codex')) {
-            console.log('    Codex CLI:               $update-agent-infra');
+        for (const nextStep of workflowPlan.nextSteps) {
+            console.log(`    ${nextStep.displayName}: ${nextStep.command}`);
         }
         console.log('');
         console.log('  This will render all templates and set up the full');

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

@@ -0,0 +1,174 @@
+import fs from 'node:fs';
+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';
+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',
+        changed: false,
+        commands: [],
+        diagnostics: [],
+        error: { code, message }
+    })}\n`);
+    process.exitCode = 1;
+}
+function parseArgs(args) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return null;
+    }
+    if (args[0] !== 'next-steps') {
+        failure('AGENT_CLIENT_PAYLOAD_INVALID', "operation must be 'next-steps'");
+        return null;
+    }
+    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', '--version', '--format'].includes(flag)) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `unknown option '${flag}'`);
+            return null;
+        }
+        if (seen.has(flag)) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `duplicate option '${flag}'`);
+            return null;
+        }
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
+            return null;
+        }
+        seen.add(flag);
+        if (flag === '--skill')
+            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'");
+                return null;
+            }
+            format = value;
+        }
+    }
+    if (!skillName) {
+        failure('AGENT_CLIENT_PAYLOAD_INVALID', "option '--skill' is required");
+        return null;
+    }
+    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;
+    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));
+        return;
+    }
+    try {
+        const clients = normalizeAgentClients(config);
+        const custom = normalizeCustomTUIs(process.cwd(), config.customTUIs ?? []);
+        const commands = renderNextStepCommands({
+            projectName: String(config.project ?? ''),
+            state: clients.state,
+            customTUIs: custom.items,
+            skillName: parsed.skillName,
+            ...(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`);
+        }
+    }
+    catch (error) {
+        if (error instanceof AgentClientConfigError) {
+            failure(error.code, error.message);
+            return;
+        }
+        failure('AGENT_CLIENT_RENDER_INVALID', error instanceof Error ? error.message : String(error));
+    }
+}
+export { agentClient };
+//# sourceMappingURL=agent-client.js.map

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,13 +23,18 @@ 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;
         if (!input)
             result = { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
         else if (action === 'snapshot')
-            result = { status: 'no-op', changed: false, snapshot: snapshotReview({ cwd: cwd ?? process.cwd(), mode: input.mode, baseline: input.baseline, globs: input.globs ?? resolvePostReviewGlobs({}, {}) }), error: null };
+            result = { status: 'no-op', changed: false, snapshot: snapshotReview({ cwd: cwd ?? process.cwd(), mode: input.mode, baseline: input.baseline, diffBase: input.diffBase, globs: input.globs ?? resolvePostReviewGlobs({}, {}) }), error: null };
         else
             result = { status: 'no-op', changed: false, comparison: compareReviewTrees({ cwd: cwd ?? process.cwd(), expected: input.expected, actual: input.actual }), error: 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);