@phnx-labs/agents-cli 1.20.4 → 1.20.5

package/dist/lib/staleness/detectors/permissions.js

@@ -0,0 +1,201 @@
+/**
+ * Permissions detector — inspects the agent's native permission storage and
+ * reports the permission GROUP names that have been applied.
+ *
+ * For claude/opencode the detector intersects with discovered groups (a group
+ * is "applied" if any of its allow/deny rules are present). For Codex / Gemini /
+ * Antigravity / Grok the on-disk format is lossy — once any group has been
+ * applied the storage doesn't carry per-group provenance back, so we report
+ * "all known groups applied" when any permission artifact is present. This
+ * matches the existing behavior in versions.ts:445-518 (extended to the
+ * agents that were previously silent-skipped).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as TOML from 'smol-toml';
+import { capableAgents } from '../../capabilities.js';
+import { discoverPermissionGroups, buildPermissionsFromGroups, CODEX_RULES_FILENAME, } from '../../permissions.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildClaudeDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'claude',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.claude', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const allowRules = settings.permissions?.allow || [];
+                const denyRules = settings.permissions?.deny || [];
+                if (allowRules.length === 0 && denyRules.length === 0)
+                    return [];
+                const groups = discoverPermissionGroups();
+                const applied = [];
+                for (const group of groups) {
+                    const built = buildPermissionsFromGroups([group.name]);
+                    // Empty groups (header files) count as synced when anything is applied.
+                    if (built.allow.length === 0 && (!built.deny || built.deny.length === 0)) {
+                        applied.push(group.name);
+                        continue;
+                    }
+                    const hasAllow = built.allow.some(r => allowRules.includes(r));
+                    const hasDeny = built.deny?.some(r => denyRules.includes(r)) || false;
+                    if (hasAllow || hasDeny)
+                        applied.push(group.name);
+                }
+                return applied;
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}
+function buildCodexDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'codex',
+        list({ versionHome }) {
+            const codexConfigPath = path.join(versionHome, '.codex', 'config.toml');
+            const codexRulesPath = path.join(versionHome, '.codex', 'rules', CODEX_RULES_FILENAME);
+            const hasConfig = fs.existsSync(codexConfigPath);
+            const hasRules = fs.existsSync(codexRulesPath);
+            if (!hasConfig && !hasRules)
+                return [];
+            try {
+                let hasPermKeys = false;
+                if (hasConfig) {
+                    const config = TOML.parse(fs.readFileSync(codexConfigPath, 'utf-8'));
+                    hasPermKeys = !!(config.approval_policy || config.sandbox_mode || config.sandbox_workspace_write);
+                }
+                if (hasPermKeys || hasRules) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildOpenCodeDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'opencode',
+        list({ versionHome }) {
+            const opencodeConfigPath = path.join(versionHome, '.opencode', 'opencode.jsonc');
+            if (!fs.existsSync(opencodeConfigPath))
+                return [];
+            try {
+                const content = fs.readFileSync(opencodeConfigPath, 'utf-8');
+                const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                const config = JSON.parse(stripped);
+                if (config.permission && Object.keys(config.permission.bash || {}).length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildGeminiDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'gemini',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.gemini', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const allowed = settings?.tools?.allowed;
+                if (Array.isArray(allowed) && allowed.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildAntigravityDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'antigravity',
+        list({ versionHome }) {
+            const settingsPath = path.join(versionHome, '.gemini', 'antigravity-cli', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return [];
+            try {
+                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                const perms = settings?.permissions;
+                const hasAllow = Array.isArray(perms?.allow) && perms.allow.length > 0;
+                const hasDeny = Array.isArray(perms?.deny) && perms.deny.length > 0;
+                if (hasAllow || hasDeny) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildGrokDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'grok',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.grok', 'config.toml');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+                const perm = config.permission;
+                if (perm && Array.isArray(perm.rules) && perm.rules.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+function buildKimiDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'kimi',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.kimi-code', 'config.toml');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
+                const perm = config.permission;
+                if (perm && Array.isArray(perm.rules) && perm.rules.length > 0) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
+const handlers = {
+    claude: buildClaudeDetector,
+    codex: buildCodexDetector,
+    opencode: buildOpenCodeDetector,
+    gemini: buildGeminiDetector,
+    antigravity: buildAntigravityDetector,
+    grok: buildGrokDetector,
+    kimi: buildKimiDetector,
+};
+export const permissionsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('allowlist')) {
+        const f = handlers[agent];
+        if (f)
+            m[agent] = f();
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/plugins.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Plugins detector — for each discovered plugin, ask `isPluginSynced` whether
+ * its expected artifacts are present in the version home. Mirrors
+ * versions.ts:541-549.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const pluginsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/plugins.js

@@ -0,0 +1,23 @@
+import { capableAgents } from '../../capabilities.js';
+import { discoverPlugins, isPluginSynced } from '../../plugins.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildPluginsDetector(agent) {
+    return {
+        kind: 'plugins',
+        agent,
+        list({ versionHome }) {
+            const synced = [];
+            for (const plugin of discoverPlugins()) {
+                if (isPluginSynced(plugin, agent, versionHome))
+                    synced.push(plugin.name);
+            }
+            return synced;
+        },
+    };
+}
+export const pluginsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('plugins'))
+        m[agent] = buildPluginsDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/rules.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const rulesDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/rules.js

@@ -0,0 +1,34 @@
+/**
+ * Rules detector — reports whether the composed instructions file exists in
+ * the version home. Uses the active rules preset name as the detected
+ * "resource name" so the diff stays meaningful (one preset = one synced
+ * name, mirroring what getAvailableResources surfaces under `memory`).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { capableAgents } from '../../capabilities.js';
+import { getActiveRulesPreset } from '../../state.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildRulesDetector(agent) {
+    return {
+        kind: 'rules',
+        agent,
+        list({ version, versionHome }) {
+            const cap = AGENTS[agent].capabilities.rules;
+            if (cap === false)
+                return [];
+            const agentDir = path.join(versionHome, agentConfigDirName(agent));
+            const instrFile = path.join(agentDir, cap.file);
+            if (!fs.existsSync(instrFile))
+                return [];
+            return [getActiveRulesPreset(agent, version)];
+        },
+    };
+}
+export const rulesDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('rules'))
+        m[agent] = buildRulesDetector(agent);
+    return m;
+});

package/dist/lib/staleness/detectors/skills.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const skillsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/skills.js

@@ -0,0 +1,71 @@
+/**
+ * Skills detector — names of skill directories materialized in the version
+ * home that match the central source content. Mirrors versions.ts:359-389.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS, agentConfigDirName } from '../../agents.js';
+import { capableAgents } from '../../capabilities.js';
+import { resolveSkillSource } from '../writers/sources.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+const SKILL_COPY_IGNORE = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
+function skillDirsMatch(src, dest) {
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        if (SKILL_COPY_IGNORE.has(entry.name))
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            if (!fs.existsSync(destPath))
+                return false;
+            if (!skillDirsMatch(srcPath, destPath))
+                return false;
+        }
+        else {
+            if (!fs.existsSync(destPath))
+                return false;
+            if (fs.readFileSync(srcPath, 'utf-8') !== fs.readFileSync(destPath, 'utf-8'))
+                return false;
+        }
+    }
+    return true;
+}
+function buildSkillsDetector(agent) {
+    return {
+        kind: 'skills',
+        agent,
+        list({ versionHome }) {
+            const skillsDir = path.join(versionHome, agentConfigDirName(agent), 'skills');
+            if (!fs.existsSync(skillsDir))
+                return [];
+            const installed = fs.readdirSync(skillsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => d.name);
+            const synced = [];
+            for (const name of installed) {
+                const src = resolveSkillSource(name);
+                if (!src) {
+                    // True orphan — no source. Still count so cleanup knows it's accounted for.
+                    synced.push(name);
+                    continue;
+                }
+                if (skillDirsMatch(src, path.join(skillsDir, name))) {
+                    synced.push(name);
+                }
+            }
+            return synced;
+        },
+    };
+}
+export const skillsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('skills')) {
+        if (AGENTS[agent].nativeAgentsSkillsDir)
+            continue;
+        m[agent] = buildSkillsDetector(agent);
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/subagents.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const subagentsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/subagents.js

@@ -0,0 +1,50 @@
+/**
+ * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
+ * Mirrors versions.ts:521-539.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildClaudeDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'claude',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.claude', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.md'))
+                .map(f => f.replace('.md', ''));
+        },
+    };
+}
+function buildOpenclawDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'openclaw',
+        list({ versionHome }) {
+            const openclawDir = path.join(versionHome, '.openclaw');
+            if (!fs.existsSync(openclawDir))
+                return [];
+            return fs.readdirSync(openclawDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(openclawDir, d.name, 'AGENTS.md')))
+                .map(d => d.name);
+        },
+    };
+}
+const handlers = {
+    claude: buildClaudeDetector,
+    openclaw: buildOpenclawDetector,
+};
+export const subagentsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('subagents')) {
+        const f = handlers[agent];
+        if (f)
+            m[agent] = f();
+    }
+    return m;
+});

package/dist/lib/staleness/detectors/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-(kind, agent) detector contract.
+ *
+ * A detector inspects a version home and reports which resource names of a
+ * given kind are materialized there. The aggregator at
+ * `getActuallySyncedResources` calls one detector per kind/agent pair to build
+ * the "what is actually on disk" view, which is then diffed against
+ * "what is available" to drive the resource prompt in `agents view`.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceKind } from '../writers/kinds.js';
+export interface DetectArgs {
+    version: string;
+    versionHome: string;
+    /** Working directory — needed by detectors that resolve project state. */
+    cwd: string;
+}
+export interface ResourceDetector {
+    readonly kind: ResourceKind;
+    readonly agent: AgentId;
+    list(args: DetectArgs): string[];
+}

