@phnx-labs/agents-cli 1.18.1 → 1.18.2

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

@@ -0,0 +1,11 @@
+/**
+ * Plugins staleness — one directory per plugin, marker file is
+ * `.claude-plugin/plugin.json`. First-wins across project > user > system
+ * > extras. Fingerprints the entire plugin root (skills, commands, hooks,
+ * etc. live INSIDE the plugin dir, so a content fingerprint covers them).
+ *
+ * Not tracked in v1 manifests; same one-time re-sync trade-off as workflows.
+ */
+import type { PluginEntry } from '../types.js';
+import type { TypedResourceChecker } from './types.js';
+export declare const pluginsChecker: TypedResourceChecker<PluginEntry>;

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

@@ -0,0 +1,39 @@
+/**
+ * Plugins staleness — one directory per plugin, marker file is
+ * `.claude-plugin/plugin.json`. First-wins across project > user > system
+ * > extras. Fingerprints the entire plugin root (skills, commands, hooks,
+ * etc. live INSIDE the plugin dir, so a content fingerprint covers them).
+ *
+ * Not tracked in v1 manifests; same one-time re-sync trade-off as workflows.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { firstWinsLayers, listAcrossLayers, resolveByName } from '../layers.js';
+import { fingerprintDir, isDirStale } from '../fingerprint.js';
+function isPluginDir(full) {
+    try {
+        return fs.statSync(full).isDirectory()
+            && fs.existsSync(path.join(full, '.claude-plugin', 'plugin.json'));
+    }
+    catch {
+        return false;
+    }
+}
+export const pluginsChecker = {
+    type: 'plugins',
+    listNames(cwd) {
+        return listAcrossLayers(firstWinsLayers(cwd), 'plugins', (_, full) => isPluginDir(full));
+    },
+    build(name, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('plugins', name), isPluginDir);
+        if (!resolved)
+            return null;
+        return { dirPath: resolved.path, files: fingerprintDir(resolved.path) };
+    },
+    isFresh(name, stored, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('plugins', name), isPluginDir);
+        if (!resolved)
+            return false;
+        return !isDirStale(stored.dirPath, stored.files, resolved.path);
+    },
+};

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

@@ -0,0 +1,19 @@
+/**
+ * Rules staleness — composed from a layered `rules.yaml` preset definition
+ * plus per-layer `subrules/<name>.md` fragments. Fingerprints exactly the
+ * source files that contribute to the active preset's composed output.
+ *
+ * Bug-fixed from v1: the old `resolveRuleFile` looked for `rules/<preset>.md`,
+ * a path that never exists (presets live in `rules.yaml`, fragments live in
+ * `subrules/`). That made the rules section always report stale. This module
+ * uses `composeRulesFromState` to discover the actual source file set per
+ * preset/cwd, so freshness reflects real source changes.
+ *
+ * Special-cased vs. the other checkers: agent + version are needed to read
+ * the active preset, so this module doesn't conform to ResourceChecker. The
+ * aggregator wires it up explicitly.
+ */
+import type { AgentId } from '../../types.js';
+import type { RulesEntry } from '../types.js';
+export declare function buildRules(agent: AgentId, version: string, cwd: string): RulesEntry;
+export declare function isRulesStale(stored: RulesEntry, agent: AgentId, version: string, cwd: string): boolean;

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

