@fitlab-ai/agent-infra 0.9.1 → 0.9.2

package/dist/lib/agent-clients/custom-tuis.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+const CUSTOM_TUI_CONTRACT = Object.freeze({
+    requiredFields: Object.freeze(['name', 'dir', 'invoke']),
+    allowedPlaceholders: Object.freeze(['skillName', 'projectName'])
+});
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptySingleLine(value) {
+    return typeof value === 'string'
+        && value.trim() !== ''
+        && !/[\r\n]/.test(value);
+}
+function normalizeDir(projectRoot, value) {
+    if (!isNonEmptySingleLine(value)
+        || value.includes('\\')
+        || path.isAbsolute(value)
+        || /^[a-zA-Z]:/.test(value)) {
+        return null;
+    }
+    const normalized = path.posix.normalize(value);
+    if (normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || normalized.split('/').includes('..')) {
+        return null;
+    }
+    const relative = path.relative(path.resolve(projectRoot), path.resolve(projectRoot, normalized));
+    return relative === ''
+        || path.isAbsolute(relative)
+        || relative === '..'
+        || relative.startsWith(`..${path.sep}`)
+        ? null
+        : normalized;
+}
+function hasValidPlaceholders(invocation) {
+    const placeholders = [
+        ...invocation.matchAll(/\$\{([^}]+)\}/g)
+    ].map((match) => match[1]);
+    return placeholders.includes('skillName')
+        && placeholders.every((placeholder) => CUSTOM_TUI_CONTRACT.allowedPlaceholders.includes(placeholder))
+        && !invocation
+            .replaceAll('${skillName}', '')
+            .replaceAll('${projectName}', '')
+            .includes('${');
+}
+function normalizeCustomTUIs(projectRoot, input) {
+    const items = [];
+    const diagnostics = [];
+    if (!Array.isArray(input)) {
+        return Object.freeze({
+            items: Object.freeze([]),
+            diagnostics: Object.freeze([
+                Object.freeze({
+                    code: 'INVALID_CUSTOM_TUIS',
+                    path: 'customTUIs'
+                })
+            ])
+        });
+    }
+    for (const [index, candidate] of input.entries()) {
+        const base = `customTUIs[${index}]`;
+        if (!isRecord(candidate)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: base });
+            continue;
+        }
+        if (!isNonEmptySingleLine(candidate.name)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.name` });
+            continue;
+        }
+        const dir = normalizeDir(projectRoot, candidate.dir);
+        if (!dir) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.dir` });
+            continue;
+        }
+        if (!isNonEmptySingleLine(candidate.invoke)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.invoke` });
+            continue;
+        }
+        if (!hasValidPlaceholders(candidate.invoke)) {
+            diagnostics.push({
+                code: 'INVALID_CUSTOM_TUI_PLACEHOLDER',
+                path: `${base}.invoke`
+            });
+            continue;
+        }
+        items.push(Object.freeze({
+            name: candidate.name,
+            dir,
+            invocation: candidate.invoke
+        }));
+    }
+    return Object.freeze({
+        items: Object.freeze(items),
+        diagnostics: Object.freeze(diagnostics.map((diagnostic) => Object.freeze(diagnostic)))
+    });
+}
+export { CUSTOM_TUI_CONTRACT, normalizeCustomTUIs };
+//# sourceMappingURL=custom-tuis.js.map

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

@@ -0,0 +1,9 @@
+function renderAgentClientInvocation(template, input) {
+    let command = template.replaceAll('${skillName}', input.skillName);
+    if (input.projectName !== undefined) {
+        command = command.replaceAll('${projectName}', input.projectName);
+    }
+    return [command, ...(input.args ?? [])].join(' ').trim();
+}
+export { renderAgentClientInvocation };
+//# sourceMappingURL=invocation.js.map

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

@@ -0,0 +1,38 @@
+import { listEnabledAgentClientAdapters } from './registry.js';
+import { renderAgentClientInvocation } from './invocation.js';
+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) {
+    if (!SAFE_NAME.test(value)) {
+        throw new Error(`Invalid ${field}`);
+    }
+}
+function renderNextStepCommands(input) {
+    requireSafeName(input.projectName, 'project name');
+    requireSafeName(input.skillName, 'skill name');
+    if (input.taskRef !== undefined && !SAFE_TASK_REF.test(input.taskRef)) {
+        throw new Error('Invalid task ref');
+    }
+    const builtins = listEnabledAgentClientAdapters(input.state).map((adapter) => Object.freeze({
+        source: 'builtin',
+        clientId: adapter.id,
+        displayName: adapter.displayName,
+        command: renderAgentClientInvocation(adapter.invocation, {
+            projectName: input.projectName,
+            skillName: input.skillName,
+            args: input.taskRef === undefined ? [] : [input.taskRef]
+        })
+    }));
+    const custom = input.customTUIs.map((tool) => Object.freeze({
+        source: 'custom',
+        displayName: tool.name,
+        command: renderAgentClientInvocation(tool.invocation, {
+            projectName: input.projectName,
+            skillName: input.skillName,
+            args: input.taskRef === undefined ? [] : [input.taskRef]
+        })
+    }));
+    return Object.freeze([...builtins, ...custom]);
+}
+export { renderNextStepCommands };
+//# sourceMappingURL=next-steps.js.map

package/dist/lib/agent-clients/project-assets.js

@@ -0,0 +1,45 @@
+function unique(values) {
+    return Object.freeze([...new Set(values)]);
+}
+function planAgentClientProjectAssets(input) {
+    const enabledIds = new Set(input.enabledAdapters.map((adapter) => adapter.id));
+    const enabledAdapters = input.allAdapters.filter((adapter) => enabledIds.has(adapter.id));
+    const disabledAdapters = input.allAdapters.filter((adapter) => !enabledIds.has(adapter.id));
+    const enabledManaged = unique(enabledAdapters.flatMap((adapter) => adapter.project.managed));
+    const enabledMerged = unique(enabledAdapters.flatMap((adapter) => adapter.project.merged));
+    const enabledEjected = unique(enabledAdapters.flatMap((adapter) => adapter.project.ejected));
+    const disabledManaged = unique(disabledAdapters.flatMap((adapter) => adapter.project.managed));
+    const allAdapterAssets = new Set(input.allAdapters.flatMap((adapter) => [
+        ...adapter.project.managed,
+        ...adapter.project.merged,
+        ...adapter.project.ejected
+    ]));
+    const ejected = unique([
+        ...input.current.ejected,
+        ...enabledEjected,
+        ...input.sharedDefaults.ejected
+    ]);
+    const ejectedSet = new Set(ejected);
+    const preserveCurrent = (values, enabledValues) => values.filter((entry) => !ejectedSet.has(entry)
+        && (!allAdapterAssets.has(entry) || enabledValues.includes(entry)));
+    const managed = unique([
+        ...preserveCurrent(input.current.managed, enabledManaged),
+        ...enabledManaged.filter((entry) => !ejectedSet.has(entry)),
+        ...input.sharedDefaults.managed.filter((entry) => !ejectedSet.has(entry))
+    ]);
+    const managedSet = new Set(managed);
+    const merged = unique([
+        ...preserveCurrent(input.current.merged, enabledMerged),
+        ...enabledMerged.filter((entry) => !ejectedSet.has(entry) && !managedSet.has(entry)),
+        ...input.sharedDefaults.merged.filter((entry) => !ejectedSet.has(entry) && !managedSet.has(entry))
+    ]);
+    return Object.freeze({
+        registry: Object.freeze({ managed, merged, ejected }),
+        enabledManaged,
+        enabledMerged,
+        enabledEjected,
+        disabledManaged
+    });
+}
+export { planAgentClientProjectAssets };
+//# sourceMappingURL=project-assets.js.map

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

@@ -0,0 +1,235 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import defaults from '../defaults.json' with { type: 'json' };
+import { normalizeAgentClients, serializeAgentClients } from './config.js';
+import { normalizeCustomTUIs } from './custom-tuis.js';
+import { renderNextStepCommands } from './next-steps.js';
+import { planAgentClientProjectAssets } from './project-assets.js';
+import { listAgentClientAdapters, listEnabledAgentClientAdapters } from './registry.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hash(content) {
+    return `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`;
+}
+function trustedBaseline(value) {
+    return typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value)
+        ? value
+        : null;
+}
+function cloneState(state) {
+    return Object.fromEntries(Object.entries(state).map(([id, value]) => [id, { ...value }]));
+}
+function applyMutation(state, mutation) {
+    if (mutation.type === 'none')
+        return cloneState(state);
+    if (mutation.type === 'replace-state')
+        return cloneState(mutation.state);
+    return Object.fromEntries(Object.entries(state).map(([id, value]) => [
+        id,
+        id === mutation.id ? { ...value, enabled: mutation.value } : { ...value }
+    ]));
+}
+function registryFrom(value) {
+    const files = isRecord(value) ? value : {};
+    const strings = (candidate) => Array.isArray(candidate)
+        ? candidate.filter((entry) => typeof entry === 'string')
+        : [];
+    return {
+        managed: strings(files.managed),
+        merged: strings(files.merged),
+        ejected: strings(files.ejected)
+    };
+}
+function isPathOwnedByOtherPlatform(relativePath, platformType) {
+    const top = relativePath.replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
+    return top.startsWith('.')
+        && ['github', 'none'].includes(top.slice(1))
+        && top.slice(1) !== platformType;
+}
+function renderSeed(content, config) {
+    return content
+        .replaceAll('{{project}}', String(config.project ?? ''))
+        .replaceAll('{{org}}', String(config.org ?? ''));
+}
+function planAgentClientReconciliation(input) {
+    const normalized = normalizeAgentClients(input.config);
+    const desired = applyMutation(normalized.state, input.mutation);
+    const adapters = listAgentClientAdapters();
+    const current = registryFrom(input.config.files);
+    const sharedDefaults = {
+        managed: defaults.files.managed.filter((entry) => !isPathOwnedByOtherPlatform(entry, input.platformType)),
+        merged: defaults.files.merged.filter((entry) => !isPathOwnedByOtherPlatform(entry, input.platformType)),
+        ejected: defaults.files.ejected
+    };
+    const projectAssets = planAgentClientProjectAssets({
+        current,
+        sharedDefaults,
+        enabledAdapters: listEnabledAgentClientAdapters(desired),
+        allAdapters: adapters
+    });
+    const nextConfig = structuredClone(input.config);
+    nextConfig.agentClients = serializeAgentClients(desired);
+    delete nextConfig.tuis;
+    if (normalized.remainingSandboxTools !== undefined) {
+        const sandbox = isRecord(nextConfig.sandbox) ? { ...nextConfig.sandbox } : {};
+        sandbox.tools = [
+            'agent-infra',
+            ...normalized.remainingSandboxTools.filter((tool) => tool !== 'agent-infra')
+        ];
+        nextConfig.sandbox = sandbox;
+    }
+    const existingFiles = isRecord(nextConfig.files) ? nextConfig.files : {};
+    const existingBaselines = isRecord(existingFiles.managedBaselines)
+        ? existingFiles.managedBaselines
+        : {};
+    const baselines = { ...existingBaselines };
+    nextConfig.files = {
+        ...existingFiles,
+        managed: [...projectAssets.registry.managed],
+        merged: [...projectAssets.registry.merged],
+        ejected: [...projectAssets.registry.ejected],
+        managedBaselines: baselines
+    };
+    const projectName = String(input.config.project ?? '');
+    const language = input.language === 'zh-CN' ? 'zh-CN' : 'en';
+    const seedOperations = [];
+    for (const adapter of adapters) {
+        for (const seed of adapter.project.seedCommands) {
+            const relativeTarget = seed.target.replaceAll('${projectName}', projectName);
+            const target = path.join(input.projectRoot, relativeTarget);
+            const templatePath = path.join(input.templateRoot, seed.templates[language]);
+            const content = renderSeed(fs.readFileSync(templatePath, 'utf8'), input.config);
+            const templateHash = hash(content);
+            const exists = fs.existsSync(target);
+            const localHash = exists ? hash(fs.readFileSync(target)) : null;
+            const baseline = trustedBaseline(baselines[relativeTarget]);
+            const enabled = desired[adapter.id].enabled;
+            if (enabled) {
+                if (!exists || (baseline !== null && localHash === baseline)) {
+                    baselines[relativeTarget] = templateHash;
+                    seedOperations.push({
+                        kind: localHash === templateHash ? 'unchanged' : 'write',
+                        clientId: adapter.id,
+                        target: relativeTarget,
+                        ...(localHash === templateHash ? {} : { content })
+                    });
+                }
+                else if (localHash === templateHash) {
+                    baselines[relativeTarget] = templateHash;
+                    seedOperations.push({ kind: 'unchanged', clientId: adapter.id, target: relativeTarget });
+                }
+                else {
+                    seedOperations.push({
+                        kind: 'protect',
+                        clientId: adapter.id,
+                        target: relativeTarget,
+                        reason: baseline ? 'user-modified' : 'unknown-origin'
+                    });
+                }
+            }
+            else if (!exists) {
+                delete baselines[relativeTarget];
+                seedOperations.push({ kind: 'unchanged', clientId: adapter.id, target: relativeTarget });
+            }
+            else if ((baseline !== null && localHash === baseline) || localHash === templateHash) {
+                delete baselines[relativeTarget];
+                seedOperations.push({ kind: 'remove', clientId: adapter.id, target: relativeTarget });
+            }
+            else {
+                seedOperations.push({
+                    kind: 'protect',
+                    clientId: adapter.id,
+                    target: relativeTarget,
+                    reason: baseline ? 'user-modified' : 'unknown-origin'
+                });
+            }
+        }
+    }
+    if (Object.keys(baselines).length === 0) {
+        delete nextConfig.files.managedBaselines;
+    }
+    const custom = normalizeCustomTUIs(input.projectRoot, input.config.customTUIs ?? []);
+    const nextSteps = renderNextStepCommands({
+        projectName,
+        state: desired,
+        customTUIs: custom.items,
+        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;
+    return Object.freeze({
+        source: normalized.source,
+        before: normalized.state,
+        desired,
+        nextConfig,
+        projectAssets,
+        seedOperations: Object.freeze(seedOperations),
+        nextSteps,
+        diagnostics: Object.freeze([...normalized.diagnostics, ...custom.diagnostics]),
+        changed,
+        projectRoot: input.projectRoot,
+        configPath: path.join(input.projectRoot, '.agents', '.airc.json')
+    });
+}
+function applyAgentClientReconciliation(plan, dependencies = {}) {
+    const mkdirSync = dependencies.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = dependencies.writeFileSync ?? fs.writeFileSync;
+    const renameSync = dependencies.renameSync ?? fs.renameSync;
+    const unlinkSync = dependencies.unlinkSync ?? fs.unlinkSync;
+    const applied = [];
+    const protectedTargets = [];
+    const unchanged = [];
+    for (const operation of plan.seedOperations) {
+        const target = path.join(plan.projectRoot, operation.target);
+        if (operation.kind === 'write') {
+            mkdirSync(path.dirname(target), { recursive: true });
+            writeFileSync(target, operation.content, 'utf8');
+            applied.push(operation.target);
+        }
+        else if (operation.kind === 'remove') {
+            if (fs.existsSync(target))
+                unlinkSync(target);
+            applied.push(operation.target);
+        }
+        else if (operation.kind === 'protect') {
+            protectedTargets.push(operation.target);
+        }
+        else {
+            unchanged.push(operation.target);
+        }
+    }
+    const serialized = `${JSON.stringify(plan.nextConfig, null, 2)}\n`;
+    const previous = fs.existsSync(plan.configPath)
+        ? fs.readFileSync(plan.configPath, 'utf8')
+        : null;
+    const configUpdated = previous !== serialized;
+    if (configUpdated) {
+        mkdirSync(path.dirname(plan.configPath), { recursive: true });
+        const temporary = `${plan.configPath}.tmp-${process.pid}-${Date.now()}`;
+        try {
+            writeFileSync(temporary, serialized, 'utf8');
+            renameSync(temporary, plan.configPath);
+        }
+        catch (error) {
+            try {
+                if (fs.existsSync(temporary))
+                    unlinkSync(temporary);
+            }
+            catch {
+                // Preserve the original error; a later idempotent rerun can clean stale state.
+            }
+            throw error;
+        }
+    }
+    return Object.freeze({
+        status: configUpdated || applied.length > 0 ? 'applied' : 'unchanged',
+        configUpdated,
+        applied: Object.freeze(applied),
+        protected: Object.freeze(protectedTargets),
+        unchanged: Object.freeze(unchanged)
+    });
+}
+export { applyAgentClientReconciliation, planAgentClientReconciliation };
+//# sourceMappingURL=reconcile.js.map

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

@@ -0,0 +1,72 @@
+import { BUILTIN_AGENT_CLIENT_ADAPTERS } from './adapters/index.js';
+import { AGENT_CLIENT_IDS, isAgentClientId } from './types.js';
+function buildRegistry() {
+    if (BUILTIN_AGENT_CLIENT_ADAPTERS.length !== AGENT_CLIENT_IDS.length) {
+        throw new Error('Agent Client Registry is incomplete');
+    }
+    const byId = new Map(BUILTIN_AGENT_CLIENT_ADAPTERS.map((adapter) => [adapter.id, adapter]));
+    if (byId.size !== BUILTIN_AGENT_CLIENT_ADAPTERS.length) {
+        throw new Error('Agent Client Registry contains duplicate IDs');
+    }
+    const adapters = Object.freeze(AGENT_CLIENT_IDS.map((id) => {
+        const adapter = byId.get(id);
+        if (!adapter || adapter.id !== id) {
+            throw new Error(`Agent Client Registry is missing '${id}'`);
+        }
+        return adapter;
+    }));
+    const ownedPaths = adapters.flatMap((adapter) => adapter.project.ownedPathPrefixes.map((prefix) => ({
+        id: adapter.id,
+        prefix
+    })));
+    for (const [index, current] of ownedPaths.entries()) {
+        for (const other of ownedPaths.slice(index + 1)) {
+            if (current.id !== other.id
+                && (current.prefix.startsWith(other.prefix)
+                    || other.prefix.startsWith(current.prefix))) {
+                throw new Error(`Agent Client owned paths overlap: '${current.prefix}' and '${other.prefix}'`);
+            }
+        }
+    }
+    const registry = Object.freeze(Object.fromEntries(adapters.map((adapter) => [adapter.id, adapter])));
+    return Object.freeze({ registry, adapters });
+}
+const built = buildRegistry();
+const AGENT_CLIENT_REGISTRY = built.registry;
+const AGENT_CLIENT_ADAPTERS = built.adapters;
+function listAgentClientAdapters() {
+    return AGENT_CLIENT_ADAPTERS;
+}
+function getAgentClientAdapter(id) {
+    if (!isAgentClientId(id)) {
+        throw new Error(`No Agent Client adapter registered for '${String(id)}'`);
+    }
+    return AGENT_CLIENT_REGISTRY[id];
+}
+function listEnabledAgentClientAdapters(state) {
+    return Object.freeze(AGENT_CLIENT_ADAPTERS.filter((adapter) => state[adapter.id].enabled));
+}
+function listInstalledAgentClientAdapters(state) {
+    return Object.freeze(AGENT_CLIENT_ADAPTERS.filter((adapter) => state[adapter.id].installInSandbox));
+}
+function getAgentClientCapability(id, capability) {
+    return getAgentClientAdapter(id).capabilities[capability];
+}
+function listEnabledAgentClientAdaptersByCapability(state, capability, acceptedLevels) {
+    const accepted = new Set(acceptedLevels);
+    return Object.freeze(AGENT_CLIENT_ADAPTERS.filter((adapter) => state[adapter.id].enabled
+        && accepted.has(adapter.capabilities[capability].level)));
+}
+function createAgentClientManifest() {
+    return Object.freeze(AGENT_CLIENT_ADAPTERS.map((adapter) => Object.freeze({
+        id: adapter.id,
+        displayName: adapter.displayName,
+        invocation: adapter.invocation,
+        ownedPathPrefixes: Object.freeze([...adapter.project.ownedPathPrefixes]),
+        managed: Object.freeze([...adapter.project.managed]),
+        merged: Object.freeze([...adapter.project.merged]),
+        ejected: Object.freeze([...adapter.project.ejected])
+    })));
+}
+export { AGENT_CLIENT_REGISTRY, createAgentClientManifest, getAgentClientAdapter, getAgentClientCapability, listAgentClientAdapters, listEnabledAgentClientAdapters, listEnabledAgentClientAdaptersByCapability, listInstalledAgentClientAdapters };
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,57 @@
+import { AGENT_CLIENT_CAPABILITY_IDS, AGENT_CLIENT_IDS, AGENT_CLIENT_SUPPORT_LEVELS } from './types.js';
+const AGENT_CLIENTS_SCHEMA = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    required: ['agentClients'],
+    properties: {
+        agentClients: {
+            type: 'array',
+            minItems: AGENT_CLIENT_IDS.length,
+            maxItems: AGENT_CLIENT_IDS.length,
+            uniqueItems: true,
+            description: 'Canonical Agent Client configuration. Object ID completeness and uniqueness are enforced by the runtime normalizer.',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'enabled', 'installInSandbox'],
+                properties: {
+                    id: {
+                        type: 'string',
+                        enum: [...AGENT_CLIENT_IDS]
+                    },
+                    enabled: {
+                        type: 'boolean'
+                    },
+                    installInSandbox: {
+                        type: 'boolean'
+                    }
+                }
+            }
+        },
+        customTUIs: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: true,
+                required: ['name', 'dir', 'invoke'],
+                properties: {
+                    name: { type: 'string' },
+                    dir: { type: 'string' },
+                    invoke: { type: 'string' }
+                }
+            }
+        }
+    },
+    definitions: {
+        agentClientCapabilityId: {
+            type: 'string',
+            enum: [...AGENT_CLIENT_CAPABILITY_IDS]
+        },
+        agentClientSupportLevel: {
+            type: 'string',
+            enum: [...AGENT_CLIENT_SUPPORT_LEVELS]
+        }
+    }
+};
+export { AGENT_CLIENTS_SCHEMA };
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,29 @@
+const AGENT_CLIENT_IDS = [
+    'claude-code',
+    'codex',
+    'gemini-cli',
+    'opencode'
+];
+const AGENT_CLIENT_CAPABILITY_IDS = [
+    'instructions',
+    'skills',
+    'commands',
+    'hooks',
+    'subagents',
+    'orchestration',
+    'sandbox',
+    'verification'
+];
+const AGENT_CLIENT_SUPPORT_LEVELS = [
+    'compatible',
+    'integrated',
+    'verified',
+    'experimental',
+    'unsupported'
+];
+function isAgentClientId(value) {
+    return typeof value === 'string'
+        && AGENT_CLIENT_IDS.includes(value);
+}
+export { AGENT_CLIENT_IDS, AGENT_CLIENT_CAPABILITY_IDS, AGENT_CLIENT_SUPPORT_LEVELS, isAgentClientId };
+//# sourceMappingURL=types.js.map

package/dist/lib/builtin-tuis.js

@@ -1,18 +1,13 @@
-const BUILTIN_TUI_IDS = ['claude-code', 'codex', 'gemini-cli', 'opencode'];
-const BUILTIN_TUI_DISPLAY = {
-    'claude-code': 'Claude Code',
-    'codex': 'Codex',
-    'gemini-cli': 'Gemini CLI',
-    'opencode': 'OpenCode'
-};
-const BUILTIN_TUI_OWNED_PATH_PREFIXES = {
-    'claude-code': ['.claude/'],
-    'codex': ['.codex/'],
-    'gemini-cli': ['.gemini/'],
-    'opencode': ['.opencode/']
-};
+import { AGENT_CLIENT_IDS, isAgentClientId } from './agent-clients/types.js';
+import { listAgentClientAdapters } from './agent-clients/registry.js';
+const BUILTIN_TUI_IDS = AGENT_CLIENT_IDS;
+const BUILTIN_TUI_DISPLAY = Object.fromEntries(listAgentClientAdapters().map((adapter) => [adapter.id, adapter.displayName]));
+const BUILTIN_TUI_OWNED_PATH_PREFIXES = Object.fromEntries(listAgentClientAdapters().map((adapter) => [
+    adapter.id,
+    [...adapter.project.ownedPathPrefixes]
+]));
 function isBuiltinTUIId(value) {
-    return typeof value === 'string' && BUILTIN_TUI_IDS.includes(value);
+    return isAgentClientId(value);
 }
 function resolveEnabledTUIs(value) {
     // Missing field / null / non-array → full set (backward compat for legacy