package/dist/lib/staleness/detectors/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/staleness/detectors/workflows.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceDetector } from './types.js';
+export declare const workflowsDetectors: Partial<Record<AgentId, ResourceDetector>>;

package/dist/lib/staleness/detectors/workflows.js

@@ -0,0 +1,28 @@
+/**
+ * Workflows detector — scans `{versionHome}/workflows/` for subdirectories
+ * containing WORKFLOW.md. Mirrors versions.ts:551-558.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { lazyAgentMap } from '../writers/lazy-map.js';
+function buildWorkflowsDetector(agent) {
+    return {
+        kind: 'workflows',
+        agent,
+        list({ versionHome }) {
+            const workflowsDir = path.join(versionHome, 'workflows');
+            if (!fs.existsSync(workflowsDir))
+                return [];
+            return fs.readdirSync(workflowsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(workflowsDir, d.name, 'WORKFLOW.md')))
+                .map(d => d.name);
+        },
+    };
+}
+export const workflowsDetectors = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('workflows'))
+        m[agent] = buildWorkflowsDetector(agent);
+    return m;
+});

package/dist/lib/staleness/registry.d.ts

@@ -0,0 +1,26 @@
+import type { AgentId } from '../types.js';
+import { type ResourceKind } from './writers/kinds.js';
+import type { ResourceWriter } from './writers/types.js';
+import type { ResourceDetector } from './detectors/types.js';
+import type { RulesSelection } from './writers/rules.js';
+export type { ResourceKind } from './writers/kinds.js';
+export { kindToCapability, ALL_RESOURCE_KINDS } from './writers/kinds.js';
+export type { ResourceWriter, WriteArgs, WriteResult } from './writers/types.js';
+export type { ResourceDetector, DetectArgs } from './detectors/types.js';
+export type { RulesSelection } from './writers/rules.js';
+/** Per-kind selection payload. Most kinds are string[]; rules is special. */
+export type SelectionFor<K extends ResourceKind> = K extends 'rules' ? RulesSelection : string[];
+export declare const WRITERS: Record<ResourceKind, Partial<Record<AgentId, ResourceWriter<any>>>>;
+export declare const DETECTORS: Record<ResourceKind, Partial<Record<AgentId, ResourceDetector>>>;
+/**
+ * Verify every supported (agent, kind) pair has both a writer and a
+ * detector. Deferred from module-import time to the first `getWriter` /
+ * `getDetector` call to dodge the agents.ts ↔ versions.ts ↔ registry.ts
+ * import cycle (the same one the lazy writer/detector maps work around).
+ * Idempotent — runs at most once per process.
+ */
+export declare function assertRegistryComplete(): void;
+/** Return the writer for (kind, agent), or undefined if unsupported. */
+export declare function getWriter<K extends ResourceKind>(kind: K, agent: AgentId): ResourceWriter<SelectionFor<K>> | undefined;
+/** Return the detector for (kind, agent), or undefined if unsupported. */
+export declare function getDetector(kind: ResourceKind, agent: AgentId): ResourceDetector | undefined;