@@ -0,0 +1,86 @@
+/**
+ * Rules staleness — composed from a layered `rules.yaml` preset definition
+ * plus per-layer `subrules/<name>.md` fragments. Fingerprints exactly the
+ * source files that contribute to the active preset's composed output.
+ *
+ * Bug-fixed from v1: the old `resolveRuleFile` looked for `rules/<preset>.md`,
+ * a path that never exists (presets live in `rules.yaml`, fragments live in
+ * `subrules/`). That made the rules section always report stale. This module
+ * uses `composeRulesFromState` to discover the actual source file set per
+ * preset/cwd, so freshness reflects real source changes.
+ *
+ * Special-cased vs. the other checkers: agent + version are needed to read
+ * the active preset, so this module doesn't conform to ResourceChecker. The
+ * aggregator wires it up explicitly.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fingerprintFile, isFileStale } from '../fingerprint.js';
+import { composeRulesFromState } from '../../rules/compose.js';
+import { getActiveRulesPreset, getUserRulesDir, getResolvedRulesDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../../state.js';
+function rulesDirForLayer(scope, cwd) {
+    if (scope === 'project') {
+        const proj = getProjectAgentsDir(cwd);
+        return proj ? path.join(proj, 'rules') : null;
+    }
+    if (scope === 'user')
+        return getUserRulesDir();
+    if (scope === 'system')
+        return getResolvedRulesDir();
+    // extra: first registered extra repo's rules dir. The composer doesn't
+    // disambiguate multi-extra rules.yaml today, so we don't either.
+    const extras = getEnabledExtraRepos();
+    return extras.length > 0 ? path.join(extras[0].dir, 'rules') : null;
+}
+/**
+ * Resolve the set of source files contributing to the active preset's output.
+ * Keys are relative paths within the rules dir (stable across machines).
+ * Values are absolute current paths.
+ */
+function activeSources(agent, version, cwd) {
+    const result = {};
+    let compose;
+    try {
+        const preset = getActiveRulesPreset(agent, version);
+        compose = composeRulesFromState({ preset, cwd });
+    }
+    catch {
+        return result;
+    }
+    const yamlDir = rulesDirForLayer(compose.presetLayer, cwd);
+    if (yamlDir) {
+        const yamlPath = path.join(yamlDir, 'rules.yaml');
+        if (fs.existsSync(yamlPath))
+            result['rules.yaml'] = yamlPath;
+    }
+    for (const sub of compose.subrules) {
+        result[`subrules/${sub.name}.md`] = sub.sourcePath;
+    }
+    return result;
+}
+export function buildRules(agent, version, cwd) {
+    const files = {};
+    for (const [key, srcPath] of Object.entries(activeSources(agent, version, cwd))) {
+        const fp = fingerprintFile(srcPath);
+        if (fp)
+            files[key] = { source: fp };
+    }
+    return { files };
+}
+export function isRulesStale(stored, agent, version, cwd) {
+    const current = activeSources(agent, version, cwd);
+    const storedKeys = Object.keys(stored.files).sort();
+    const currentKeys = Object.keys(current).sort();
+    if (storedKeys.length !== currentKeys.length)
+        return true;
+    for (let i = 0; i < storedKeys.length; i++) {
+        if (storedKeys[i] !== currentKeys[i])
+            return true;
+    }
+    for (const [key, srcPath] of Object.entries(current)) {
+        const entry = stored.files[key];
+        if (!entry || isFileStale(entry.source, srcPath))
+            return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Skills staleness — one directory per skill (must contain SKILL.md),
+ * first-wins across project > user > system > extras.
+ */
+import type { DirEntry } from '../types.js';
+import type { TypedResourceChecker } from './types.js';
+export declare const skillsChecker: TypedResourceChecker<DirEntry>;

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

@@ -0,0 +1,34 @@
+/**
+ * Skills staleness — one directory per skill (must contain SKILL.md),
+ * first-wins across project > user > system > extras.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { firstWinsLayers, listAcrossLayers, resolveByName } from '../layers.js';
+import { fingerprintDir, isDirStale } from '../fingerprint.js';
+function isSkillDir(full) {
+    try {
+        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'SKILL.md'));
+    }
+    catch {
+        return false;
+    }
+}
+export const skillsChecker = {
+    type: 'skills',
+    listNames(cwd) {
+        return listAcrossLayers(firstWinsLayers(cwd), 'skills', (_, full) => isSkillDir(full));
+    },
+    build(name, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('skills', name), isSkillDir);
+        if (!resolved)
+            return null;
+        return { dirPath: resolved.path, files: fingerprintDir(resolved.path) };
+    },
+    isFresh(name, stored, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('skills', name), isSkillDir);
+        if (!resolved)
+            return false;
+        return !isDirStale(stored.dirPath, stored.files, resolved.path);
+    },
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Subagents staleness — one directory per subagent (must contain AGENT.md),
+ * first-wins across project > user > system > extras.
+ *
+ * Bug-fixed from v1: the old manifest derived its name list from
+ * `listInstalledSubagents()` which only walks user + system. With project
+ * subagents in `available.subagents`, the name-set diff always flipped to
+ * "stale". This checker walks all four layers consistently.
+ */
+import type { DirEntry } from '../types.js';
+import type { TypedResourceChecker } from './types.js';
+export declare const subagentsChecker: TypedResourceChecker<DirEntry>;

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

@@ -0,0 +1,39 @@
+/**
+ * Subagents staleness — one directory per subagent (must contain AGENT.md),
+ * first-wins across project > user > system > extras.
+ *
+ * Bug-fixed from v1: the old manifest derived its name list from
+ * `listInstalledSubagents()` which only walks user + system. With project
+ * subagents in `available.subagents`, the name-set diff always flipped to
+ * "stale". This checker walks all four layers consistently.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { firstWinsLayers, listAcrossLayers, resolveByName } from '../layers.js';
+import { fingerprintDir, isDirStale } from '../fingerprint.js';
+function isSubagentDir(full) {
+    try {
+        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'AGENT.md'));
+    }
+    catch {
+        return false;
+    }
+}
+export const subagentsChecker = {
+    type: 'subagents',
+    listNames(cwd) {
+        return listAcrossLayers(firstWinsLayers(cwd), 'subagents', (_, full) => isSubagentDir(full));
+    },
+    build(name, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('subagents', name), isSubagentDir);
+        if (!resolved)
+            return null;
+        return { dirPath: resolved.path, files: fingerprintDir(resolved.path) };
+    },
+    isFresh(name, stored, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('subagents', name), isSubagentDir);
+        if (!resolved)
+            return false;
+        return !isDirStale(stored.dirPath, stored.files, resolved.path);
+    },
+};

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

@@ -0,0 +1,44 @@
+/**
+ * Contract every resource staleness checker implements. Each checker owns
+ * the layer-resolution and entry-shape rules for one resource type. The
+ * aggregator in `../index.ts` doesn't know any of those details — it just
+ * calls these three methods.
+ *
+ * Why three methods (not just "isStale"):
+ *   - `listNames`   feeds both the manifest writer (what to record) and the
+ *     name-set diff (`stored` vs. `current` reveals adds/removes).
+ *   - `build`       produces the entry for a single name; called per name
+ *     after listing. Pure — no comparison logic.
+ *   - `isFresh`     checks one stored entry against current state; called
+ *     when the name set already matches and we need content-level certainty.
+ *
+ * The `unknown` entry type is intentional — each checker round-trips its
+ * own concrete shape through JSON (commands/hooks/mcp use FileEntry; skills
+ * /subagents/workflows/plugins use DirEntry; rules/permissions use their
+ * own composite entries).
+ */
+export interface ResourceChecker {
+    /** Stable identifier; matches the manifest field name. */
+    readonly type: string;
+    /** Names of every resource currently available across this checker's layers. */
+    listNames(cwd: string): string[];
+    /**
+     * Build a manifest entry for one name. Returns null when no source file is
+     * found — the aggregator drops nulls so name-set diff stays accurate.
+     */
+    build(name: string, cwd: string): unknown | null;
+    /**
+     * Check whether a stored entry still reflects current source. Called only
+     * after the name-set already matches. Returns true when fresh, false when
+     * the entry should trigger a re-sync.
+     */
+    isFresh(name: string, stored: unknown, cwd: string): boolean;
+}
+/**
+ * Helper for checkers whose entry shape varies. Strict-typed convenience
+ * wrapper that callers can use to avoid `unknown` casts in their own code.
+ */
+export interface TypedResourceChecker<TEntry> extends ResourceChecker {
+    build(name: string, cwd: string): TEntry | null;
+    isFresh(name: string, stored: TEntry, cwd: string): boolean;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Contract every resource staleness checker implements. Each checker owns
+ * the layer-resolution and entry-shape rules for one resource type. The
+ * aggregator in `../index.ts` doesn't know any of those details — it just
+ * calls these three methods.
+ *
+ * Why three methods (not just "isStale"):
+ *   - `listNames`   feeds both the manifest writer (what to record) and the
+ *     name-set diff (`stored` vs. `current` reveals adds/removes).
+ *   - `build`       produces the entry for a single name; called per name
+ *     after listing. Pure — no comparison logic.
+ *   - `isFresh`     checks one stored entry against current state; called
+ *     when the name set already matches and we need content-level certainty.
+ *
+ * The `unknown` entry type is intentional — each checker round-trips its
+ * own concrete shape through JSON (commands/hooks/mcp use FileEntry; skills
+ * /subagents/workflows/plugins use DirEntry; rules/permissions use their
+ * own composite entries).
+ */
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ * Workflows staleness — one directory per workflow (must contain
+ * WORKFLOW.md), first-wins across project > user > system > extras.
+ *
+ * Not tracked in v1 manifests; treated as a new section that's empty on old
+ * files, which causes one re-sync (filling the field) and then steady-state.
+ */
+import type { DirEntry } from '../types.js';
+import type { TypedResourceChecker } from './types.js';
+export declare const workflowsChecker: TypedResourceChecker<DirEntry>;

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

@@ -0,0 +1,37 @@
+/**
+ * Workflows staleness — one directory per workflow (must contain
+ * WORKFLOW.md), first-wins across project > user > system > extras.
+ *
+ * Not tracked in v1 manifests; treated as a new section that's empty on old
+ * files, which causes one re-sync (filling the field) and then steady-state.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { firstWinsLayers, listAcrossLayers, resolveByName } from '../layers.js';
+import { fingerprintDir, isDirStale } from '../fingerprint.js';
+function isWorkflowDir(full) {
+    try {
+        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'WORKFLOW.md'));
+    }
+    catch {
+        return false;
+    }
+}
+export const workflowsChecker = {
+    type: 'workflows',
+    listNames(cwd) {
+        return listAcrossLayers(firstWinsLayers(cwd), 'workflows', (_, full) => isWorkflowDir(full));
+    },
+    build(name, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('workflows', name), isWorkflowDir);
+        if (!resolved)
+            return null;
+        return { dirPath: resolved.path, files: fingerprintDir(resolved.path) };
+    },
+    isFresh(name, stored, cwd) {
+        const resolved = resolveByName(firstWinsLayers(cwd), path.join('workflows', name), isWorkflowDir);
+        if (!resolved)
+            return false;
+        return !isDirStale(stored.dirPath, stored.files, resolved.path);
+    },
+};

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

@@ -0,0 +1,38 @@
+/**
+ * File and directory fingerprinting primitives shared by every resource
+ * checker. Two-tier comparison: stat (mtime+size) first for the hot path,
+ * sha256 only on miss.
+ */
+/** Fingerprint of a single source file. */
+export interface Fingerprint {
+    path: string;
+    mtime: number;
+    size: number;
+    sha256: string;
+}
+export declare function sha256(content: string): string;
+/** Fingerprint a single file. Returns null when the file is unreadable. */
+export declare function fingerprintFile(filePath: string): Fingerprint | null;
+/**
+ * Fingerprint all files in a directory recursively. Returned sorted by
+ * absolute path so ordering is deterministic regardless of readdir order.
+ * Noise entries (see `FINGERPRINT_SKIP`) are excluded.
+ */
+export declare function fingerprintDir(dirPath: string): Fingerprint[];
+/** Hot-path file staleness: stat-only when mtime+size match, sha256 on miss. */
+export declare function isFileStale(stored: Fingerprint, currentPath: string): boolean;
+/**
+ * Hot-path directory staleness. Compares sorted paths first (catches add /
+ * remove / rename), then stat each file (skips reads when mtime+size match),
+ * sha256 only on stat mismatch.
+ */
+export declare function isDirStale(storedDirPath: string, storedFiles: Fingerprint[], currentDirPath: string): boolean;
+/**
+ * Walk a directory and return sorted absolute paths of every regular file.
+ * No content reads. Uses the same FINGERPRINT_SKIP allowlist as
+ * `fingerprintDir` so both produce the same path set (required for the
+ * dir-stale path comparison to work).
+ */
+export declare function walkDirPaths(dirPath: string): string[];
+/** True if two sorted-or-unsorted name sets differ. */
+export declare function nameSetDiffers(a: string[], b: string[]): boolean;

package/dist/lib/staleness/fingerprint.js

@@ -0,0 +1,154 @@
+/**
+ * File and directory fingerprinting primitives shared by every resource
+ * checker. Two-tier comparison: stat (mtime+size) first for the hot path,
+ * sha256 only on miss.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+export function sha256(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+/** Fingerprint a single file. Returns null when the file is unreadable. */
+export function fingerprintFile(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return { path: filePath, mtime: stat.mtimeMs, size: stat.size, sha256: sha256(content) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Names we never fingerprint: OS metadata, VCS bookkeeping, dep caches,
+ * build outputs. Matches the SKILL_COPY_IGNORE set used by the sync writer
+ * in `src/lib/versions.ts`.
+ *
+ * Important: this is an allowlist of noise, NOT a blanket "skip every
+ * dot-prefixed entry". Plugins keep their manifest at
+ * `.claude-plugin/plugin.json` — a dot-prefix skip would make plugin
+ * manifests invisible to the fingerprint and silently break staleness
+ * detection for plugins.
+ */
+const FINGERPRINT_SKIP = new Set([
+    '.DS_Store',
+    '.git',
+    '.gitignore',
+    '.venv',
+    '__pycache__',
+    'node_modules',
+]);
+/**
+ * Fingerprint all files in a directory recursively. Returned sorted by
+ * absolute path so ordering is deterministic regardless of readdir order.
+ * Noise entries (see `FINGERPRINT_SKIP`) are excluded.
+ */
+export function fingerprintDir(dirPath) {
+    const results = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (FINGERPRINT_SKIP.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile()) {
+                const fp = fingerprintFile(full);
+                if (fp)
+                    results.push(fp);
+            }
+        }
+    }
+    walk(dirPath);
+    results.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    return results;
+}
+/** Hot-path file staleness: stat-only when mtime+size match, sha256 on miss. */
+export function isFileStale(stored, currentPath) {
+    if (stored.path !== currentPath)
+        return true;
+    try {
+        const stat = fs.statSync(currentPath);
+        if (stat.mtimeMs === stored.mtime && stat.size === stored.size)
+            return false;
+        return sha256(fs.readFileSync(currentPath, 'utf-8')) !== stored.sha256;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Hot-path directory staleness. Compares sorted paths first (catches add /
+ * remove / rename), then stat each file (skips reads when mtime+size match),
+ * sha256 only on stat mismatch.
+ */
+export function isDirStale(storedDirPath, storedFiles, currentDirPath) {
+    if (storedDirPath !== currentDirPath)
+        return true;
+    const currentPaths = walkDirPaths(currentDirPath);
+    if (currentPaths.length !== storedFiles.length)
+        return true;
+    for (let i = 0; i < currentPaths.length; i++) {
+        const stored = storedFiles[i];
+        const cur = currentPaths[i];
+        if (stored.path !== cur)
+            return true;
+        try {
+            const stat = fs.statSync(cur);
+            if (stat.mtimeMs === stored.mtime && stat.size === stored.size)
+                continue;
+            if (sha256(fs.readFileSync(cur, 'utf-8')) !== stored.sha256)
+                return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Walk a directory and return sorted absolute paths of every regular file.
+ * No content reads. Uses the same FINGERPRINT_SKIP allowlist as
+ * `fingerprintDir` so both produce the same path set (required for the
+ * dir-stale path comparison to work).
+ */
+export function walkDirPaths(dirPath) {
+    const results = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (FINGERPRINT_SKIP.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile())
+                results.push(full);
+        }
+    }
+    walk(dirPath);
+    results.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    return results;
+}
+/** True if two sorted-or-unsorted name sets differ. */
+export function nameSetDiffers(a, b) {
+    if (a.length !== b.length)
+        return true;
+    const sortedA = [...a].sort();
+    const sortedB = [...b].sort();
+    return sortedA.some((n, i) => n !== sortedB[i]);
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Staleness library entrypoint. Aggregates per-resource checkers into the
+ * two operations the rest of the codebase needs:
+ *
+ *   - `buildManifest(agent, version, cwd)` — snapshot current state.
+ *   - `isStale(manifest, agent, version, cwd)` — true when any tracked
+ *     resource has drifted from its stored fingerprint.
+ *
+ * `loadManifest` / `saveManifest` round-trip the on-disk JSON. The format
+ * version stays at 1; new optional fields (workflows, plugins) on old files
+ * read as empty maps which forces a single re-sync.
+ */
+import type { AgentId } from '../types.js';
+import { type SyncManifest, type FileEntry, type DirEntry, type PluginEntry, type RulesEntry } from './types.js';
+export type { SyncManifest } from './types.js';
+export { MANIFEST_VERSION } from './types.js';
+export declare function loadManifest(agent: AgentId, version: string): SyncManifest | null;
+export declare function saveManifest(agent: AgentId, version: string, manifest: SyncManifest): void;
+export declare function buildManifest(agent: AgentId, version: string, cwd: string): SyncManifest;
+/**
+ * True when any tracked resource has drifted from the stored manifest.
+ * Walks every resource type in turn and returns true at the first miss —
+ * sync detection should be cheap when nothing changed.
+ */
+export declare function isStale(manifest: SyncManifest, agent: AgentId, version: string, cwd: string): boolean;
+export type { FileEntry, DirEntry, PluginEntry, RulesEntry };