@fitlab-ai/agent-infra 0.9.1 → 0.9.3

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

@@ -0,0 +1,236 @@
+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,78 @@
+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 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
+        && 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, getAgentClientDelegationEvidence, getAgentClientModelSelection, listAgentClientAdapters, listEnabledAgentClientAdapters, listEnabledAgentClientAdaptersByCapability, listInstalledAgentClientAdapters };
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,75 @@
+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'
+                    },
+                    orchestration: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['executor', 'reviewer'],
+                        properties: {
+                            executor: { $ref: '#/definitions/orchestrationRolePolicy' },
+                            reviewer: { $ref: '#/definitions/orchestrationRolePolicy' }
+                        }
+                    }
+                }
+            }
+        },
+        customTUIs: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: true,
+                required: ['name', 'dir', 'invoke'],
+                properties: {
+                    name: { type: 'string' },
+                    dir: { type: 'string' },
+                    invoke: { type: 'string' }
+                }
+            }
+        }
+    },
+    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]
+        },
+        agentClientSupportLevel: {
+            type: 'string',
+            enum: [...AGENT_CLIENT_SUPPORT_LEVELS]
+        }
+    }
+};
+export { AGENT_CLIENTS_SCHEMA };
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,29 @@
+const AGENT_CLIENT_IDS = [
+    'claude-code',
+    'codex',
+    'antigravity-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

package/dist/lib/defaults.json

@@ -1,77 +1,89 @@
 {
-  "platform": {
-    "type": "github"
-  },
-  "sandbox": {
-    "engine": null,
-    "runtimes": [
-      "node22"
+    "platform": {
+        "type": "github"
+    },
+    "agentClients": [
+        {
+            "id": "claude-code",
+            "enabled": true,
+            "installInSandbox": true
+        },
+        {
+            "id": "codex",
+            "enabled": true,
+            "installInSandbox": true
+        },
+        {
+            "id": "antigravity-cli",
+            "enabled": true,
+            "installInSandbox": true
+        },
+        {
+            "id": "opencode",
+            "enabled": true,
+            "installInSandbox": true
+        }
     ],
-    "tools": [
-      "agent-infra",
-      "claude-code",
-      "codex",
-      "gemini-cli",
-      "opencode"
-    ],
-    "refreshIntervalDays": 7,
-    "dockerfile": null,
-    "vm": {
-      "cpu": null,
-      "memory": null,
-      "disk": null
+    "sandbox": {
+        "engine": null,
+        "runtimes": [
+            "node22"
+        ],
+        "tools": [
+            "agent-infra"
+        ],
+        "refreshIntervalDays": 7,
+        "dockerfile": null,
+        "vm": {
+            "cpu": null,
+            "memory": null,
+            "disk": null
+        }
+    },
+    "task": {
+        "shortIdLength": 2
+    },
+    "labels": {
+        "in": {}
+    },
+    "files": {
+        "managed": [
+            ".agents/QUICKSTART.md",
+            ".agents/README.md",
+            ".agents/hooks/",
+            ".agents/rules/",
+            ".agents/scripts/",
+            ".agents/skills/",
+            ".agents/templates/",
+            ".agents/workflows/",
+            ".agents/workspace/README.md",
+            ".git-hooks/check-large-files.cjs",
+            ".git-hooks/check-version-format.sh",
+            ".github/scripts/",
+            ".github/workflows/metadata-sync.yml",
+            ".github/workflows/pr-label.yml",
+            ".github/workflows/status-label.yml"
+        ],
+        "guardedManaged": [
+            ".github/workflows/metadata-sync.yml",
+            ".github/workflows/pr-label.yml",
+            ".github/workflows/status-label.yml"
+        ],
+        "merged": [
+            "**/post-release.*",
+            "**/release.*",
+            "**/test-integration.*",
+            "**/test.*",
+            "**/upgrade-dependency.*",
+            ".agents/rules/testing-discipline.*",
+            ".agents/skills/post-release/SKILL.*",
+            ".agents/skills/release/SKILL.*",
+            ".agents/skills/test-integration/SKILL.*",
+            ".agents/skills/test/SKILL.*",
+            ".agents/skills/upgrade-dependency/SKILL.*",
+            ".git-hooks/pre-commit",
+            ".gitignore"
+        ],
+        "ejected": []
     }
-  },
-  "task": {
-    "shortIdLength": 2
-  },
-  "labels": {
-    "in": {}
-  },
-  "files": {
-    "managed": [
-      ".agents/QUICKSTART.md",
-      ".agents/README.md",
-      ".agents/hooks/",
-      ".agents/rules/",
-      ".agents/scripts/",
-      ".agents/skills/",
-      ".agents/templates/",
-      ".agents/workflows/",
-      ".agents/workspace/README.md",
-      ".claude/commands/",
-      ".codex/hooks.json",
-      ".gemini/commands/",
-      ".git-hooks/check-large-files.cjs",
-      ".git-hooks/check-version-format.sh",
-      ".github/scripts/",
-      ".github/workflows/metadata-sync.yml",
-      ".github/workflows/pr-label.yml",
-      ".github/workflows/status-label.yml",
-      ".opencode/commands/"
-    ],
-    "guardedManaged": [
-      ".github/workflows/metadata-sync.yml",
-      ".github/workflows/pr-label.yml",
-      ".github/workflows/status-label.yml"
-    ],
-    "merged": [
-      "**/post-release.*",
-      "**/release.*",
-      "**/test-integration.*",
-      "**/test.*",
-      "**/upgrade-dependency.*",
-      ".agents/rules/testing-discipline.*",
-      ".agents/skills/post-release/SKILL.*",
-      ".agents/skills/release/SKILL.*",
-      ".agents/skills/test-integration/SKILL.*",
-      ".agents/skills/test/SKILL.*",
-      ".agents/skills/upgrade-dependency/SKILL.*",
-      ".claude/settings.json",
-      ".gemini/settings.json",
-      ".git-hooks/pre-commit",
-      ".gitignore"
-    ],
-    "ejected": []
-  }
 }