package/dist/lib/staleness/registry.js

@@ -0,0 +1,123 @@
+/**
+ * Writer + detector registry for resource sync.
+ *
+ * Two parallel maps keyed by (ResourceKind, AgentId). At module import time
+ * (which fires once when the CLI boots) we verify that EVERY supported
+ * (agent, kind) pair has both a writer and a detector. Missing entries
+ * throw immediately — silent-skip bugs become startup errors.
+ *
+ *   - Adding a new agent? Either declare every supported kind with a writer
+ *     here OR mark the kind `false` in `AgentConfig.capabilities`.
+ *   - Adding a new kind? Declare it on every agent's capabilities and add a
+ *     writer module.
+ *
+ * The capability matrix in `lib/agents.ts:AGENTS` is the single source of
+ * truth for "is this (agent, kind) supported?". The assertion below maps the
+ * matrix to required registry entries.
+ */
+import { AGENTS } from '../agents.js';
+import { supports } from '../capabilities.js';
+import { ALL_RESOURCE_KINDS, kindToCapability, } from './writers/kinds.js';
+import { commandsWriters } from './writers/commands.js';
+import { skillsWriters } from './writers/skills.js';
+import { hooksWriters } from './writers/hooks.js';
+import { rulesWriters } from './writers/rules.js';
+import { mcpWriters } from './writers/mcp.js';
+import { permissionsWriters } from './writers/permissions.js';
+import { subagentsWriters } from './writers/subagents.js';
+import { pluginsWriters } from './writers/plugins.js';
+import { workflowsWriters } from './writers/workflows.js';
+import { commandsDetectors } from './detectors/commands.js';
+import { skillsDetectors } from './detectors/skills.js';
+import { hooksDetectors } from './detectors/hooks.js';
+import { rulesDetectors } from './detectors/rules.js';
+import { mcpDetectors } from './detectors/mcp.js';
+import { permissionsDetectors } from './detectors/permissions.js';
+import { subagentsDetectors } from './detectors/subagents.js';
+import { pluginsDetectors } from './detectors/plugins.js';
+import { workflowsDetectors } from './detectors/workflows.js';
+export { kindToCapability, ALL_RESOURCE_KINDS } from './writers/kinds.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const WRITERS = {
+    commands: commandsWriters,
+    skills: skillsWriters,
+    hooks: hooksWriters,
+    rules: rulesWriters,
+    mcp: mcpWriters,
+    permissions: permissionsWriters,
+    subagents: subagentsWriters,
+    plugins: pluginsWriters,
+    workflows: workflowsWriters,
+};
+/* eslint-enable @typescript-eslint/no-explicit-any */
+export const DETECTORS = {
+    commands: commandsDetectors,
+    skills: skillsDetectors,
+    hooks: hooksDetectors,
+    rules: rulesDetectors,
+    mcp: mcpDetectors,
+    permissions: permissionsDetectors,
+    subagents: subagentsDetectors,
+    plugins: pluginsDetectors,
+    workflows: workflowsDetectors,
+};
+/**
+ * Kinds excluded from the assertion. Skills + native-skills-dir agents are
+ * the only legitimate gap — Gemini reads `~/.agents/skills/` natively, so
+ * it deliberately has no per-version writer/detector. The orchestrator
+ * handles that case by clearing the version-home skills dir before launch.
+ * Anywhere else, a missing entry is a real bug.
+ */
+function isExempt(agent, kind) {
+    if (kind === 'skills' && AGENTS[agent].nativeAgentsSkillsDir)
+        return true;
+    return false;
+}
+let assertionFired = false;
+/**
+ * Verify every supported (agent, kind) pair has both a writer and a
+ * detector. Deferred from module-import time to the first `getWriter` /
+ * `getDetector` call to dodge the agents.ts ↔ versions.ts ↔ registry.ts
+ * import cycle (the same one the lazy writer/detector maps work around).
+ * Idempotent — runs at most once per process.
+ */
+export function assertRegistryComplete() {
+    if (assertionFired)
+        return;
+    assertionFired = true;
+    const missing = [];
+    for (const kind of ALL_RESOURCE_KINDS) {
+        const cap = kindToCapability(kind);
+        for (const agent of Object.keys(AGENTS)) {
+            if (!supports(agent, cap).ok)
+                continue;
+            if (isExempt(agent, kind))
+                continue;
+            const lacks = [];
+            if (!WRITERS[kind][agent])
+                lacks.push('writer');
+            if (!DETECTORS[kind][agent])
+                lacks.push('detector');
+            if (lacks.length > 0)
+                missing.push({ kind, agent, missing: lacks });
+        }
+    }
+    if (missing.length > 0) {
+        const detail = missing
+            .map((m) => `  - ${m.kind}/${m.agent}: missing ${m.missing.join(' and ')}`)
+            .join('\n');
+        throw new Error(`staleness/registry: missing required (kind, agent) entries:\n${detail}\n` +
+            `Fix: register the entry in src/lib/staleness/{writers,detectors}/<kind>.ts, OR ` +
+            `mark the capability false in AGENTS.${missing[0].agent}.capabilities.`);
+    }
+}
+/** Return the writer for (kind, agent), or undefined if unsupported. */
+export function getWriter(kind, agent) {
+    assertRegistryComplete();
+    return WRITERS[kind][agent];
+}
+/** Return the detector for (kind, agent), or undefined if unsupported. */
+export function getDetector(kind, agent) {
+    assertRegistryComplete();
+    return DETECTORS[kind][agent];
+}

package/dist/lib/staleness/writers/commands.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceWriter } from './types.js';
+export declare const commandsWriters: Partial<Record<AgentId, ResourceWriter<string[]>>>;