@vortex-os/base 0.0.1 → 0.2.3

package/dist/index.d.ts

@@ -1,24 +1,2970 @@
+import { vector, recall, sessionArchive } from '@vortex-os/memory-extended';
+
 /**
- * @vortex-os/base — base framework entry point for VortEX.
- *
- * This is the initial release (0.0.1). The full v0.1.0 will aggregate the
- * framework modules (core, slash-commands, til, decision-log, memory-system,
- * runbooks, data-lint, link-rewriter, index-generator, report-generator,
- * ai-coding-pitfalls, tool-rules, session-rituals) into a single importable
- * surface, plus an add-on discovery hook. See
- * https://github.com/dydan77/vortex/blob/main/docs/phase-10-split-plan.md
- * (Phase 10 split plan v2 — capability-cluster) for the shape.
- *
- * Until v0.1.0 lands, this package exposes framework metadata only.
- */
-export declare const VORTEX_BASE_VERSION: "0.0.1";
-/** Framework metadata available at install time, without pulling in any module. */
-export interface VortexFrameworkMeta {
-    readonly version: string;
-    readonly framework: "vortex-os";
-    readonly fullReleaseTarget: string;
-    readonly designReference: string;
-    readonly repository: string;
-}
-export declare const FRAMEWORK_META: VortexFrameworkMeta;
-//# sourceMappingURL=index.d.ts.map
+ * Three-tier privacy classification used across VortEX.
+ *
+ * - `public`   — safe to share with anyone, including in published repositories.
+ * - `internal` — visible to the operator and their organization; not for public release.
+ * - `personal` — personal data; never shared, never published.
+ */
+declare const Privacy: {
+    readonly Public: "public";
+    readonly Internal: "internal";
+    readonly Personal: "personal";
+};
+type Privacy = (typeof Privacy)[keyof typeof Privacy];
+/**
+ * Parsed markdown document with separated YAML frontmatter and body.
+ */
+interface FrontmatterDoc<T = Record<string, unknown>> {
+    frontmatter: T & {
+        privacy?: Privacy;
+    };
+    body: string;
+}
+/**
+ * Resolved paths for a VortEX repository root.
+ *
+ * Every module receives a `ModuleContext` from the host (CLI, plugin runtime,
+ * or test harness) and resolves its own paths against it. Modules must not
+ * derive paths by string manipulation against an assumed layout.
+ */
+interface ModuleContext {
+    repoRoot: string;
+    agentDir: string;
+    dataDir: string;
+    modulesDir: string;
+    pluginsDir: string;
+}
+
+/**
+ * Parse a markdown source into its YAML frontmatter and body. If no frontmatter
+ * fence is present, returns an empty frontmatter object and the source unchanged.
+ *
+ * A leading UTF-8 BOM is stripped before matching. Windows-authored files
+ * frequently begin with ``, which would otherwise prevent the fence
+ * regex from anchoring to `---` at byte 0.
+ */
+declare function parseFrontmatter<T = Record<string, unknown>>(source: string): FrontmatterDoc<T>;
+/**
+ * Serialize a `FrontmatterDoc` back into markdown text. If the frontmatter is
+ * empty, the body is returned unchanged (no empty fence is emitted).
+ */
+declare function serializeFrontmatter<T = Record<string, unknown>>(doc: FrontmatterDoc<T>): string;
+
+/**
+ * Returns true if a document with `docPrivacy` is visible to a viewer authorized
+ * at `viewerPrivacy`. Viewers see content at or below their own level.
+ *
+ * - `public`   viewer sees → public only
+ * - `internal` viewer sees → public + internal
+ * - `personal` viewer sees → all three
+ */
+declare function isVisibleAt(docPrivacy: Privacy, viewerPrivacy: Privacy): boolean;
+/**
+ * Returns the more-restrictive of two privacy levels.
+ * Useful when combining content from multiple sources for sharing.
+ */
+declare function maxPrivacy(a: Privacy, b: Privacy): Privacy;
+/**
+ * Coerce an unknown value (e.g. user input or untyped frontmatter) into a
+ * valid `Privacy`. Falls back to `internal` by default — the safest default
+ * for unclassified content.
+ */
+declare function normalizePrivacy(value: unknown, fallback?: Privacy): Privacy;
+
+/**
+ * Build a `ModuleContext` for the given VortEX repository root. The root is
+ * resolved to an absolute path; standard subdirectories are derived by
+ * convention and are not guaranteed to exist on disk.
+ */
+declare function makeContext(repoRoot: string): ModuleContext;
+/**
+ * Resolve the directory of a named module within the repository.
+ */
+declare function moduleDir(ctx: ModuleContext, moduleName: string): string;
+
+/**
+ * Instance configuration for VortEX, read from `<agentDir>/vortex.json`.
+ *
+ * The config exists to give the user control over the **auto-maintained**
+ * operational behaviors (see `AGENT.md` → "Default behaviors") without
+ * touching code: toggle any auto-record off, and declare how this machine's
+ * environment is detected. A fresh instance has no config file — everything
+ * is on, no environment — so the framework works out of the box and the file
+ * is purely opt-in tuning.
+ */
+/** Which auto-maintained operational records are enabled. Default: all on. */
+interface AutoRecordConfig {
+    readonly sessionStart: boolean;
+    readonly worklog: boolean;
+    readonly decision: boolean;
+    readonly ambientRecall: boolean;
+    /**
+     * Catch-up: at session start, ingest conversation transcripts that have not
+     * been archived yet (the host's own machine only). Text is stored
+     * immediately; vectorization is deferred to recall/rebuild so start stays
+     * fast. Off → no automatic ingest; the archive only grows when explicitly
+     * rebuilt.
+     */
+    readonly archive: boolean;
+}
+/**
+ * One environment label plus the signal that selects it. Rules are evaluated
+ * in order; the first match wins. Generalizes the operator's home/work
+ * `Test-Path` pattern into a portable, declarative form.
+ */
+interface EnvironmentRule {
+    readonly label: string;
+    /** Match when this absolute path exists on the machine. */
+    readonly pathExists?: string;
+    /** Match when the OS hostname equals this (case-insensitive). */
+    readonly hostname?: string;
+    /**
+     * Match when an environment variable is set. A bare string matches on
+     * presence; the object form additionally requires a specific value.
+     */
+    readonly envVar?: string | {
+        readonly name: string;
+        readonly equals?: string;
+    };
+}
+interface VortexConfig {
+    readonly autoRecord: AutoRecordConfig;
+    readonly environments: readonly EnvironmentRule[];
+}
+/** Path of the instance config file: `<agentDir>/vortex.json`. */
+declare function vortexConfigPath(ctx: ModuleContext): string;
+/**
+ * Load the instance config, merged over defaults. A missing, unreadable, or
+ * invalid file yields defaults (everything on, no environments) rather than
+ * throwing — config is opt-in tuning, never a prerequisite.
+ */
+declare function loadVortexConfig(ctx: ModuleContext): VortexConfig;
+/**
+ * Resolve the active environment label from the config rules (first match
+ * wins), or null when none match. Pure — the caller injects the signals
+ * (hostname, env vars, a path-existence probe) so this stays testable and
+ * free of direct OS access.
+ */
+declare function resolveEnvironment(config: VortexConfig, signals: {
+    readonly hostname?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly pathExists?: (p: string) => boolean;
+}): string | null;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$d_AutoRecordConfig = AutoRecordConfig;
+type index_d$d_EnvironmentRule = EnvironmentRule;
+type index_d$d_FrontmatterDoc<T = Record<string, unknown>> = FrontmatterDoc<T>;
+type index_d$d_ModuleContext = ModuleContext;
+type index_d$d_Privacy = Privacy;
+type index_d$d_VortexConfig = VortexConfig;
+declare const index_d$d_isVisibleAt: typeof isVisibleAt;
+declare const index_d$d_loadVortexConfig: typeof loadVortexConfig;
+declare const index_d$d_makeContext: typeof makeContext;
+declare const index_d$d_maxPrivacy: typeof maxPrivacy;
+declare const index_d$d_moduleDir: typeof moduleDir;
+declare const index_d$d_normalizePrivacy: typeof normalizePrivacy;
+declare const index_d$d_parseFrontmatter: typeof parseFrontmatter;
+declare const index_d$d_resolveEnvironment: typeof resolveEnvironment;
+declare const index_d$d_serializeFrontmatter: typeof serializeFrontmatter;
+declare const index_d$d_vortexConfigPath: typeof vortexConfigPath;
+declare namespace index_d$d {
+  export { type index_d$d_AutoRecordConfig as AutoRecordConfig, type index_d$d_EnvironmentRule as EnvironmentRule, type index_d$d_FrontmatterDoc as FrontmatterDoc, type index_d$d_ModuleContext as ModuleContext, type index_d$d_Privacy as Privacy, type index_d$d_VortexConfig as VortexConfig, index_d$d_isVisibleAt as isVisibleAt, index_d$d_loadVortexConfig as loadVortexConfig, index_d$d_makeContext as makeContext, index_d$d_maxPrivacy as maxPrivacy, index_d$d_moduleDir as moduleDir, index_d$d_normalizePrivacy as normalizePrivacy, index_d$d_parseFrontmatter as parseFrontmatter, index_d$d_resolveEnvironment as resolveEnvironment, index_d$d_serializeFrontmatter as serializeFrontmatter, index_d$d_vortexConfigPath as vortexConfigPath };
+}
+
+/**
+ * Declaration of a single argument expected by a command.
+ *
+ * Argument parsing in Phase 2 is positional: arguments are read from the
+ * tokens following the command name, in declaration order. Named flags
+ * (e.g. `--foo bar`) are not handled at this layer — hosts that need them
+ * can pre-process input before calling `runSlash`.
+ */
+interface CommandArg {
+    readonly name: string;
+    readonly description: string;
+    readonly required?: boolean;
+}
+/**
+ * Value passed to a command's handler.
+ *
+ * - `raw` — the full input string with any leading `/` removed.
+ * - `args` — positional arguments matched against the command's declared
+ *   `args` schema, keyed by argument name.
+ * - `rest` — the unparsed trailing portion of the input (everything after
+ *   the command name), provided as-is for commands that prefer to handle
+ *   their own parsing.
+ * - `context` — resolved repository paths from `@vortex-os/core.makeContext`.
+ */
+interface CommandInput {
+    readonly raw: string;
+    readonly args: Readonly<Record<string, string>>;
+    readonly rest: string;
+    readonly context: ModuleContext;
+}
+/**
+ * A registrable, callable command.
+ */
+interface Command<Result = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly args?: readonly CommandArg[];
+    readonly handler: (input: CommandInput) => Result | Promise<Result>;
+}
+
+/**
+ * Holds registered commands and looks them up by name.
+ *
+ * Names are matched exactly. Registering two commands with the same name
+ * is an error — the second call throws. Callers that want to override an
+ * existing command must `unregister` first.
+ */
+declare class CommandRegistry {
+    private readonly commands;
+    register(command: Command): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    get(name: string): Command | undefined;
+    list(): readonly Command[];
+}
+
+interface RunOptions {
+    readonly registry: CommandRegistry;
+    readonly context: ModuleContext;
+}
+/**
+ * Thrown by `runSlash` when the requested command name does not exist
+ * in the registry. The unknown name is exposed for caller diagnostics.
+ */
+declare class CommandNotFoundError extends Error {
+    readonly commandName: string;
+    constructor(commandName: string);
+}
+/**
+ * Parse an input string and dispatch the matching command.
+ *
+ * Accepted forms (leading slash optional):
+ *   "name"
+ *   "/name"
+ *   "name arg1 arg2 ..."
+ *
+ * Returns whatever the command's handler returns (awaited if it is async).
+ */
+declare function runSlash(input: string, { registry, context }: RunOptions): Promise<unknown>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$c_Command<Result = unknown> = Command<Result>;
+type index_d$c_CommandArg = CommandArg;
+type index_d$c_CommandInput = CommandInput;
+type index_d$c_CommandNotFoundError = CommandNotFoundError;
+declare const index_d$c_CommandNotFoundError: typeof CommandNotFoundError;
+type index_d$c_CommandRegistry = CommandRegistry;
+declare const index_d$c_CommandRegistry: typeof CommandRegistry;
+type index_d$c_RunOptions = RunOptions;
+declare const index_d$c_runSlash: typeof runSlash;
+declare namespace index_d$c {
+  export { type index_d$c_Command as Command, type index_d$c_CommandArg as CommandArg, type index_d$c_CommandInput as CommandInput, index_d$c_CommandNotFoundError as CommandNotFoundError, index_d$c_CommandRegistry as CommandRegistry, type index_d$c_RunOptions as RunOptions, index_d$c_runSlash as runSlash };
+}
+
+/**
+ * Canonical memory categories.
+ *
+ * - `user`      — facts about the operator (role, preferences, working style).
+ * - `feedback`  — corrections and validated approaches from the operator.
+ * - `project`   — ongoing work context (goals, deadlines, stakeholders).
+ * - `reference` — pointers to external systems (dashboards, repos, channels).
+ *
+ * Hosts may extend the set, but stability of these four is preserved.
+ */
+declare const MemoryType: {
+    readonly User: "user";
+    readonly Feedback: "feedback";
+    readonly Project: "project";
+    readonly Reference: "reference";
+};
+type MemoryType = (typeof MemoryType)[keyof typeof MemoryType];
+/**
+ * Frontmatter required on every memory file.
+ *
+ * `name` should match the file id (filename without `.md`). `description`
+ * is a single-line summary used in the generated index. `type` places the
+ * memory in one of the canonical categories. Additional keys (e.g.
+ * `originSessionId`, `created`, custom tags) are tolerated and preserved
+ * on round-trip but are not required.
+ */
+interface MemoryFrontmatter {
+    name: string;
+    description: string;
+    type: MemoryType;
+    [key: string]: unknown;
+}
+/**
+ * A parsed memory document, ready to be written back or rendered.
+ *
+ * `id` is the filename stem (no `.md`); it is the address by which the
+ * store retrieves and overwrites the memory.
+ */
+interface Memory {
+    id: string;
+    frontmatter: MemoryFrontmatter;
+    body: string;
+}
+
+/**
+ * A directory-backed memory store.
+ *
+ * Each memory lives in a single `.md` file. The `MEMORY.md` (generated index)
+ * and `_INDEX.md` (Obsidian-friendly index) files are excluded — they are
+ * derived views, not memories themselves.
+ */
+declare class MemoryStore {
+    readonly dir: string;
+    constructor(dir: string);
+    /** Ensure the backing directory exists. Safe to call repeatedly. */
+    ensure(): Promise<void>;
+    /** List memory ids (filename stems), sorted lexicographically. */
+    list(): Promise<readonly string[]>;
+    /** Read a memory by id. Throws if the file does not exist. */
+    read(id: string): Promise<Memory>;
+    /** Write (or overwrite) a memory. Ensures the directory exists first. */
+    write(memory: Memory): Promise<void>;
+    /** Delete a memory. Returns false if it did not exist. */
+    delete(id: string): Promise<boolean>;
+    /** Test whether a memory exists by id. */
+    has(id: string): Promise<boolean>;
+    /** Absolute path of a memory file (file may not exist). */
+    pathFor(id: string): string;
+}
+
+interface WriteMemoryIndexOptions {
+    /** Top-level heading. Defaults to "Memory Index". */
+    title?: string;
+    /** Optional text placed above the heading (e.g. an HTML comment). */
+    preamble?: string;
+}
+/**
+ * Render a `MEMORY.md` index from the entries currently in `store` and
+ * write it to `<store.dir>/MEMORY.md`. Existing `MEMORY.md` is overwritten.
+ *
+ * The index is a flat bullet list: one line per memory, linking to the
+ * memory file and including the memory's `description`.
+ */
+declare function writeMemoryIndex(store: MemoryStore, options?: WriteMemoryIndexOptions): Promise<void>;
+
+/**
+ * Difference between two memory stores. All three lists may be empty,
+ * which means the stores are in sync.
+ */
+interface SyncDiff {
+    /** Ids present in `a` but not in `b`. */
+    onlyInA: readonly string[];
+    /** Ids present in `b` but not in `a`. */
+    onlyInB: readonly string[];
+    /** Ids present in both but whose raw file contents differ. */
+    changed: readonly string[];
+}
+/**
+ * Compute the diff between two memory stores. Neither store is modified.
+ *
+ * `changed` is determined by exact byte comparison of the underlying
+ * `.md` files. Frontmatter ordering or whitespace differences therefore
+ * count as a change — callers that want semantic equality should
+ * re-serialize through `parseFrontmatter` / `serializeFrontmatter` before
+ * comparing.
+ */
+declare function diffStores(a: MemoryStore, b: MemoryStore): Promise<SyncDiff>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$b_Memory = Memory;
+type index_d$b_MemoryFrontmatter = MemoryFrontmatter;
+type index_d$b_MemoryStore = MemoryStore;
+declare const index_d$b_MemoryStore: typeof MemoryStore;
+type index_d$b_MemoryType = MemoryType;
+type index_d$b_SyncDiff = SyncDiff;
+type index_d$b_WriteMemoryIndexOptions = WriteMemoryIndexOptions;
+declare const index_d$b_diffStores: typeof diffStores;
+declare const index_d$b_writeMemoryIndex: typeof writeMemoryIndex;
+declare namespace index_d$b {
+  export { type index_d$b_Memory as Memory, type index_d$b_MemoryFrontmatter as MemoryFrontmatter, index_d$b_MemoryStore as MemoryStore, type index_d$b_MemoryType as MemoryType, type index_d$b_SyncDiff as SyncDiff, type index_d$b_WriteMemoryIndexOptions as WriteMemoryIndexOptions, index_d$b_diffStores as diffStores, index_d$b_writeMemoryIndex as writeMemoryIndex };
+}
+
+type Severity = "error" | "warning" | "info";
+/**
+ * A single problem found by a rule.
+ */
+interface LintFinding {
+    readonly rule: string;
+    readonly severity: Severity;
+    readonly file: string;
+    readonly line?: number;
+    readonly message: string;
+}
+/**
+ * Input passed to a rule's `check` function.
+ */
+interface LintInput {
+    readonly file: string;
+    readonly content: string;
+}
+/**
+ * A registrable lint rule.
+ *
+ * Rules are pure: same input produces the same findings, no side effects.
+ * `check` may be async — useful for rules that need to consult other
+ * files (e.g. resolving wiki links).
+ */
+interface LintRule {
+    readonly id: string;
+    readonly description: string;
+    readonly check: (input: LintInput) => readonly LintFinding[] | Promise<readonly LintFinding[]>;
+}
+/**
+ * Aggregated result of a lint run.
+ */
+interface LintReport {
+    readonly findings: readonly LintFinding[];
+    readonly filesScanned: number;
+    readonly rulesRun: number;
+    readonly durationMs: number;
+}
+
+interface LintOptions {
+    /** Directory to scan recursively. */
+    readonly dir: string;
+    /** Rules to apply to every file. */
+    readonly rules: readonly LintRule[];
+    /** File extensions to include. Defaults to `[".md"]`. */
+    readonly extensions?: readonly string[];
+}
+/**
+ * Recursively scan `dir` for files with the configured extensions and run
+ * every rule against each file. Findings from all rules are aggregated into
+ * a single `LintReport`. Order of findings within the report is not
+ * guaranteed beyond "file by file, rule by rule".
+ */
+declare function lintDirectory(options: LintOptions): Promise<LintReport>;
+
+interface RequireFrontmatterOptions {
+    /** Frontmatter keys that must be present and non-empty. */
+    readonly required: readonly string[];
+}
+/**
+ * Rule that ensures the listed frontmatter keys are present and non-empty.
+ * Empty string, null, and undefined values all fail the check; `0`, `false`,
+ * and structured values (arrays, objects) pass as long as they exist.
+ */
+declare function requireFrontmatter(options: RequireFrontmatterOptions): LintRule;
+
+/**
+ * Rule that ensures, if a `privacy` frontmatter field is present, its value
+ * is one of the canonical three: `public`, `internal`, `personal`.
+ * Documents without any `privacy` field pass.
+ */
+declare function privacyValid(): LintRule;
+
+interface WikiLinkResolvesOptions {
+    /** Directory under which valid link targets live. Searched recursively. */
+    readonly searchRoot: string;
+    /** Target file extensions. Defaults to `[".md"]`. */
+    readonly extensions?: readonly string[];
+}
+/**
+ * Rule that checks wiki-style links `[[target]]` resolve to an existing
+ * file under `searchRoot` (by basename match, recursive). Aliases
+ * (`[[target|alias]]`) and anchors (`[[target#section]]`) are stripped
+ * before lookup.
+ *
+ * The target index is built lazily on the first invocation and cached for
+ * the lifetime of the rule instance.
+ */
+declare function wikiLinkResolves(options: WikiLinkResolvesOptions): LintRule;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$a_LintFinding = LintFinding;
+type index_d$a_LintInput = LintInput;
+type index_d$a_LintOptions = LintOptions;
+type index_d$a_LintReport = LintReport;
+type index_d$a_LintRule = LintRule;
+type index_d$a_RequireFrontmatterOptions = RequireFrontmatterOptions;
+type index_d$a_Severity = Severity;
+type index_d$a_WikiLinkResolvesOptions = WikiLinkResolvesOptions;
+declare const index_d$a_lintDirectory: typeof lintDirectory;
+declare const index_d$a_privacyValid: typeof privacyValid;
+declare const index_d$a_requireFrontmatter: typeof requireFrontmatter;
+declare const index_d$a_wikiLinkResolves: typeof wikiLinkResolves;
+declare namespace index_d$a {
+  export { type index_d$a_LintFinding as LintFinding, type index_d$a_LintInput as LintInput, type index_d$a_LintOptions as LintOptions, type index_d$a_LintReport as LintReport, type index_d$a_LintRule as LintRule, type index_d$a_RequireFrontmatterOptions as RequireFrontmatterOptions, type index_d$a_Severity as Severity, type index_d$a_WikiLinkResolvesOptions as WikiLinkResolvesOptions, index_d$a_lintDirectory as lintDirectory, index_d$a_privacyValid as privacyValid, index_d$a_requireFrontmatter as requireFrontmatter, index_d$a_wikiLinkResolves as wikiLinkResolves };
+}
+
+type PitfallSeverity = "info" | "warning" | "error";
+/**
+ * A single AI coding pitfall.
+ *
+ * Pitfalls describe failure modes that recur across AI coding work, along
+ * with how to recognize them and what to do instead. They are catalog
+ * entries, not active detectors.
+ */
+interface Pitfall {
+    readonly id: string;
+    readonly title: string;
+    readonly category: string;
+    readonly severity: PitfallSeverity;
+    readonly signal: string;
+    readonly cause: string;
+    readonly mitigation: string;
+    /** Free-form trailing markdown (examples, notes); empty string if none. */
+    readonly body: string;
+}
+/**
+ * Frontmatter shape expected on a pitfall `.md` file.
+ *
+ * `id` is optional in the source — if omitted, the filename stem is used.
+ */
+interface PitfallFrontmatter {
+    id?: string;
+    title: string;
+    category: string;
+    severity: PitfallSeverity;
+    signal: string;
+    cause: string;
+    mitigation: string;
+}
+
+/**
+ * Directory-backed pitfall catalog. One `.md` file per pitfall.
+ *
+ * The catalog reads all `.md` files in `dir` on each query (no caching).
+ * Callers that need cached behavior should wrap or call `list()` once and
+ * reuse the result.
+ */
+declare class PitfallCatalog {
+    readonly dir: string;
+    constructor(dir: string);
+    /** Load every pitfall in the directory, sorted by id. */
+    list(): Promise<readonly Pitfall[]>;
+    /** Load a single pitfall by id. Returns `undefined` if not found. */
+    get(id: string): Promise<Pitfall | undefined>;
+    /** Return only pitfalls matching the given category. */
+    filterByCategory(category: string): Promise<readonly Pitfall[]>;
+    private entries;
+    private loadFile;
+}
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$9_Pitfall = Pitfall;
+type index_d$9_PitfallCatalog = PitfallCatalog;
+declare const index_d$9_PitfallCatalog: typeof PitfallCatalog;
+type index_d$9_PitfallFrontmatter = PitfallFrontmatter;
+type index_d$9_PitfallSeverity = PitfallSeverity;
+declare namespace index_d$9 {
+  export { type index_d$9_Pitfall as Pitfall, index_d$9_PitfallCatalog as PitfallCatalog, type index_d$9_PitfallFrontmatter as PitfallFrontmatter, type index_d$9_PitfallSeverity as PitfallSeverity };
+}
+
+type ToolRuleSeverity = "advisory" | "strict" | "absolute";
+/**
+ * A single tool-usage rule.
+ *
+ * Tool rules express constraints the operator wants agents to obey when
+ * invoking specific tools. They are catalog entries, not active enforcers.
+ */
+interface ToolRule {
+    readonly id: string;
+    readonly title: string;
+    readonly scope: string;
+    readonly severity: ToolRuleSeverity;
+    readonly condition: string;
+    readonly action: string;
+    /** Free-form trailing markdown (examples, notes); empty string if none. */
+    readonly body: string;
+}
+/**
+ * Frontmatter shape expected on a tool-rule `.md` file.
+ *
+ * `id` is optional in the source — if omitted, the filename stem is used.
+ */
+interface ToolRuleFrontmatter {
+    id?: string;
+    title: string;
+    scope: string;
+    severity: ToolRuleSeverity;
+    condition: string;
+    action: string;
+}
+
+/**
+ * Directory-backed tool-rule catalog. One `.md` file per rule.
+ *
+ * The catalog reads all `.md` files in `dir` on each query (no caching).
+ */
+declare class ToolRuleCatalog {
+    readonly dir: string;
+    constructor(dir: string);
+    /** Load every rule in the directory, sorted by id. */
+    list(): Promise<readonly ToolRule[]>;
+    /** Load a single rule by id. Returns `undefined` if not found. */
+    get(id: string): Promise<ToolRule | undefined>;
+    /** Return only rules whose `scope` matches exactly. */
+    filterByScope(scope: string): Promise<readonly ToolRule[]>;
+    /** Return only rules whose `severity` matches. */
+    filterBySeverity(severity: ToolRuleSeverity): Promise<readonly ToolRule[]>;
+    private entries;
+    private loadFile;
+}
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$8_ToolRule = ToolRule;
+type index_d$8_ToolRuleCatalog = ToolRuleCatalog;
+declare const index_d$8_ToolRuleCatalog: typeof ToolRuleCatalog;
+type index_d$8_ToolRuleFrontmatter = ToolRuleFrontmatter;
+type index_d$8_ToolRuleSeverity = ToolRuleSeverity;
+declare namespace index_d$8 {
+  export { type index_d$8_ToolRule as ToolRule, index_d$8_ToolRuleCatalog as ToolRuleCatalog, type index_d$8_ToolRuleFrontmatter as ToolRuleFrontmatter, type index_d$8_ToolRuleSeverity as ToolRuleSeverity };
+}
+
+interface RenderOptions {
+    /** Target viewer privacy level. Content above this is stripped. */
+    readonly targetPrivacy: Privacy;
+    /**
+     * Optional HTML template. The placeholders `{{title}}` and `{{content}}`
+     * are replaced. If omitted, a minimal default template is used.
+     */
+    readonly template?: string;
+    /** Optional title for the `{{title}}` placeholder. */
+    readonly title?: string;
+}
+type WarningKind = "section-stripped" | "document-not-visible";
+interface RenderWarning {
+    readonly kind: WarningKind;
+    readonly reason: string;
+}
+interface RenderResult {
+    /** Rendered HTML. Empty string if the document is not visible at target. */
+    readonly html: string;
+    /** Effective document privacy (frontmatter value or default `internal`). */
+    readonly documentPrivacy: Privacy;
+    /** Whether the document was visible at the requested target privacy. */
+    readonly visible: boolean;
+    /** Warnings collected during render (stripped sections, skipped docs). */
+    readonly warnings: readonly RenderWarning[];
+}
+
+/**
+ * Render a markdown source to HTML, applying document-level and
+ * section-level privacy filtering before conversion.
+ *
+ * If the document's own privacy exceeds the target, an empty result is
+ * returned with a `document-not-visible` warning and no body conversion
+ * is performed.
+ */
+declare function renderHtml(source: string, options: RenderOptions): Promise<RenderResult>;
+
+interface StripResult {
+    readonly content: string;
+    readonly warnings: readonly RenderWarning[];
+}
+/**
+ * Remove section blocks whose declared privacy exceeds the target.
+ *
+ * Each section is delimited by `<!-- vortex:privacy LEVEL -->` and
+ * `<!-- /vortex:privacy -->`. Sections at or below target privacy keep
+ * their body (markers themselves are removed). Sections above target are
+ * stripped entirely and a `section-stripped` warning is reported.
+ *
+ * Sections do not nest; the parser does not support nesting.
+ */
+declare function stripPrivateSections(content: string, targetPrivacy: Privacy): StripResult;
+
+/**
+ * Minimal default template. Hosts that want styling, navigation, or
+ * additional metadata should pass a custom `template` to `renderHtml`.
+ */
+declare const DEFAULT_TEMPLATE = "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>{{title}}</title>\n</head>\n<body>\n{{content}}\n</body>\n</html>\n";
+/**
+ * Replace `{{name}}` placeholders in a template string with values from
+ * `vars`. Missing keys are replaced with the empty string.
+ */
+declare function applyTemplate(template: string, vars: Readonly<Record<string, string>>): string;
+
+//# sourceMappingURL=index.d.ts.map
+
+declare const index_d$7_DEFAULT_TEMPLATE: typeof DEFAULT_TEMPLATE;
+type index_d$7_RenderOptions = RenderOptions;
+type index_d$7_RenderResult = RenderResult;
+type index_d$7_RenderWarning = RenderWarning;
+type index_d$7_StripResult = StripResult;
+type index_d$7_WarningKind = WarningKind;
+declare const index_d$7_applyTemplate: typeof applyTemplate;
+declare const index_d$7_renderHtml: typeof renderHtml;
+declare const index_d$7_stripPrivateSections: typeof stripPrivateSections;
+declare namespace index_d$7 {
+  export { index_d$7_DEFAULT_TEMPLATE as DEFAULT_TEMPLATE, type index_d$7_RenderOptions as RenderOptions, type index_d$7_RenderResult as RenderResult, type index_d$7_RenderWarning as RenderWarning, type index_d$7_StripResult as StripResult, type index_d$7_WarningKind as WarningKind, index_d$7_applyTemplate as applyTemplate, index_d$7_renderHtml as renderHtml, index_d$7_stripPrivateSections as stripPrivateSections };
+}
+
+/**
+ * Frontmatter expected on a worklog file. All fields besides `type` are
+ * conventional — the store tolerates absence and surfaces what is present.
+ */
+interface WorklogFrontmatter {
+    type: "worklog";
+    status?: string;
+    privacy?: string;
+    created?: string;
+    updated?: string;
+    tags?: readonly string[];
+    related?: readonly string[];
+    [key: string]: unknown;
+}
+/**
+ * A parsed worklog entry.
+ *
+ * `date` is the ISO date portion of the filename (`YYYY-MM-DD`).
+ * `keyword` is the trailing slug portion of the filename without `.md`.
+ * `path` is the absolute path of the file on disk.
+ */
+interface WorklogEntry {
+    readonly date: string;
+    readonly keyword: string;
+    readonly path: string;
+    readonly frontmatter: WorklogFrontmatter;
+    readonly body: string;
+}
+
+/**
+ * Directory-backed worklog store. Expected layout: `<rootDir>/YYYY/MM/YYYY-MM-DD-keyword.md`.
+ *
+ * The store treats missing subdirectories as empty, never as errors —
+ * a brand-new month with no entries returns an empty list, not a throw.
+ */
+declare class WorklogStore {
+    readonly rootDir: string;
+    constructor(rootDir: string);
+    /** All entries across all years and months, sorted by date ascending. */
+    list(): Promise<readonly WorklogEntry[]>;
+    /** Entries within one calendar month. */
+    listByMonth(year: number, month: number): Promise<readonly WorklogEntry[]>;
+    /**
+     * The first entry matching `date` (`YYYY-MM-DD`). If multiple files exist
+     * for that date with different keywords, the lexicographically-first one
+     * is returned. Use `list()` when all are needed.
+     */
+    get(date: string): Promise<WorklogEntry | undefined>;
+    /** Most recent entry by date (descending), then keyword (descending). */
+    getLatest(): Promise<WorklogEntry | undefined>;
+    /** Resolve the file path for a given (date, keyword), without creating it. */
+    pathFor(date: string, keyword: string): string;
+    private listSubdirs;
+    private entriesIn;
+}
+
+/**
+ * Append a new section to the end of an existing worklog entry's file.
+ *
+ * The resulting markdown adds two leading blank lines, then `## <title>`,
+ * then a blank line, then the body. The entry's frontmatter is not touched.
+ *
+ * Returns the updated raw markdown that was written.
+ */
+declare function appendSection(entry: WorklogEntry, title: string, body: string): Promise<string>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$6_WorklogEntry = WorklogEntry;
+type index_d$6_WorklogFrontmatter = WorklogFrontmatter;
+type index_d$6_WorklogStore = WorklogStore;
+declare const index_d$6_WorklogStore: typeof WorklogStore;
+declare const index_d$6_appendSection: typeof appendSection;
+declare namespace index_d$6 {
+  export { type index_d$6_WorklogEntry as WorklogEntry, type index_d$6_WorklogFrontmatter as WorklogFrontmatter, index_d$6_WorklogStore as WorklogStore, index_d$6_appendSection as appendSection };
+}
+
+/**
+ * Frontmatter expected on a Decision-Log entry. `type` is the only required
+ * field — the store tolerates absence of the rest and surfaces what is present.
+ *
+ * `privacy` defaults to `personal` by convention; callers should not rely on
+ * the store to enforce it.
+ */
+interface DecisionLogFrontmatter {
+    type: "decision-log";
+    status?: "active" | "template" | "archived" | string;
+    privacy?: "personal" | "internal" | "public" | string;
+    created?: string;
+    updated?: string;
+    tags?: readonly string[];
+    related?: readonly string[];
+    [key: string]: unknown;
+}
+/**
+ * A parsed Decision-Log entry.
+ *
+ * `date` is the ISO date portion of the filename (`YYYY-MM-DD`).
+ * `slug` is the trailing portion of the filename without `.md`.
+ * `path` is the absolute path of the file on disk.
+ */
+interface DecisionEntry {
+    readonly date: string;
+    readonly slug: string;
+    readonly path: string;
+    readonly frontmatter: DecisionLogFrontmatter;
+    readonly body: string;
+}
+/** Filter criteria for {@link DecisionStore.filter}. Empty filter matches all. */
+interface DecisionFilter {
+    /** Match entries with `frontmatter.status` equal to this value. */
+    status?: string;
+    /** Match entries that contain this tag (case-sensitive). */
+    tag?: string;
+    /** Match entries with date >= this value (`YYYY-MM-DD`). */
+    fromDate?: string;
+    /** Match entries with date <= this value (`YYYY-MM-DD`). */
+    toDate?: string;
+}
+/** Input for {@link renderTemplate}. */
+interface DecisionTemplateInput {
+    /** ISO date (`YYYY-MM-DD`). Also written into the body header. */
+    date: string;
+    /** Short kebab-style identifier used in the filename. */
+    slug: string;
+    /** One-line decision title shown as the H1. */
+    title: string;
+    /** Free-form area label (e.g. `work`, `personal`, `home-lab`). */
+    area?: string;
+    /** Extra tags appended after the default `decision-log` tag. */
+    tags?: readonly string[];
+}
+
+/**
+ * Directory-backed Decision-Log store. Expected layout is flat —
+ * `<rootDir>/YYYY-MM-DD-<slug>.md`, no year/month subdirectories.
+ *
+ * Non-entry files at the root (README, _TEMPLATE, anything not matching
+ * the date-prefix pattern) are silently ignored.
+ *
+ * A missing root directory returns an empty list rather than throwing,
+ * so a brand-new template clone with no entries is a normal state.
+ */
+declare class DecisionStore {
+    readonly rootDir: string;
+    constructor(rootDir: string);
+    /** All entries, sorted by date ascending, then slug ascending. */
+    list(): Promise<readonly DecisionEntry[]>;
+    /**
+     * Entries whose filename starts with `date` (`YYYY-MM-DD`). Multiple
+     * decisions on the same day are returned in slug-ascending order.
+     */
+    getByDate(date: string): Promise<readonly DecisionEntry[]>;
+    /**
+     * The first entry matching `date` and (optionally) `slug`. When no slug is
+     * provided and multiple entries share the date, the lexicographically-first
+     * one is returned.
+     */
+    get(date: string, slug?: string): Promise<DecisionEntry | undefined>;
+    /** Most recent entry by date (descending), then slug (descending). */
+    getLatest(): Promise<DecisionEntry | undefined>;
+    /**
+     * Subset of entries matching the given criteria. Empty/undefined fields
+     * are ignored. Returns entries in the same order as {@link list}.
+     */
+    filter(criteria: DecisionFilter): Promise<readonly DecisionEntry[]>;
+    /** Resolve the file path for a given (date, slug), without creating it. */
+    pathFor(date: string, slug: string): string;
+}
+
+/**
+ * Render a new Decision-Log entry body using an obsidian-style template
+ * convention. Caller is responsible for writing the result to disk via
+ * {@link DecisionStore.pathFor}.
+ *
+ * The output deliberately mirrors a human-authored template so the
+ * shape stays consistent whether the entry was created by hand or by
+ * this helper.
+ */
+declare function renderTemplate(input: DecisionTemplateInput): string;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$5_DecisionEntry = DecisionEntry;
+type index_d$5_DecisionFilter = DecisionFilter;
+type index_d$5_DecisionLogFrontmatter = DecisionLogFrontmatter;
+type index_d$5_DecisionStore = DecisionStore;
+declare const index_d$5_DecisionStore: typeof DecisionStore;
+type index_d$5_DecisionTemplateInput = DecisionTemplateInput;
+declare const index_d$5_renderTemplate: typeof renderTemplate;
+declare namespace index_d$5 {
+  export { type index_d$5_DecisionEntry as DecisionEntry, type index_d$5_DecisionFilter as DecisionFilter, type index_d$5_DecisionLogFrontmatter as DecisionLogFrontmatter, index_d$5_DecisionStore as DecisionStore, type index_d$5_DecisionTemplateInput as DecisionTemplateInput, index_d$5_renderTemplate as renderTemplate };
+}
+
+/**
+ * One entry surfaced in a generated `_INDEX.md`.
+ */
+interface IndexEntry {
+    /** Path relative to the directory being indexed (forward slashes). */
+    readonly relPath: string;
+    /** Filename without extension. */
+    readonly name: string;
+    /** Title — `# H1` from the body, or filename fallback. */
+    readonly title: string;
+    /** Short description — frontmatter `description`, or first body paragraph fallback. */
+    readonly description?: string;
+    /** Frontmatter `type` value, if present (e.g. `worklog`, `decision-log`, `memory`). */
+    readonly type?: string;
+    /** Frontmatter `updated` or `created` value, ISO `YYYY-MM-DD` when parseable. */
+    readonly updated?: string;
+}
+/**
+ * Options controlling {@link scanDirectory}.
+ */
+interface ScanOptions {
+    /**
+     * Recurse into subdirectories. Default: false (flat scan).
+     *
+     * When true, the scanner descends into all subdirectories whose name does
+     * not start with `.` or `_`. The reserved files `README.md` and
+     * `_INDEX.md` are always skipped at every depth.
+     */
+    recursive?: boolean;
+    /**
+     * Filenames to skip in addition to the always-skipped reserved files
+     * (`README.md`, `_INDEX.md`). Comparison is case-sensitive on the basename.
+     */
+    skipFilenames?: readonly string[];
+    /**
+     * Filename prefixes to skip (e.g. `["_TEMPLATE"]`). Comparison is
+     * case-sensitive against the basename without extension.
+     */
+    skipPrefixes?: readonly string[];
+}
+/**
+ * Input for {@link renderIndex}.
+ */
+interface RenderIndexInput {
+    /** Page H1 — typically the directory's human name (e.g. "Memory", "Worklog"). */
+    title: string;
+    /**
+     * One-line blockquote shown beneath the H1. Pass an empty string to omit
+     * the blockquote.
+     */
+    description?: string;
+    /** Entries to list. Order is preserved as given. */
+    entries: readonly IndexEntry[];
+    /** Frontmatter `updated` field. Default: today's date in `YYYY-MM-DD`. */
+    updated?: string;
+    /** Frontmatter `privacy` field. Default: `internal`. */
+    privacy?: "public" | "internal" | "personal" | string;
+    /** Extra frontmatter tags besides the default `[index]`. */
+    extraTags?: readonly string[];
+    /** Optional "관련" links rendered after the entry list. */
+    related?: readonly string[];
+}
+
+/**
+ * Scan a directory of markdown notes and produce one {@link IndexEntry}
+ * per file, sorted by `relPath` ascending.
+ *
+ * - Files whose names are `README.md` or `_INDEX.md` are always skipped.
+ * - Hidden entries (name starting with `.` or `_`, except `_TEMPLATE` which
+ *   is still surfaced but can be excluded via `skipPrefixes: ["_TEMPLATE"]`)
+ *   are not descended into when `recursive: true`.
+ * - A missing directory returns an empty list rather than throwing.
+ */
+declare function scanDirectory(rootDir: string, opts?: ScanOptions): Promise<readonly IndexEntry[]>;
+
+/**
+ * Render an `_INDEX.md` body from a {@link RenderIndexInput}.
+ *
+ * Output shape:
+ *
+ *   ---
+ *   type: index
+ *   status: active
+ *   privacy: <privacy>
+ *   updated: <updated>
+ *   tags: [index, <extraTags...>]
+ *   ---
+ *
+ *   # <title>
+ *
+ *   > <description>
+ *
+ *   ## 항목 (<count>)
+ *
+ *   | 파일 | 설명 | 갱신 |
+ *   |---|---|---|
+ *   | [[<name>]] | <description or title> | <updated> |
+ *   ...
+ *
+ *   ## 관련  (only if `related` is non-empty)
+ *
+ *   - [[<related[0]>]]
+ *   ...
+ *
+ * Caller is responsible for writing this body to disk. The renderer never
+ * touches the filesystem.
+ */
+declare function renderIndex(input: RenderIndexInput): string;
+
+/**
+ * Walk a directory tree and return every subdirectory that contains at
+ * least `minEntries` markdown files at its top level. The root directory
+ * itself is included if it qualifies.
+ *
+ * "At its top level" means `.md` files **directly inside** the directory
+ * (not in its subdirectories) — this is what an `_INDEX.md` in that
+ * directory would index.
+ *
+ * `README.md` and `_INDEX.md` files are not counted (they are not
+ * indexable entries). `.md` files starting with prefixes in `skipPrefixes`
+ * are also not counted.
+ *
+ * Hidden directories (`.foo`) are not descended into. `_foo` directories
+ * are descended into — they may legitimately contain content
+ * (`_HUB-*.md`, `_INDEX.md` of subdirectories).
+ *
+ * A missing root directory returns an empty list rather than throwing.
+ *
+ * Use case — splitting a giant flat `_INDEX.md` into per-folder
+ * indexes: scan a tree, find the meaningful directories, write an
+ * `_INDEX.md` in each.
+ */
+declare function findIndexableDirs(rootDir: string, options?: {
+    minEntries?: number;
+    skipPrefixes?: readonly string[];
+}): Promise<readonly string[]>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$4_IndexEntry = IndexEntry;
+type index_d$4_RenderIndexInput = RenderIndexInput;
+type index_d$4_ScanOptions = ScanOptions;
+declare const index_d$4_findIndexableDirs: typeof findIndexableDirs;
+declare const index_d$4_renderIndex: typeof renderIndex;
+declare const index_d$4_scanDirectory: typeof scanDirectory;
+declare namespace index_d$4 {
+  export { type index_d$4_IndexEntry as IndexEntry, type index_d$4_RenderIndexInput as RenderIndexInput, type index_d$4_ScanOptions as ScanOptions, index_d$4_findIndexableDirs as findIndexableDirs, index_d$4_renderIndex as renderIndex, index_d$4_scanDirectory as scanDirectory };
+}
+
+/**
+ * Frontmatter expected on a Runbook entry. `type` is the only required
+ * field; the store tolerates absence of the rest and surfaces what is present.
+ */
+interface RunbookFrontmatter {
+    type: "runbook";
+    status?: "active" | "draft" | "archived" | string;
+    privacy?: "public" | "internal" | "personal" | string;
+    /** ISO date (`YYYY-MM-DD`) when this runbook was last verified end-to-end. */
+    last_tested?: string;
+    /** Free-form incident category (e.g. `network-outage`, `mail-outage`). */
+    "incident-type"?: string;
+    created?: string;
+    updated?: string;
+    tags?: readonly string[];
+    related?: readonly string[] | string;
+    [key: string]: unknown;
+}
+/**
+ * A parsed runbook entry.
+ *
+ * `slug` is the filename without the `.md` extension. Runbooks live in a
+ * flat directory — no date-prefix convention, since the name is typically
+ * descriptive (`service-restart-procedure`, `database-restore`).
+ */
+interface RunbookEntry {
+    readonly slug: string;
+    readonly path: string;
+    readonly frontmatter: RunbookFrontmatter;
+    readonly body: string;
+}
+/** Filter criteria for {@link RunbookStore.filter}. */
+interface RunbookFilter {
+    /** Match entries with `frontmatter.status` equal to this value. */
+    status?: string;
+    /** Match entries that contain this tag (case-sensitive). */
+    tag?: string;
+    /** Match entries with `frontmatter['incident-type']` equal to this value. */
+    incidentType?: string;
+}
+
+/**
+ * Directory-backed runbook store. Expected layout is flat —
+ * `<rootDir>/<slug>.md`, no subdirectories.
+ *
+ * Non-entry files at the root (README, _INDEX, anything not ending in `.md`)
+ * are silently ignored. A missing root directory returns an empty list
+ * rather than throwing.
+ */
+declare class RunbookStore {
+    readonly rootDir: string;
+    constructor(rootDir: string);
+    /** All entries, sorted by slug ascending. */
+    list(): Promise<readonly RunbookEntry[]>;
+    /** A single entry by slug, or undefined if not found. */
+    get(slug: string): Promise<RunbookEntry | undefined>;
+    /**
+     * Subset of entries matching the given criteria. Empty/undefined fields
+     * are ignored. Returns entries in the same order as {@link list}.
+     */
+    filter(criteria: RunbookFilter): Promise<readonly RunbookEntry[]>;
+    /**
+     * Entries whose `last_tested` is older than `staleAfterDays` from the
+     * given reference date (default: today). Entries without a `last_tested`
+     * field are treated as "never tested" and are always returned.
+     *
+     * This is the practical reason runbooks are a module rather than plain
+     * data — periodic reverification is a real operational need.
+     */
+    getStaleByLastTested(staleAfterDays: number, referenceDate?: Date): Promise<readonly RunbookEntry[]>;
+}
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$3_RunbookEntry = RunbookEntry;
+type index_d$3_RunbookFilter = RunbookFilter;
+type index_d$3_RunbookFrontmatter = RunbookFrontmatter;
+type index_d$3_RunbookStore = RunbookStore;
+declare const index_d$3_RunbookStore: typeof RunbookStore;
+declare namespace index_d$3 {
+  export { type index_d$3_RunbookEntry as RunbookEntry, type index_d$3_RunbookFilter as RunbookFilter, type index_d$3_RunbookFrontmatter as RunbookFrontmatter, index_d$3_RunbookStore as RunbookStore };
+}
+
+/**
+ * A wiki link extracted from a markdown body.
+ *
+ * Examples (input → parsed shape):
+ *   `[[Foo]]`         → { name: "Foo" }
+ *   `[[Foo|bar]]`     → { name: "Foo", alias: "bar" }
+ *   `[[Foo#Section]]` → { name: "Foo", anchor: "Section" }
+ *   `[[Foo#Sec|bar]]` → { name: "Foo", anchor: "Sec", alias: "bar" }
+ */
+interface WikiLink {
+    /** Target page name as written, without the `.md` extension. */
+    readonly name: string;
+    /** Section anchor after `#`, if present. */
+    readonly anchor?: string;
+    /** Display alias after `|`, if present. */
+    readonly alias?: string;
+    /** Original raw text including `[[...]]` brackets. */
+    readonly raw: string;
+}
+/**
+ * A wiki link that did not resolve against the filesystem index.
+ *
+ * `sourcePath` is the absolute path of the file that contained the link.
+ * `link` is the parsed link itself. Reason is a short string identifying
+ * why resolution failed (e.g. `not-found`).
+ */
+interface BrokenLink {
+    readonly sourcePath: string;
+    readonly link: WikiLink;
+    readonly reason: "not-found" | "ambiguous";
+    /** When `ambiguous`, the candidate paths that matched the name. */
+    readonly candidates?: readonly string[];
+}
+/**
+ * Aggregate result of {@link checkDirectory}.
+ */
+interface LinkCheckResult {
+    /** Number of `.md` files scanned. */
+    readonly filesScanned: number;
+    /** Total wiki links encountered across all files. */
+    readonly totalLinks: number;
+    /** Links that resolved to a unique target. */
+    readonly resolved: number;
+    /** Detail of unresolved links. */
+    readonly broken: readonly BrokenLink[];
+    /** Detail of ambiguous links (name matched multiple files). */
+    readonly ambiguous: readonly BrokenLink[];
+}
+
+/**
+ * Extract every wiki link from a markdown body. Returns links in
+ * document order; duplicates are preserved (callers can dedupe if they
+ * want, but a broken link in two places is still two repairs).
+ *
+ * Code fences and inline code spans are not stripped — this module
+ * treats markdown as text. Hosts that need to ignore links inside
+ * code blocks should pre-filter the body.
+ */
+declare function extractWikiLinks(body: string): readonly WikiLink[];
+
+/**
+ * Filesystem index of every `.md` file under a root.
+ *
+ * Provides two lookup paths:
+ *
+ * - `byBasename` — `name` (no `.md`) → list of absolute paths. Used for
+ *   bare wiki links like `[[Foo]]`, which Obsidian resolves by filename
+ *   anywhere in the vault.
+ * - `byRelPath` — forward-slash relative path (no `.md`) → absolute path.
+ *   Used for path-aware wiki links like `[[Projects/Home/Foo]]` or
+ *   `[[../Foo]]`, where the operator wrote a path on purpose to
+ *   disambiguate.
+ *
+ * `rootDir` is retained so resolvers can interpret root-relative paths.
+ */
+interface FileIndex {
+    readonly byBasename: ReadonlyMap<string, readonly string[]>;
+    readonly byRelPath: ReadonlyMap<string, string>;
+    /**
+     * Optional lowercase rel-path → absolute-path map for case-insensitive
+     * fallback. Present only when {@link buildFileIndex} was called with
+     * `caseInsensitive: true`. If two rel-paths collide after lowercasing,
+     * the first walker-visited path wins; the conflict is silent (rare in
+     * a well-organized tree).
+     */
+    readonly byRelPathLower?: ReadonlyMap<string, string>;
+    readonly rootDir: string;
+}
+/**
+ * Options for {@link buildFileIndex}.
+ */
+interface BuildIndexOptions {
+    /**
+     * Build an additional lowercase `byRelPathLower` map so {@link resolveLink}
+     * can fall back to case-insensitive matching when the exact-case path
+     * lookup fails. Useful when the operator's wiki-link convention uses
+     * different casing than the on-disk layout (a frequent situation when
+     * content is migrated from one vault into another with renamed roots,
+     * e.g. `[[Projects/Home/foo]]` vs `data/projects/home/foo.md`).
+     *
+     * Default: false. Bare-name lookup is unaffected — Obsidian historically
+     * treats bare names case-sensitively, and we keep that.
+     */
+    caseInsensitive?: boolean;
+    /**
+     * Extra file extensions (besides `.md`) to include in the index. Each
+     * extension must include the leading dot, e.g. `[".hwp", ".docx", ".pdf"]`.
+     *
+     * `.md` files are always indexed with the extension stripped from their
+     * key — `[[Foo]]` matches `Foo.md`. Files with one of the additional
+     * extensions are indexed with the extension *kept*, so they only match
+     * when the operator writes the full filename — `[[Foo.hwp]]` matches
+     * `Foo.hwp`. This avoids surprise collisions where `[[Foo]]` would
+     * suddenly match a non-markdown file.
+     *
+     * Default: `[]` (only `.md` is indexed; preserves v1 behavior).
+     *
+     * Note: only `.md` files are scanned for wiki links by
+     * {@link import("./checker.js").checkDirectory} and rewritten by
+     * {@link import("./rewrite.js").rewriteDirectory}. Additional extensions
+     * affect *resolution targets* (what a wiki link can point at), not
+     * *scan sources* (what a wiki link can appear in).
+     */
+    additionalExtensions?: readonly string[];
+}
+/**
+ * Walk `rootDir` recursively and build a {@link FileIndex} of every `.md`
+ * file (plus any `additionalExtensions` requested).
+ *
+ * Hidden directories (`.foo`) are skipped. `_foo` directories ARE indexed —
+ * Obsidian wiki links can target any markdown file regardless of underscore
+ * prefix, so we mirror that. A missing root returns an empty index.
+ */
+declare function buildFileIndex(rootDir: string, options?: BuildIndexOptions): Promise<FileIndex>;
+/**
+ * Resolution outcome for a single wiki link.
+ *
+ * - `unique`: one and only one file matched.
+ * - `not-found`: no file matched.
+ * - `ambiguous`: multiple files share the basename (only possible for
+ *   bare-name links; path-aware links always resolve uniquely or fail).
+ */
+type ResolveOutcome = {
+    kind: "unique";
+    path: string;
+} | {
+    kind: "not-found";
+} | {
+    kind: "ambiguous";
+    candidates: readonly string[];
+};
+/**
+ * Optional hints that turn on path-aware resolution.
+ *
+ * - `sourcePath` — absolute path of the file the link was found in.
+ *   Required to resolve `../foo`-style relative links.
+ *
+ * When neither hint is set, behavior collapses to bare-name lookup
+ * (basename only), matching the original v1 semantics.
+ */
+interface ResolveOpts {
+    sourcePath?: string;
+}
+/**
+ * Look up a wiki link in the index. Three cases:
+ *
+ * 1. **Bare name** (`[[Foo]]`) — basename lookup only. Returns `unique`
+ *    if exactly one `Foo.md` exists, `ambiguous` if multiple, `not-found`
+ *    otherwise.
+ * 2. **Root-relative path** (`[[Projects/Foo]]`) — exact rel-path lookup
+ *    against the index. Always `unique` or `not-found`.
+ * 3. **Source-relative path** (`[[../Foo]]`, `[[./Foo]]`) — resolved
+ *    against `dirname(sourcePath)` first, then looked up by rel-path.
+ *    Requires `opts.sourcePath`; without it, returns `not-found`.
+ *
+ * Trailing `.md` in the link name is stripped before matching.
+ */
+declare function resolveLink(name: string, index: FileIndex, opts?: ResolveOpts): ResolveOutcome;
+/**
+ * Reduce an absolute path to one relative to `rootDir`, using forward
+ * slashes. Useful for reporting.
+ */
+declare function toRel(path: string, rootDir: string): string;
+
+/**
+ * Options for {@link checkDirectory}.
+ */
+interface CheckDirectoryOptions extends BuildIndexOptions {
+}
+/**
+ * Scan every `.md` file under `rootDir`, extract wiki links, and
+ * report which ones cannot be resolved (or resolve to multiple files).
+ *
+ * This is read-only — it does not modify any file. The function returns
+ * a structured result so hosts can decide whether to log, fail a build,
+ * propose rewrites, etc.
+ *
+ * Pass `caseInsensitive: true` when wiki-link casing may differ from
+ * the on-disk path (e.g. content migrated from a vault with different
+ * directory naming conventions).
+ */
+declare function checkDirectory(rootDir: string, options?: CheckDirectoryOptions): Promise<LinkCheckResult>;
+/**
+ * Group broken links by target name and return counts in descending order.
+ * Useful for quickly identifying the most-cited missing pages.
+ */
+declare function topBrokenTargets(broken: readonly BrokenLink[], limit?: number): readonly {
+    readonly name: string;
+    readonly count: number;
+}[];
+
+/**
+ * Map of wiki-link names to replace.
+ *
+ * Both keys and values are the `name` portion of a wiki link — what
+ * appears between `[[` and the optional `#anchor` / `|alias`. Anchors
+ * and aliases on the original link are preserved automatically.
+ *
+ * Examples:
+ *   { "API-Tokens": "secrets/api-tokens" }
+ *     [[API-Tokens]]       → [[secrets/api-tokens]]
+ *     [[API-Tokens|토큰]]  → [[secrets/api-tokens|토큰]]
+ *     [[API-Tokens#A|토큰]] → [[secrets/api-tokens#A|토큰]]
+ *
+ * Use the exact name string the operator wrote — no normalization is
+ * applied. If the same broken target appears with different spellings
+ * (e.g. case differences), provide one entry per spelling.
+ */
+type RedirectionMap = ReadonlyMap<string, string>;
+/**
+ * Options for {@link rewriteDirectory}.
+ */
+interface RewriteOptions {
+    /**
+     * The redirection map driving the rewrite. Links whose name is not
+     * a key in this map are left untouched.
+     */
+    redirections: RedirectionMap;
+    /**
+     * When true, do not write any files. The result still describes the
+     * rewrites that would happen — useful for showing the operator what
+     * a redirection map will do before it does it.
+     */
+    dryRun?: boolean;
+}
+/**
+ * Per-file detail of a rewrite operation.
+ */
+interface FileRewrite {
+    readonly sourcePath: string;
+    readonly rewrites: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
+}
+/**
+ * Aggregate result of {@link rewriteDirectory}.
+ */
+interface RewriteResult {
+    readonly filesScanned: number;
+    /** Files whose body was changed (or would be changed under dry-run). */
+    readonly filesChanged: number;
+    /** Total number of link replacements (may exceed `filesChanged`). */
+    readonly rewritesApplied: number;
+    /** Links matching a redirection key but ultimately not replaced — currently always 0; reserved for future skip reasons. */
+    readonly skipped: number;
+    readonly details: readonly FileRewrite[];
+    readonly dryRun: boolean;
+}
+/**
+ * Walk every `.md` file under `rootDir`, replace wiki links whose name
+ * is a key in `redirections`, and write the changed files back to disk
+ * (or describe what would change when `dryRun: true`).
+ *
+ * Only the link `name` is replaced. Anchors (`#Section`) and aliases
+ * (`|display`) carry over verbatim onto the replacement link. The
+ * surrounding markdown body is untouched.
+ *
+ * Rewriting is deterministic and order-independent — within a file,
+ * every occurrence of every mapped key is replaced exactly once per
+ * occurrence, with no chaining (the replacement is not re-scanned for
+ * further matches).
+ */
+declare function rewriteDirectory(rootDir: string, opts: RewriteOptions): Promise<RewriteResult>;
+/**
+ * Pure transformation: take a markdown body, return the body with all
+ * `[[…]]` links whose name appears in `redirections` rewritten. Exported
+ * for testing and for callers that need to rewrite an in-memory string.
+ *
+ * The transformation does not touch markdown outside `[[…]]` patterns.
+ */
+declare function rewriteBody(body: string, redirections: RedirectionMap): {
+    newBody: string;
+    fileRewrites: {
+        from: string;
+        to: string;
+    }[];
+};
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$2_BrokenLink = BrokenLink;
+type index_d$2_BuildIndexOptions = BuildIndexOptions;
+type index_d$2_CheckDirectoryOptions = CheckDirectoryOptions;
+type index_d$2_FileIndex = FileIndex;
+type index_d$2_FileRewrite = FileRewrite;
+type index_d$2_LinkCheckResult = LinkCheckResult;
+type index_d$2_RedirectionMap = RedirectionMap;
+type index_d$2_ResolveOpts = ResolveOpts;
+type index_d$2_ResolveOutcome = ResolveOutcome;
+type index_d$2_RewriteOptions = RewriteOptions;
+type index_d$2_RewriteResult = RewriteResult;
+type index_d$2_WikiLink = WikiLink;
+declare const index_d$2_buildFileIndex: typeof buildFileIndex;
+declare const index_d$2_checkDirectory: typeof checkDirectory;
+declare const index_d$2_extractWikiLinks: typeof extractWikiLinks;
+declare const index_d$2_resolveLink: typeof resolveLink;
+declare const index_d$2_rewriteBody: typeof rewriteBody;
+declare const index_d$2_rewriteDirectory: typeof rewriteDirectory;
+declare const index_d$2_toRel: typeof toRel;
+declare const index_d$2_topBrokenTargets: typeof topBrokenTargets;
+declare namespace index_d$2 {
+  export { type index_d$2_BrokenLink as BrokenLink, type index_d$2_BuildIndexOptions as BuildIndexOptions, type index_d$2_CheckDirectoryOptions as CheckDirectoryOptions, type index_d$2_FileIndex as FileIndex, type index_d$2_FileRewrite as FileRewrite, type index_d$2_LinkCheckResult as LinkCheckResult, type index_d$2_RedirectionMap as RedirectionMap, type index_d$2_ResolveOpts as ResolveOpts, type index_d$2_ResolveOutcome as ResolveOutcome, type index_d$2_RewriteOptions as RewriteOptions, type index_d$2_RewriteResult as RewriteResult, type index_d$2_WikiLink as WikiLink, index_d$2_buildFileIndex as buildFileIndex, index_d$2_checkDirectory as checkDirectory, index_d$2_extractWikiLinks as extractWikiLinks, index_d$2_resolveLink as resolveLink, index_d$2_rewriteBody as rewriteBody, index_d$2_rewriteDirectory as rewriteDirectory, index_d$2_toRel as toRel, index_d$2_topBrokenTargets as topBrokenTargets };
+}
+
+/**
+ * Host-supplied LLM adapter. The proposer asks structured questions
+ * (a prompt plus a JSON-shaped expected answer); the host runs the question
+ * against whatever LLM facility it has — a sub-agent tool call (Claude Code),
+ * an inline completion (Codex), an MCP call (Gemini), or a Claude Desktop
+ * surface. The proposer does not care which.
+ *
+ * The interface is intentionally narrow: prompt in, structured answer out.
+ * No streaming, no tool registration, no token budget knobs. Each
+ * `LLMJudge.ask()` call is a single-shot decision query.
+ *
+ * This mirrors the `TranscriptAdapter` pattern in `@vortex-os/memory-extended`
+ * — host-specific work is isolated to one adapter per host; the consumer
+ * (`InsightProposer`, `HubProposer`) is host-agnostic.
+ */
+interface LLMJudge {
+    /**
+     * Identifier of the host this adapter speaks to. Used for diagnostics and
+     * for proposals to record which judge approved them (`accepted.log`).
+     * Open-ended string so third-party hosts can register their own identifier.
+     */
+    readonly host: string;
+    /**
+     * Run a single-shot decision query against the host LLM.
+     *
+     * Implementations must:
+     *  - Pass `prompt` to the underlying LLM with whatever system instructions
+     *    the host normally uses (no special framing required from the caller).
+     *  - Constrain the response to match `expected.shape` — either by JSON-
+     *    mode generation, by structured output, or by a retry loop that
+     *    reformats the response. The proposer assumes the returned value
+     *    conforms to `expected.shape`.
+     *  - Throw on persistent format failure rather than returning malformed
+     *    data. Callers handle the rejection rather than the host masking it.
+     *
+     * The return type is `unknown` because the caller knows the shape it
+     * expects (it supplied `expected.shape`) and runtime-validates after the
+     * call. Keeping the static return loose avoids coupling the interface to
+     * a particular validation library.
+     */
+    ask(prompt: string, expected: ExpectedShape): Promise<unknown>;
+}
+/**
+ * Shape descriptor for the expected LLM response. Kept minimal so any
+ * validation library (zod, valibot, hand-rolled) can produce one.
+ *
+ *  - `shape: "string"` — a single free-form string answer (e.g. a yes/no,
+ *    a slug, a summary).
+ *  - `shape: "json"` — a JSON value matching the supplied JSON-Schema-like
+ *    descriptor. Implementations may pass the descriptor to a structured-
+ *    output mode if the underlying LLM supports it; otherwise they must
+ *    validate after generation.
+ */
+type ExpectedShape = {
+    readonly shape: "string";
+} | {
+    readonly shape: "json";
+    /**
+     * Free-form schema descriptor — passed through to the host's structured
+     * output mechanism if any, otherwise informational only. The proposer
+     * still runs its own runtime check on the returned value, so this
+     * field's contract is best-effort.
+     */
+    readonly schema: unknown;
+};
+
+/**
+ * The single contract that both proposer surfaces (insight capture, hub
+ * auto-curation) implement. Generic over the input shape so each surface can
+ * declare its own evaluation input — a recent-turns buffer for the insight
+ * surface, a filesystem snapshot for the hub surface.
+ *
+ * `evaluate()` is intentionally pure: it inspects its input, optionally
+ * consults the LLM, and returns either a {@link Proposal} or `null`. Side
+ * effects (writing the captured insight, recording the decline) are
+ * captured as thunks inside the returned Proposal and only run after the
+ * user decides.
+ *
+ * A `null` return means "no proposal at this time" — the proposer's
+ * thresholds were not met, the LLM declined, the input fingerprint was
+ * already on the decline list, or nothing meaningful changed since the last
+ * evaluation. The caller must not treat `null` as an error.
+ */
+interface Proposer<Input, P extends Proposal = Proposal> {
+    readonly kind: string;
+    evaluate(input: Input, ctx: ProposerContext): Promise<P | null>;
+}
+/**
+ * Shared evaluation context handed to every proposer call.
+ *
+ *  - `cwd` is the instance's repository root — proposers resolve `data/`
+ *    paths relative to it. Absolute paths never leak into proposals (the
+ *    proposal's action carries data-relative paths).
+ *  - `declinedFingerprints` is pre-loaded by the orchestrator so the
+ *    proposer can do its decline check without touching the filesystem
+ *    during evaluation.
+ *  - `llm` is the host-supplied judge. Injected so the proposer stays
+ *    host-agnostic.
+ *  - `now` is injected (rather than `new Date()` inside the proposer) so
+ *    verify scenarios can pin time for deterministic fingerprints.
+ */
+interface ProposerContext {
+    readonly cwd: string;
+    readonly declinedFingerprints: ReadonlySet<string>;
+    readonly llm: LLMJudge;
+    readonly now: Date;
+}
+/**
+ * A single proposal handed to the host for the user to accept or decline.
+ *
+ * The proposal carries enough preview content that the user can decide
+ * without further round-trips. `onAccept` / `onDecline` are thunks — the
+ * side-effect logic was captured at evaluation time but does not run until
+ * the user decides. This keeps `Proposer.evaluate()` pure.
+ *
+ * `fingerprint` identifies the proposal for decline-tracking. It must
+ * include the chosen `action.kind` and target path so the same topic can
+ * re-surface with a different placement decision if the LLM's call shifts
+ * (e.g. user declined an `append-section` to file X, but a later evaluation
+ * proposes `create-file` in a sibling folder — different fingerprint,
+ * eligible to surface).
+ */
+interface Proposal {
+    readonly kind: string;
+    readonly fingerprint: string;
+    readonly action: ProposalAction;
+    readonly preview: string;
+    readonly rationale: string;
+    readonly sourceRefs: readonly string[];
+    readonly onAccept: () => Promise<AcceptResult>;
+    readonly onDecline: () => Promise<void>;
+}
+/**
+ * Placement action chosen by the proposer. Four kinds cover the full
+ * lifecycle of topic-aware capture; the proposer biases toward the *least*
+ * structural change consistent with the captured content.
+ *
+ * Preference order (extend before create):
+ *   `append-section` > `create-file` > `create-folder` > `update-file`
+ *
+ *  - `create-folder` — topic is new; create the folder and seed the first
+ *    file inside it.
+ *  - `create-file` — topic folder exists; create a new sibling file. The
+ *    proposer chose this because the content does not belong in any
+ *    existing file in the folder.
+ *  - `append-section` — an existing file is the right home; append a new
+ *    `## <sectionHeader>` section to it. Use this for an ongoing topic
+ *    where the new content is an addition, not a rewrite.
+ *  - `update-file` — an existing file needs in-place revision (status
+ *    update, factual correction, summary refresh). Rare; prefer
+ *    `append-section` when the new content is additive.
+ *
+ * All paths are relative to `data/` so proposals never embed absolute paths
+ * (proposals can be serialized into `_proactive-curator/` and re-evaluated
+ * later without being tied to a particular workspace location).
+ */
+type ProposalAction = {
+    readonly kind: "create-folder";
+    readonly folderPath: string;
+    readonly filename: string;
+    readonly body: string;
+} | {
+    readonly kind: "create-file";
+    readonly folderPath: string;
+    readonly filename: string;
+    readonly body: string;
+} | {
+    readonly kind: "append-section";
+    readonly filePath: string;
+    readonly sectionHeader: string;
+    readonly body: string;
+} | {
+    readonly kind: "update-file";
+    readonly filePath: string;
+    readonly body: string;
+    readonly reason: string;
+};
+/**
+ * Result returned by {@link Proposal.onAccept}. The host uses this to
+ * confirm the write succeeded and to surface the next-action hint to the
+ * user in plain language.
+ */
+interface AcceptResult {
+    readonly writtenPath: string;
+    readonly actionApplied: ProposalAction["kind"];
+    readonly nextActionHint?: string;
+}
+
+/**
+ * Input to {@link computeFingerprint}. Two shapes — one per surface — share
+ * a single function so the decline store can carry both kinds of
+ * fingerprints in the same lookup set.
+ *
+ * The action-aware fingerprint is the load-bearing design choice: declining
+ * an `append-section` proposal for topic X does *not* prevent a later
+ * `create-file` proposal for the same topic from surfacing. The LLM's
+ * placement decision is part of the fingerprint, so a shifted decision is
+ * a new proposal.
+ */
+type FingerprintInput = {
+    readonly kind: "capture-insight";
+    readonly turnIds: readonly string[];
+    readonly topic: string;
+    readonly actionKind: ProposalAction["kind"];
+    readonly targetPath: string;
+} | {
+    readonly kind: "create-hub";
+    readonly topic: string;
+    readonly sourceDocs: readonly string[];
+    readonly actionKind: ProposalAction["kind"];
+    readonly targetPath: string;
+};
+/**
+ * Compute a stable 16-hex-char fingerprint for a proposal. Stable means:
+ * identical logical input — regardless of source ordering of array fields or
+ * path separator style — produces an identical fingerprint, so the decline
+ * lookup is reliable across machines (work / home) and across path-separator
+ * regimes (Windows backslash vs POSIX slash).
+ *
+ * SHA-256 truncated to 16 hex chars (64 bits) is enough collision resistance
+ * for a per-instance decline set; the full hash adds storage with no
+ * practical benefit at this scale.
+ */
+declare function computeFingerprint(input: FingerprintInput): string;
+
+type ProposalKind = "capture-insight" | "create-hub";
+interface DeclinedEntry {
+    /** ISO-8601 timestamp of when the user declined. */
+    readonly declinedAt: string;
+    /** Topic slug at decline time (for the audit trail; not part of the fingerprint). */
+    readonly topic: string;
+    /** ISO-8601 timestamp after which this entry is eligible for re-evaluation. */
+    readonly expiresAt: string;
+    /** The action the user declined — `create-file`, `append-section`, etc. */
+    readonly actionKind: ProposalAction["kind"];
+    /** Target path the declined action would have written/touched (data-relative). */
+    readonly targetPath: string;
+    /** Hub proposals only — the source-doc cluster that triggered this proposal. */
+    readonly sourceDocs?: readonly string[];
+}
+/**
+ * Load the active (un-expired) declined fingerprints. The returned set is
+ * what {@link ProposerContext.declinedFingerprints} carries during
+ * `evaluate()` so the proposer can do its decline check without filesystem
+ * access at evaluation time.
+ *
+ * Missing or corrupt store files return an empty set rather than throwing —
+ * a first-run instance simply has nothing declined.
+ */
+declare function loadDeclinedFingerprints(cwd: string, now: Date): Promise<ReadonlySet<string>>;
+/**
+ * Persist a decline. Purges expired entries from disk in the same write so
+ * the store does not grow unbounded.
+ */
+declare function recordDecline(cwd: string, args: {
+    readonly kind: ProposalKind;
+    readonly fingerprint: string;
+    readonly topic: string;
+    readonly actionKind: ProposalAction["kind"];
+    readonly targetPath: string;
+    readonly sourceDocs?: readonly string[];
+    readonly now: Date;
+    readonly expiryDays?: number;
+}): Promise<void>;
+/**
+ * Append an acceptance record to the audit trail. Newline-delimited JSON so
+ * the file is grep-friendly and tail-friendly without a parser.
+ */
+declare function recordAcceptance(cwd: string, args: {
+    readonly kind: ProposalKind;
+    readonly fingerprint: string;
+    readonly topic: string;
+    readonly actionKind: ProposalAction["kind"];
+    readonly writtenPath: string;
+    readonly now: Date;
+}): Promise<void>;
+/**
+ * Clear declined entries. Optional `kind` argument scopes the reset to
+ * just one surface. Called by `/curate --reset-declined` (sub-phase c).
+ * Missing store file is a no-op — nothing to reset.
+ */
+declare function resetDeclined(cwd: string, kind?: ProposalKind): Promise<void>;
+
+interface InsightProposerOptions {
+    /** Below this token count the proposer never asks the LLM. */
+    readonly minTokensAccumulated: number;
+    /** Below this turn count the proposer never asks the LLM. */
+    readonly minTurnsBeforeFirstCheck: number;
+    /**
+     * Cap on how many topic folders to surface to the placement LLM call.
+     * Large instance trees will exceed any practical LLM context budget;
+     * truncation keeps the call tractable. Default 100.
+     */
+    readonly maxTreeEntries?: number;
+    /** Days after which a decline becomes eligible for re-evaluation. */
+    readonly declineExpiryDays?: number;
+}
+interface TurnRecord {
+    readonly turnId: string;
+    readonly role: "user" | "assistant" | "system";
+    readonly content: string;
+}
+interface InsightInput {
+    readonly recentTurns: readonly TurnRecord[];
+    readonly accumulatedTokens: number;
+}
+interface InsightProposal extends Proposal {
+    readonly kind: "capture-insight";
+}
+interface TopicFile {
+    readonly path: string;
+    readonly filename: string;
+    readonly frontmatterTopic?: string;
+    readonly tags?: readonly string[];
+}
+interface TopicFolderSnapshot {
+    readonly path: string;
+    readonly files: readonly TopicFile[];
+}
+interface TopicTreeSnapshot {
+    readonly folders: readonly TopicFolderSnapshot[];
+    /** True when the scan was truncated by `maxTreeEntries`. */
+    readonly truncated: boolean;
+}
+declare class InsightProposer implements Proposer<InsightInput, InsightProposal> {
+    private readonly options;
+    readonly kind = "capture-insight";
+    constructor(options: InsightProposerOptions);
+    evaluate(input: InsightInput, ctx: ProposerContext): Promise<InsightProposal | null>;
+}
+
+interface HubProposerOptions {
+    /** Threshold for triggering propose-veto LLM gate. Below this, no proposal. Default 3. */
+    readonly weakSignalAt: number;
+    /** Threshold for switching to suppress-veto LLM gate. Default 5. */
+    readonly strongSignalAt: number;
+    /**
+     * Content categories (data-relative) to scan for topic clusters. Default
+     * `worklog`, `decision-log`, `runbooks`. Hub itself, `_memory/`, and the
+     * curator's own `_proactive-curator/` are never scanned (a hub-of-hubs
+     * is out of scope; memory is not topical content).
+     */
+    readonly scanCategories?: readonly string[];
+    /** Decline expiry in days. Default 30. */
+    readonly declineExpiryDays?: number;
+}
+interface HubInput {
+    /**
+     * Hub evaluation has no per-call input beyond context — the filesystem is
+     * the input. This shape is kept for future extension (e.g. a hint to scan
+     * only a specific category) without breaking the `Proposer<Input, P>`
+     * contract.
+     */
+    readonly hint?: {
+        readonly onlyCategories?: readonly string[];
+    };
+}
+interface HubProposal extends Proposal {
+    readonly kind: "create-hub";
+}
+declare class HubProposer implements Proposer<HubInput, HubProposal> {
+    private readonly options;
+    readonly kind = "create-hub";
+    constructor(options: HubProposerOptions);
+    evaluate(input: HubInput, ctx: ProposerContext): Promise<HubProposal | null>;
+}
+
+/**
+ * Sliding buffer of recent conversation turns. The host pushes each turn as
+ * it occurs; the buffer caps at `maxTurns` and discards the oldest entries
+ * past the cap. Token count is estimated cheaply so the host can poll
+ * `tokenCount()` to decide when InsightProposer's threshold has been met.
+ *
+ * Default estimator is `chars / 4` — a rough baseline that overshoots for
+ * CJK content and undershoots for ASCII code. Hosts that have a real
+ * tokenizer can inject one via the `estimator` option.
+ *
+ * The buffer is process-local and not persisted — a new session starts
+ * with an empty buffer, which is the intended UX (proactive proposals are
+ * about *this conversation*, not a re-ingestion of past sessions; that is
+ * what `memory-extended/consolidate` is for).
+ */
+declare class TurnBuffer {
+    private readonly turns;
+    private readonly maxTurns;
+    private readonly estimator;
+    constructor(options?: {
+        readonly maxTurns?: number;
+        readonly estimator?: (turn: TurnRecord) => number;
+    });
+    /** Append a turn, evicting the oldest entry if the buffer is full. */
+    add(turn: TurnRecord): void;
+    /** Return the most recent `n` turns (or fewer if the buffer has fewer). */
+    recent(n: number): readonly TurnRecord[];
+    /** Number of turns currently buffered. */
+    get length(): number;
+    /** Estimated total token count over the entire buffer. */
+    tokenCount(): number;
+    /** Reset the buffer — typically called at session-end. */
+    clear(): void;
+}
+/**
+ * Backpressure controller for ambient mid-session triggers. When the user
+ * declines several proposals in a row, the controller flips into
+ * `active=true` and the host should pause ambient evaluations for the
+ * remainder of the session. Manual `/curate` invocations are still
+ * allowed — the controller exists only to suppress unsolicited prompts.
+ *
+ * Reset semantics:
+ *  - `recordAccept()` — any acceptance clears the streak.
+ *  - `recordIgnored()` — proposals the host surfaced but the user did not
+ *    explicitly accept/decline do not count toward the streak.
+ *  - `reset()` — explicit reset, used by `/curate` (the user re-engaging
+ *    after backpressure kicked in).
+ */
+declare class AmbientBackpressure {
+    private declineStreak;
+    private readonly maxStreak;
+    constructor(options?: {
+        readonly maxStreak?: number;
+    });
+    /** Record a user decline. Counts toward backpressure. */
+    recordDecline(): void;
+    /** Record a user acceptance. Clears the streak. */
+    recordAccept(): void;
+    /** Explicit reset (e.g. user runs `/curate` after backpressure activated). */
+    reset(): void;
+    /** True when the streak has reached the maximum and ambient should pause. */
+    isActive(): boolean;
+    /** Current decline streak — exposed for diagnostics. */
+    get streak(): number;
+}
+
+/**
+ * Minimal shape of a recall hit the ambient recaller consumes.
+ *
+ * Defined locally — `proactive-curator` does not depend on
+ * `@vortex-os/memory-extended`. The host injects a {@link RecallFn} whose
+ * result structurally satisfies this shape (memory-extended's `RecallHit`
+ * carries all of these fields plus a few extra, so the wiring is
+ * zero-friction). This mirrors how `LLMJudge` keeps the host's LLM facility
+ * behind an injected adapter: the recall *engine* lives in another package;
+ * the *decision of when to surface a hit in conversation* lives here.
+ */
+interface AmbientRecallHit {
+    readonly id: string;
+    /** Cosine similarity to the query (1 = identical direction). */
+    readonly score: number;
+    readonly name: string;
+    /** Short body excerpt for the host to weave into prose. */
+    readonly excerpt: string;
+    /** Corpus the hit came from (e.g. "memory", "session-archive"). */
+    readonly source: string;
+    readonly type: string;
+    readonly updated: string | null;
+    readonly tags: readonly string[];
+}
+/**
+ * Host-injected recall function. The host wires its `memory-extended` recall
+ * engine (sqlite + vector + embedder + session chunks) behind this single
+ * call so the recaller stays engine-agnostic and `proactive-curator` stays
+ * free of any `memory-extended` dependency.
+ */
+interface RecallFn {
+    (query: string, opts?: {
+        readonly k?: number;
+    }): Promise<{
+        readonly hits: readonly AmbientRecallHit[];
+    }>;
+}
+/** One surfaced suggestion — a recall hit that passed the ambient gate. */
+interface RecallSuggestion {
+    readonly hit: AmbientRecallHit;
+    /** Convenience copy of `hit.score` (the gate's ranking key). */
+    readonly score: number;
+}
+/**
+ * Result of one {@link AmbientRecaller.consider} call. Carries the surviving
+ * suggestion(s) plus diagnostics (how many hits the engine returned, how many
+ * each gate dropped) so an instance can tune `minScore` against real
+ * conversations rather than guessing.
+ */
+interface AmbientRecallResult {
+    /** Hits that passed every gate, best-first, capped at `maxSuggestions`. */
+    readonly suggestions: readonly RecallSuggestion[];
+    /** True when backpressure is active — the recaller stayed silent. */
+    readonly suppressed: boolean;
+    /** The query actually used (derived or explicit); null if none/empty. */
+    readonly query: string | null;
+    /** Hits returned by the engine before filtering (transparency for tuning). */
+    readonly considered: number;
+    /** Hits dropped for scoring below `minScore`. */
+    readonly belowThreshold: number;
+    /** Hits dropped as already surfaced earlier this session. */
+    readonly deduped: number;
+}
+interface AmbientRecallerOptions {
+    readonly recall: RecallFn;
+    /**
+     * Minimum cosine score for a hit to be worth surfacing unprompted. The
+     * single most important tuning knob — too low surfaces noise (naggy), too
+     * high never fires. The right value depends on the embedder; calibrate per
+     * instance against real conversations (the result diagnostics help). The
+     * default 0.5 is a conservative starting point for the bundled e5-small
+     * embedder.
+     */
+    readonly minScore?: number;
+    /** Max suggestions per `consider()`. Default 1 — ambient is one nudge, not a list. */
+    readonly maxSuggestions?: number;
+    /** Below this query length, do not even call the engine. Default 12. */
+    readonly minQueryChars?: number;
+    /**
+     * How many candidates to ask the engine for. Defaults to
+     * `maxSuggestions + 4` so dedup/threshold filtering has headroom.
+     */
+    readonly candidateK?: number;
+    /** Shared backpressure controller. Omit to use a fresh one. */
+    readonly backpressure?: AmbientBackpressure;
+}
+/**
+ * Decides *whether* and *which* past memory to surface in the flow of a live
+ * conversation — the ambient counterpart to the explicit `/recall` command
+ * (memory-extended-design.md deferred this "notice and offer" reliability to
+ * a proactive-curator-connected follow-up; this is it).
+ *
+ * It does not embed, search, or format anything itself. It takes the recent
+ * conversation, derives a query, asks the injected recall engine, and applies
+ * three gates so the surface stays useful and non-naggy:
+ *
+ *   1. **Backpressure** — after N consecutive declines (see
+ *      {@link AmbientBackpressure}) it goes silent for the rest of the session.
+ *   2. **Score threshold** — only confident hits surface.
+ *   3. **Session dedup** — a hit already offered this session is not re-offered.
+ *
+ * Stateful by design (the dedup set + backpressure streak live across turns),
+ * so a host keeps ONE instance alive for the session — a long-lived runtime
+ * or the opt-in embedder daemon. A stateless per-call host (a plain slash
+ * command) cannot carry the gate state; that is exactly why the default
+ * Claude Code surface is agent-guidance, not a command (see the design docs).
+ */
+declare class AmbientRecaller {
+    private readonly recall;
+    private readonly minScore;
+    private readonly maxSuggestions;
+    private readonly minQueryChars;
+    private readonly candidateK;
+    private readonly backpressure;
+    private readonly surfaced;
+    constructor(options: AmbientRecallerOptions);
+    /**
+     * Consider surfacing a memory given the current conversation. Pass an
+     * explicit `query` (the host knows what the user is referencing) or recent
+     * `turns` to derive one from. Returns the gated suggestions plus diagnostics.
+     *
+     * Does not catch errors from the injected engine — a failing embedder
+     * should surface to the host (which decides whether to swallow it for the
+     * turn), not be masked here.
+     */
+    consider(input: {
+        readonly query?: string;
+        readonly turns?: readonly TurnRecord[];
+    }): Promise<AmbientRecallResult>;
+    /** The user engaged with a surfaced suggestion — clears the decline streak. */
+    recordAccept(): void;
+    /** The user dismissed a surfaced suggestion — counts toward backpressure. */
+    recordDecline(): void;
+    /** True when backpressure has silenced ambient surfacing for the session. */
+    get suppressed(): boolean;
+    /**
+     * Re-engage after backpressure (the user explicitly asks for suggestions
+     * again, e.g. via `/curate`). Clears the decline streak AND the dedup set
+     * so previously surfaced hits can be offered again.
+     */
+    reset(): void;
+}
+/**
+ * Build a recall query from recent turns. Uses the most recent *user* turn —
+ * in ambient use the trigger is the user's latest utterance ("didn't I do
+ * this before?"), and that utterance is the query. Falls back to the most
+ * recent turn of any role if the window has no user turn.
+ */
+declare function deriveQueryFromTurns(turns: readonly TurnRecord[]): string;
+
+/**
+ * Shared building blocks for host `LLMJudge` adapters that work by injecting a
+ * single-shot "prompt in, string out" call.
+ *
+ * Every first-party host (Claude Code, Codex, Gemini, Claude Desktop) reaches
+ * its LLM differently — a sub-agent tool call, an inline completion, an MCP
+ * call, a desktop surface — but that difference is entirely in the *raw
+ * invoker* the host injects. The work *around* the call is identical: frame
+ * the proposer's prompt so the model returns only the requested shape, then
+ * parse the raw response tolerantly. That shared work lives here so each host
+ * adapter is a thin shell over one injected function (the design's
+ * "subsequent hosts inherit the pattern").
+ */
+/** A host's single-shot LLM call: a prompt in, a raw string out. */
+interface InjectedInvoker {
+    (input: {
+        readonly prompt: string;
+    }): Promise<string>;
+}
+/**
+ * Base error for injected-host LLMJudge adapters. Each host subclass narrows
+ * the `name` (e.g. `ClaudeCodeLLMJudgeError`) so callers can distinguish the
+ * source host while still catching the family with `instanceof LLMJudgeError`.
+ */
+declare class LLMJudgeError extends Error {
+    readonly raw?: string | undefined;
+    constructor(message: string, raw?: string | undefined);
+}
+/**
+ * Frame a proposer prompt for a single-shot host LLM call. Host-agnostic —
+ * the instruction constrains the response to the expected shape and names no
+ * host facility, so every adapter shares it verbatim.
+ */
+declare function frameForJudge(prompt: string, expected: ExpectedShape): string;
+/**
+ * Parse a raw host response into the expected shape. Strings pass through
+ * trimmed; JSON answers are extracted tolerantly (a leading/trailing ```json
+ * fence, or a sentence wrapped around the object) and `JSON.parse`'d.
+ * Persistent format failure throws via the injected `makeError` factory so
+ * each adapter raises its own typed error rather than the base masking it.
+ */
+declare function parseJudgeResponse(raw: string, expected: ExpectedShape, makeError: (message: string, raw?: string) => Error): unknown;
+/**
+ * Shared base for host adapters built on an injected invoker. The base owns
+ * framing + parsing; a subclass declares only the host id and (optionally)
+ * overrides {@link makeError} to raise a host-named error type.
+ */
+declare abstract class InjectedLLMJudge implements LLMJudge {
+    protected readonly invoker: InjectedInvoker;
+    abstract readonly host: string;
+    constructor(invoker: InjectedInvoker);
+    /** Host adapters override to raise a host-named error subclass. */
+    protected makeError(message: string, raw?: string): Error;
+    ask(prompt: string, expected: ExpectedShape): Promise<unknown>;
+}
+
+/**
+ * Claude Code host adapter for `LLMJudge`.
+ *
+ * Claude Code's natural surface for a single-shot decision query is a
+ * **sub-agent tool call** — a separate, ephemeral agent invoked by the outer
+ * session with a focused prompt, returning its single answer. The adapter
+ * does not know how to invoke a sub-agent itself (that is Claude Code runtime
+ * territory); the host injects an invoker callback at construction time, and
+ * the shared {@link InjectedLLMJudge} base handles prompt framing + tolerant
+ * response parsing on top of it.
+ *
+ * The invoker callback is intentionally minimal — a single async function
+ * that takes a string and returns a string. Hosts that want to thread
+ * additional metadata (session id, tool budget) can capture them in the
+ * closure when they create the invoker.
+ */
+/** Claude Code's sub-agent invoker — a `prompt in, string out` call. */
+type ClaudeCodeSubAgentInvoker = InjectedInvoker;
+declare class ClaudeCodeLLMJudgeError extends LLMJudgeError {
+    constructor(message: string, raw?: string);
+}
+declare class ClaudeCodeLLMJudge extends InjectedLLMJudge {
+    readonly host = "claude-code";
+    protected makeError(message: string, raw?: string): Error;
+}
+
+/**
+ * Codex CLI host adapter for `LLMJudge`.
+ *
+ * Codex's natural surface for a single-shot decision query is an **inline
+ * completion** — the host runs the framed prompt as a one-off completion and
+ * returns the text. As with every adapter, the host injects that call; the
+ * shared base supplies framing + parsing. The only host-specific surface here
+ * is the `host` identifier (`"codex"`, matching the sessionArchive adapter
+ * convention) and the typed error.
+ */
+/** Codex's inline-completion invoker — a `prompt in, string out` call. */
+type CodexCompletionInvoker = InjectedInvoker;
+declare class CodexLLMJudgeError extends LLMJudgeError {
+    constructor(message: string, raw?: string);
+}
+declare class CodexLLMJudge extends InjectedLLMJudge {
+    readonly host = "codex";
+    protected makeError(message: string, raw?: string): Error;
+}
+
+/**
+ * Gemini CLI host adapter for `LLMJudge`.
+ *
+ * Gemini's natural surface for a single-shot decision query is an **MCP call**
+ * — the host routes the framed prompt through its model-call tool and returns
+ * the text. The host injects that call; the shared base supplies framing +
+ * parsing. Host-specific surface is the `host` identifier (`"gemini"`,
+ * matching the sessionArchive adapter convention) and the typed error.
+ */
+/** Gemini's MCP-call invoker — a `prompt in, string out` call. */
+type GeminiMcpInvoker = InjectedInvoker;
+declare class GeminiLLMJudgeError extends LLMJudgeError {
+    constructor(message: string, raw?: string);
+}
+declare class GeminiLLMJudge extends InjectedLLMJudge {
+    readonly host = "gemini";
+    protected makeError(message: string, raw?: string): Error;
+}
+
+/**
+ * Claude Desktop host adapter for `LLMJudge`.
+ *
+ * Claude Desktop's natural surface for a single-shot decision query is a
+ * **response on its own conversation surface** — the host poses the framed
+ * prompt and returns the model's reply. The host injects that call; the
+ * shared base supplies framing + parsing. Host-specific surface is the `host`
+ * identifier (`"claude-desktop"`, matching the sessionArchive adapter
+ * convention) and the typed error.
+ */
+/** Claude Desktop's response invoker — a `prompt in, string out` call. */
+type ClaudeDesktopInvoker = InjectedInvoker;
+declare class ClaudeDesktopLLMJudgeError extends LLMJudgeError {
+    constructor(message: string, raw?: string);
+}
+declare class ClaudeDesktopLLMJudge extends InjectedLLMJudge {
+    readonly host = "claude-desktop";
+    protected makeError(message: string, raw?: string): Error;
+}
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$1_AcceptResult = AcceptResult;
+type index_d$1_AmbientBackpressure = AmbientBackpressure;
+declare const index_d$1_AmbientBackpressure: typeof AmbientBackpressure;
+type index_d$1_AmbientRecallHit = AmbientRecallHit;
+type index_d$1_AmbientRecallResult = AmbientRecallResult;
+type index_d$1_AmbientRecaller = AmbientRecaller;
+declare const index_d$1_AmbientRecaller: typeof AmbientRecaller;
+type index_d$1_AmbientRecallerOptions = AmbientRecallerOptions;
+type index_d$1_ClaudeCodeLLMJudge = ClaudeCodeLLMJudge;
+declare const index_d$1_ClaudeCodeLLMJudge: typeof ClaudeCodeLLMJudge;
+type index_d$1_ClaudeCodeLLMJudgeError = ClaudeCodeLLMJudgeError;
+declare const index_d$1_ClaudeCodeLLMJudgeError: typeof ClaudeCodeLLMJudgeError;
+type index_d$1_ClaudeCodeSubAgentInvoker = ClaudeCodeSubAgentInvoker;
+type index_d$1_ClaudeDesktopInvoker = ClaudeDesktopInvoker;
+type index_d$1_ClaudeDesktopLLMJudge = ClaudeDesktopLLMJudge;
+declare const index_d$1_ClaudeDesktopLLMJudge: typeof ClaudeDesktopLLMJudge;
+type index_d$1_ClaudeDesktopLLMJudgeError = ClaudeDesktopLLMJudgeError;
+declare const index_d$1_ClaudeDesktopLLMJudgeError: typeof ClaudeDesktopLLMJudgeError;
+type index_d$1_CodexCompletionInvoker = CodexCompletionInvoker;
+type index_d$1_CodexLLMJudge = CodexLLMJudge;
+declare const index_d$1_CodexLLMJudge: typeof CodexLLMJudge;
+type index_d$1_CodexLLMJudgeError = CodexLLMJudgeError;
+declare const index_d$1_CodexLLMJudgeError: typeof CodexLLMJudgeError;
+type index_d$1_DeclinedEntry = DeclinedEntry;
+type index_d$1_ExpectedShape = ExpectedShape;
+type index_d$1_FingerprintInput = FingerprintInput;
+type index_d$1_GeminiLLMJudge = GeminiLLMJudge;
+declare const index_d$1_GeminiLLMJudge: typeof GeminiLLMJudge;
+type index_d$1_GeminiLLMJudgeError = GeminiLLMJudgeError;
+declare const index_d$1_GeminiLLMJudgeError: typeof GeminiLLMJudgeError;
+type index_d$1_GeminiMcpInvoker = GeminiMcpInvoker;
+type index_d$1_HubInput = HubInput;
+type index_d$1_HubProposal = HubProposal;
+type index_d$1_HubProposer = HubProposer;
+declare const index_d$1_HubProposer: typeof HubProposer;
+type index_d$1_HubProposerOptions = HubProposerOptions;
+type index_d$1_InjectedInvoker = InjectedInvoker;
+type index_d$1_InjectedLLMJudge = InjectedLLMJudge;
+declare const index_d$1_InjectedLLMJudge: typeof InjectedLLMJudge;
+type index_d$1_InsightInput = InsightInput;
+type index_d$1_InsightProposal = InsightProposal;
+type index_d$1_InsightProposer = InsightProposer;
+declare const index_d$1_InsightProposer: typeof InsightProposer;
+type index_d$1_InsightProposerOptions = InsightProposerOptions;
+type index_d$1_LLMJudge = LLMJudge;
+type index_d$1_LLMJudgeError = LLMJudgeError;
+declare const index_d$1_LLMJudgeError: typeof LLMJudgeError;
+type index_d$1_Proposal = Proposal;
+type index_d$1_ProposalAction = ProposalAction;
+type index_d$1_ProposalKind = ProposalKind;
+type index_d$1_Proposer<Input, P extends Proposal = Proposal> = Proposer<Input, P>;
+type index_d$1_ProposerContext = ProposerContext;
+type index_d$1_RecallFn = RecallFn;
+type index_d$1_RecallSuggestion = RecallSuggestion;
+type index_d$1_TopicTreeSnapshot = TopicTreeSnapshot;
+type index_d$1_TurnBuffer = TurnBuffer;
+declare const index_d$1_TurnBuffer: typeof TurnBuffer;
+type index_d$1_TurnRecord = TurnRecord;
+declare const index_d$1_computeFingerprint: typeof computeFingerprint;
+declare const index_d$1_deriveQueryFromTurns: typeof deriveQueryFromTurns;
+declare const index_d$1_frameForJudge: typeof frameForJudge;
+declare const index_d$1_loadDeclinedFingerprints: typeof loadDeclinedFingerprints;
+declare const index_d$1_parseJudgeResponse: typeof parseJudgeResponse;
+declare const index_d$1_recordAcceptance: typeof recordAcceptance;
+declare const index_d$1_recordDecline: typeof recordDecline;
+declare const index_d$1_resetDeclined: typeof resetDeclined;
+declare namespace index_d$1 {
+  export { type index_d$1_AcceptResult as AcceptResult, index_d$1_AmbientBackpressure as AmbientBackpressure, type index_d$1_AmbientRecallHit as AmbientRecallHit, type index_d$1_AmbientRecallResult as AmbientRecallResult, index_d$1_AmbientRecaller as AmbientRecaller, type index_d$1_AmbientRecallerOptions as AmbientRecallerOptions, index_d$1_ClaudeCodeLLMJudge as ClaudeCodeLLMJudge, index_d$1_ClaudeCodeLLMJudgeError as ClaudeCodeLLMJudgeError, type index_d$1_ClaudeCodeSubAgentInvoker as ClaudeCodeSubAgentInvoker, type index_d$1_ClaudeDesktopInvoker as ClaudeDesktopInvoker, index_d$1_ClaudeDesktopLLMJudge as ClaudeDesktopLLMJudge, index_d$1_ClaudeDesktopLLMJudgeError as ClaudeDesktopLLMJudgeError, type index_d$1_CodexCompletionInvoker as CodexCompletionInvoker, index_d$1_CodexLLMJudge as CodexLLMJudge, index_d$1_CodexLLMJudgeError as CodexLLMJudgeError, type index_d$1_DeclinedEntry as DeclinedEntry, type index_d$1_ExpectedShape as ExpectedShape, type index_d$1_FingerprintInput as FingerprintInput, index_d$1_GeminiLLMJudge as GeminiLLMJudge, index_d$1_GeminiLLMJudgeError as GeminiLLMJudgeError, type index_d$1_GeminiMcpInvoker as GeminiMcpInvoker, type index_d$1_HubInput as HubInput, type index_d$1_HubProposal as HubProposal, index_d$1_HubProposer as HubProposer, type index_d$1_HubProposerOptions as HubProposerOptions, type index_d$1_InjectedInvoker as InjectedInvoker, index_d$1_InjectedLLMJudge as InjectedLLMJudge, type index_d$1_InsightInput as InsightInput, type index_d$1_InsightProposal as InsightProposal, index_d$1_InsightProposer as InsightProposer, type index_d$1_InsightProposerOptions as InsightProposerOptions, type index_d$1_LLMJudge as LLMJudge, index_d$1_LLMJudgeError as LLMJudgeError, type index_d$1_Proposal as Proposal, type index_d$1_ProposalAction as ProposalAction, type index_d$1_ProposalKind as ProposalKind, type index_d$1_Proposer as Proposer, type index_d$1_ProposerContext as ProposerContext, type index_d$1_RecallFn as RecallFn, type index_d$1_RecallSuggestion as RecallSuggestion, type index_d$1_TopicTreeSnapshot as TopicTreeSnapshot, index_d$1_TurnBuffer as TurnBuffer, type index_d$1_TurnRecord as TurnRecord, index_d$1_computeFingerprint as computeFingerprint, index_d$1_deriveQueryFromTurns as deriveQueryFromTurns, index_d$1_frameForJudge as frameForJudge, index_d$1_loadDeclinedFingerprints as loadDeclinedFingerprints, index_d$1_parseJudgeResponse as parseJudgeResponse, index_d$1_recordAcceptance as recordAcceptance, index_d$1_recordDecline as recordDecline, index_d$1_resetDeclined as resetDeclined };
+}
+
+/**
+ * `/curate` — surface accumulated proposals from the proactive-curator
+ * module. Two surfaces share one command:
+ *
+ *  - `/curate`                    — run both proposers; surface any results.
+ *  - `/curate --insight`          — InsightProposer only.
+ *  - `/curate --hub`              — HubProposer only.
+ *  - `/curate --reset-declined`   — clear the decline list (escape hatch).
+ *
+ * Host integration:
+ *  1. Construct an `LLMJudge` adapter for the host (Claude Code / Codex /
+ *     Gemini / Claude Desktop) — see `@vortex-os/proactive-curator`.
+ *  2. Optionally provide an `insightInputProvider` callback that returns
+ *     the current `InsightInput` (recent turns + accumulated tokens) when
+ *     the host wants the in-session insight surface. Without this provider
+ *     the insight proposer is skipped.
+ *  3. Pass both to `createRitualRegistry({ llm, insightInputProvider })`.
+ *     The `/curate` command is registered only when an LLMJudge is
+ *     supplied — instances that have not wired up a host LLM get the rest
+ *     of the rituals without a half-broken curate command.
+ *
+ * Result shape carries the full `Proposal` objects (with `onAccept` and
+ * `onDecline` thunks). Hosts render the previews, ask the user to decide,
+ * then call the thunks. This is the one command in `session-rituals`
+ * whose result is intentionally non-serializable — the thunks are the
+ * point.
+ */
+interface CurateOptions {
+    readonly llm: LLMJudge;
+    /**
+     * Returns the current InsightInput when the host wants the in-session
+     * surface to run. Absence is a feature: hosts that only want hub
+     * curation can omit it and the insight proposer is skipped without
+     * error.
+     */
+    readonly insightInputProvider?: () => InsightInput | null;
+    readonly insightProposer?: InsightProposer;
+    readonly hubProposer?: HubProposer;
+}
+type CurateAnyProposal = InsightProposal | HubProposal;
+interface CurateResult {
+    readonly subcommand: "curate";
+    readonly status: "ok" | "reset-declined";
+    readonly proposals: readonly CurateAnyProposal[];
+    readonly skipped: {
+        readonly insight: boolean;
+        readonly hub: boolean;
+    };
+    readonly nextActions: readonly string[];
+}
+/**
+ * Build the `/curate` command bound to a particular LLMJudge and optional
+ * input provider. Returned as a factory so the registry can decide at
+ * registration time whether to install the command at all.
+ */
+declare function curateCommand(options: CurateOptions): Command<CurateResult>;
+
+/**
+ * `/recall <query>` — hybrid semantic search over memories, defined in the
+ * plugin over the `@vortex-os/memory-extended` engine (mirrors how
+ * `/curate` is defined here over `proactive-curator`). Keeping the command
+ * in the plugin lets the module stay free of any slash-commands dependency.
+ *
+ * Host integration:
+ *  1. Supply an embedder. `vector.createLocalEmbedder()` is the bundled
+ *     default (local MiniLM, model downloads on first use); pass an
+ *     OpenAI/Voyage adapter to use an API instead.
+ *  2. Pass it to `createRitualRegistry({ recall: { embed } })`. The command
+ *     is registered only when an embedder is supplied — instances that have
+ *     not wired one up get the rest of the rituals without a half-broken
+ *     recall command (same graceful-degradation rule as `/curate`).
+ *
+ * The handler returns the structured `RecallResult` (data, not a report —
+ * operator decision 5 / 2026-05-29). The host renders a list with
+ * `vector`/`recall` render helpers for an explicit search, or reads the
+ * hits and phrases one in conversation for ambient use.
+ */
+interface RecallOptions {
+    /** Embedding function. `vector.createLocalEmbedder()` for the default. */
+    readonly embed: vector.EmbedFn;
+    /** Override the DB path. Default `<dataDir>/_indexes/memory.sqlite`. */
+    readonly dbPath?: (ctx: ModuleContext) => string;
+    /** Default hit count when `--k` is absent. Default 5. */
+    readonly defaultK?: number;
+}
+declare function recallCommand(options: RecallOptions): Command<recall.RecallResult>;
+
+/**
+ * Options accepted by {@link createRitualRegistry}. All fields are optional;
+ * each one unlocks an additional command surface when supplied:
+ *
+ *  - `curate` — when an `LLMJudge` is provided, the `/curate` command from
+ *    `@vortex-os/proactive-curator` is registered. Without it the rest of
+ *    the rituals work as before and `/curate` is simply absent (graceful
+ *    degradation rather than a half-broken command).
+ *  - `recall` — when an embedder is provided, the `/recall` command over
+ *    `@vortex-os/memory-extended` is registered. Same graceful-degradation
+ *    rule: absent the embedder, semantic recall would not work, so the
+ *    command is simply not installed.
+ */
+interface RitualRegistryOptions {
+    readonly curate?: CurateOptions;
+    readonly recall?: RecallOptions;
+}
+/**
+ * Build a {@link CommandRegistry} with all ritual commands registered.
+ *
+ * Hosts that want a subset can register the individual exports instead.
+ * This factory exists for the common case — "give me everything" — plus
+ * opt-in surfaces that depend on host-supplied adapters (currently
+ * `/curate`, which needs an `LLMJudge`).
+ */
+declare function createRitualRegistry(options?: RitualRegistryOptions): CommandRegistry;
+
+/**
+ * Bridge the `@vortex-os/memory-extended` recall engine into a
+ * `@vortex-os/proactive-curator` {@link AmbientRecaller} — defined in the
+ * plugin, exactly where `/recall` and `/curate` are defined over their
+ * respective engines. This keeps both modules free of a dependency on each
+ * other; the plugin is the only place that knows about both.
+ *
+ * This is deliberately **not** a slash command. Ambient recall is stateful
+ * across turns (its dedup set + backpressure streak), so it belongs to a
+ * long-lived host — the opt-in embedder daemon / `UserPromptSubmit` hook, or
+ * any host runtime that keeps one instance alive for the session. The default
+ * Claude Code surface is agent-guidance (see `docs/proactive-curator-design.md`);
+ * this factory is for hosts that opt into the *automatic* surface.
+ *
+ * Construct **once per session** and reuse the returned recaller so its gate
+ * state persists. The injected `RecallFn` opens DB handles lazily per call
+ * and closes them in a `finally`, so a long-lived process never holds a file
+ * lock between turns. The embedder (the expensive, warm-able part) is
+ * supplied by the host so it can keep the model resident across calls.
+ */
+interface AmbientRecallFactoryOptions {
+    /** Embedding function. The host keeps this warm (daemon) to avoid per-call model loads. */
+    readonly embed: vector.EmbedFn;
+    /** Override the DB path. Default `<dataDir>/_indexes/memory.sqlite`. */
+    readonly dbPath?: (ctx: ModuleContext) => string;
+    /** Restrict recall to one corpus. Omit to search all. */
+    readonly source?: vector.VectorSource;
+    /** Forwarded to AmbientRecaller — minimum cosine score to surface. Default 0.5. */
+    readonly minScore?: number;
+    /** Forwarded to AmbientRecaller — max suggestions per consider(). Default 1. */
+    readonly maxSuggestions?: number;
+    /** Forwarded to AmbientRecaller — skip the engine below this query length. Default 12. */
+    readonly minQueryChars?: number;
+}
+/**
+ * Build a session-scoped {@link AmbientRecaller} wired to the recall engine.
+ * Returns `undefined`-free — the caller owns the lifecycle.
+ */
+declare function createAmbientRecaller(ctx: ModuleContext, options: AmbientRecallFactoryOptions): AmbientRecaller;
+
+/**
+ * Output of {@link sessionStartCommand}'s handler. Pure data — the host
+ * decides how to display it. Returning structured output rather than
+ * printing keeps the command usable from non-CLI hosts (tests, web UIs).
+ */
+interface SessionStartReport {
+    readonly time: string;
+    readonly repoRoot: string;
+    readonly dataDir: string;
+    readonly counts: Readonly<Record<string, number>>;
+    readonly missing: readonly string[];
+}
+/**
+ * `/session-start` — Emit a small report that anchors a new session.
+ * No side effects: reads filesystem counts only.
+ *
+ * The host (e.g. Claude Code session loop) is expected to display the
+ * report and decide what to do next. This command's job is to surface
+ * the facts, not to take action.
+ */
+declare const sessionStartCommand: Command<SessionStartReport>;
+
+interface RecentWorklog {
+    /** Path relative to the data directory (e.g. `worklog/2026/05/2026-05-30-foo.md`). */
+    readonly path: string;
+    /** First `# ` heading, else the filename without extension. */
+    readonly title: string;
+}
+/** Outcome of the optional `git pull` the hook runs before reporting. */
+interface GitPullResult {
+    readonly ran: boolean;
+    readonly summary: string;
+    /** True when the pull could not fast-forward (divergence / dirty tree). Never auto-resolved. */
+    readonly conflict: boolean;
+}
+interface SessionStartHookReport {
+    readonly time: string;
+    readonly repoRoot: string;
+    readonly dataDir: string;
+    readonly counts: Readonly<Record<string, number>>;
+    readonly missing: readonly string[];
+    readonly recentWorklog: RecentWorklog | null;
+    /** Worklog dates (`YYYY-MM-DD`) present within the gap window — for backfill detection. */
+    readonly recentWorklogDates: readonly string[];
+    /** Resolved environment label (e.g. home/work), or null when none is configured. */
+    readonly environment: string | null;
+}
+/**
+ * Gather the read-only facts for a start-of-session report: data-dir counts,
+ * the most recent worklog, recent worklog dates, and an optional environment
+ * label. Mirrors the `/session-start` command's counting.
+ */
+declare function collectSessionStartReport(ctx: ModuleContext, opts?: {
+    readonly now?: Date;
+    readonly environment?: string | null;
+    readonly gapWindowDays?: number;
+}): Promise<SessionStartHookReport>;
+/**
+ * Days that have commits but no worklog — backfill candidates. Pure set
+ * difference (`commitDays` − `presentDates`), de-duplicated and sorted. The
+ * hook supplies `commitDays` from git; the report supplies the present dates.
+ */
+declare function detectWorklogGaps(commitDays: readonly string[], presentDates: readonly string[]): string[];
+/**
+ * Render a session-start report as a compact markdown block for a host hook
+ * to inject as session context. A pull conflict and any worklog gaps are
+ * surfaced as warnings (the agent acts on the gaps — see AGENT.md).
+ */
+declare function renderSessionStartReport(report: SessionStartHookReport, extras?: {
+    readonly git?: GitPullResult | null;
+    readonly missingWorklogDays?: readonly string[];
+    readonly catchUp?: {
+        readonly ingestedLocal: number;
+        readonly indexedPulled: number;
+        readonly errors: number;
+    };
+}): string;
+
+/**
+ * Ensure a dated worklog entry exists — the host-side **create** primitive
+ * the worklog module deliberately leaves out (`WorklogStore` reads; `/log`
+ * only appends and errors when today's entry is missing). Auto-worklog
+ * (the agent at wind-down, or the SessionEnd net) needs *creation*, so it
+ * lives here, where instance frontmatter conventions belong.
+ *
+ * Idempotent: if a worklog already exists for the date (with any keyword), it
+ * is returned untouched (`created: false`) — never overwritten. Pair with
+ * `appendSection` from `@vortex-os/worklog` to add the session's content.
+ */
+interface EnsureWorklogResult {
+    readonly path: string;
+    readonly date: string;
+    readonly keyword: string;
+    /** True when this call created the file; false when one already existed. */
+    readonly created: boolean;
+}
+declare function ensureWorklogEntry(ctx: ModuleContext, opts?: {
+    readonly now?: Date;
+    readonly keyword?: string;
+    readonly title?: string;
+    readonly body?: string;
+}): Promise<EnsureWorklogResult>;
+
+/**
+ * Start-of-session "catch-up": fold conversation transcripts into the local
+ * search archive without the user ever having to wrap up a session.
+ *
+ * Two sources, one pass:
+ *  - **local (a)** — this machine's own transcripts that are not archived yet,
+ *    read from the agent's transcript store and scoped to the current project.
+ *  - **pulled (b)** — transcripts created on another machine that arrived as
+ *    normalized text via git sync. Their text is present but this machine's
+ *    DB (local, derived, gitignored) has never indexed them.
+ *
+ * Text only — vectorization is deferred to recall/rebuild so session start
+ * stays fast. The whole step is gated by `autoRecord.archive` at the call site
+ * and is best-effort: callers should treat a thrown archive backend (e.g. the
+ * native sqlite module not built) as "skip", never as a fatal start error.
+ */
+interface CatchUpResult {
+    /** Local transcripts newly archived this run (source a). */
+    readonly ingestedLocal: number;
+    /** Normalized transcripts from another machine newly indexed (source b). */
+    readonly indexedPulled: number;
+    /** Per-session ingest errors (source a). */
+    readonly errors: number;
+}
+interface CatchUpOptions {
+    /** Restrict local ingest to one project's transcripts. Default: `ctx.repoRoot`. */
+    readonly cwd?: string;
+    /**
+     * Transcript adapters for local ingest. Default: Claude Code only. Other
+     * hosts (Codex, Gemini) can be added by a caller; tests inject fakes so the
+     * scan never touches the real home directory.
+     */
+    readonly adapters?: sessionArchive.IngestParams["adapters"];
+    /** Adapter environment override (e.g. a sandbox HOME). Tests use this. */
+    readonly env?: sessionArchive.IngestParams["env"];
+}
+declare function catchUpSessions(ctx: ModuleContext, opts?: CatchUpOptions): Promise<CatchUpResult>;
+
+/**
+ * Hook wiring for `/vortex init`: make sure the instance's
+ * `.claude/settings.json` registers the VortEX SessionStart / SessionEnd hooks,
+ * so the boot report + worklog-net fire automatically without the user knowing
+ * any command. NON-DESTRUCTIVE — like the MCP install merge, this preserves
+ * every other hook and top-level field and only adds our two entries if absent.
+ *
+ * Pure functions here (parse / merge / detect); the command does the actual
+ * file read/write around them. Keeping them pure makes the merge unit-testable
+ * and the "writes only what's missing" guarantee verifiable.
+ */
+declare const SESSION_START_COMMAND = "node plugins/session-rituals/scripts/session-start-hook.mjs";
+declare const SESSION_END_COMMAND = "node plugins/session-rituals/scripts/session-end-hook.mjs";
+interface HookCommand {
+    readonly type: "command";
+    readonly command: string;
+}
+interface HookGroup {
+    readonly hooks: readonly HookCommand[];
+    readonly matcher?: string;
+}
+interface ClaudeSettings {
+    hooks?: {
+        SessionStart?: HookGroup[];
+        SessionEnd?: HookGroup[];
+        [event: string]: HookGroup[] | undefined;
+    };
+    [key: string]: unknown;
+}
+interface EnsureHooksResult {
+    readonly settings: ClaudeSettings;
+    /** Which hook events we added a VortEX entry to (empty if already wired). */
+    readonly added: readonly ("SessionStart" | "SessionEnd")[];
+    /** True when nothing changed — every VortEX hook was already present. */
+    readonly alreadyWired: boolean;
+}
+/**
+ * Parse existing settings.json text. Empty/whitespace → `{}` (fresh). Throws on
+ * malformed JSON so the caller aborts rather than clobbering a hand-edited file.
+ */
+declare function parseSettings(text: string | null | undefined): ClaudeSettings;
+/**
+ * Merge the VortEX hooks into an existing settings object WITHOUT mutating the
+ * input. A hook event is left untouched if it already references our command
+ * (idempotent); otherwise our group is appended alongside any existing groups.
+ */
+declare function ensureVortexHooks(existing: ClaudeSettings | null | undefined): EnsureHooksResult;
+/** Serialize settings the way Claude writes them (2-space, trailing newline). */
+declare function serializeSettings(settings: ClaudeSettings): string;
+
+interface ReindexResult {
+    readonly dir: string;
+    readonly status: "written" | "unchanged" | "missing";
+    readonly entries: number;
+    readonly bytes: number;
+}
+/**
+ * `/reindex [dir]` — Regenerate `_INDEX.md` for one or all known data
+ * directories. When called with no argument, processes all targets;
+ * when called with a directory name, processes only that target.
+ *
+ * Returns a list of results so the host can summarize. Unchanged
+ * indexes are reported as `unchanged` (no write performed); missing
+ * directories are reported as `missing` (no write attempted).
+ */
+declare const reindexCommand: Command<readonly ReindexResult[]>;
+
+interface NewDecisionResult {
+    readonly path: string;
+    readonly date: string;
+    readonly slug: string;
+}
+/**
+ * `/decision <slug> <title...>` — Create a new Decision Log entry from
+ * the canonical template at `data/decision-log/<today>-<slug>.md`.
+ *
+ * `slug` is required and used in the filename. The remaining tokens form
+ * the entry title (the H1 in the rendered body). The command refuses to
+ * overwrite an existing file — it errors out so the caller can decide.
+ */
+declare const decisionCommand: Command<NewDecisionResult>;
+
+interface WorklogAppendResult {
+    readonly path: string;
+    readonly date: string;
+    readonly keyword: string;
+    readonly sectionTitle: string;
+}
+/**
+ * `/log <section-title>` — Append a `## <section-title>` section to today's
+ * worklog entry. If no worklog exists for today, the command errors (entry
+ * creation with frontmatter is left to the host so it can apply
+ * project-specific conventions). The body of the new section is left empty
+ * for the caller to fill in.
+ *
+ * This is a deliberately small command — the goal is to make "add a quick
+ * note to today's worklog" a one-liner, not to replace a real editor.
+ */
+declare const logCommand: Command<WorklogAppendResult>;
+
+/**
+ * "What should I do today?" — a read-only synthesis over existing records
+ * (worklog + decision-log + open `- [ ]` checkboxes), the P2 work-management
+ * surface. No new store: it reads what's already written and answers
+ * "what were you doing, what's open, what's next" from it.
+ *
+ * Design goal (operator, 2026-05-30): adapt to EVERY data state — a brand-new
+ * user with nothing, a partly-used instance, and a rich history must each get a
+ * sensible report. So the collector returns a structured, presence-flagged
+ * shape and the renderer branches on what's actually there rather than assuming
+ * any section exists.
+ */
+/** An unchecked `- [ ]` item lifted from a recent worklog body. */
+interface OpenTask {
+    readonly text: string;
+    /** Worklog date the task was found in (`YYYY-MM-DD`). */
+    readonly fromDate: string;
+}
+interface OpenDecision {
+    readonly title: string;
+    readonly date: string;
+    readonly slug: string;
+}
+interface AgendaReport {
+    /** Most recent worklog (what you were last doing), or null if none. */
+    readonly lastWorklog: {
+        readonly date: string;
+        readonly title: string;
+        readonly path: string;
+    } | null;
+    /**
+     * "Next up" lines lifted from the most recent worklog's hand-off section
+     * (`## 다음 작업` / `## Next` / a `📋`-marked heading) — the planned-work
+     * pointer, mirroring the vault TIL hand-off block. Empty if none.
+     */
+    readonly nextUp: readonly string[];
+    /** Date of the worklog the nextUp lines came from (or null). */
+    readonly nextUpFrom: string | null;
+    /** Unchecked checkboxes from recent worklogs, newest first, capped. */
+    readonly openTasks: readonly OpenTask[];
+    /** Active (non-archived) decisions, newest first, capped. */
+    readonly openDecisions: readonly OpenDecision[];
+    /** Total worklog / decision counts — used to distinguish "new" from "quiet". */
+    readonly worklogCount: number;
+    readonly decisionCount: number;
+    /** True when there is essentially nothing yet (brand-new instance). */
+    readonly isEmpty: boolean;
+    /** True when there are records but nothing actionable surfaced. */
+    readonly nothingOpen: boolean;
+}
+interface CollectAgendaOptions {
+    /** How many recent worklogs to scan for open tasks. Default 7. */
+    readonly recentWorklogs?: number;
+    /** Max open tasks / decisions to surface. Default 8 each. */
+    readonly maxTasks?: number;
+    readonly maxDecisions?: number;
+}
+/**
+ * Pull unchecked GitHub-style checkboxes (`- [ ]` / `* [ ]`, any indent) from a
+ * worklog body. Checked items (`- [x]`) are ignored. Returns the trimmed label.
+ */
+/**
+ * Lift the "next up / hand-off" section from a worklog body — the planned-work
+ * pointer the agent leaves at wind-down (mirrors the vault's TIL `## 📋 다음
+ * 작업` block). Matches a heading whose text contains any of: "다음 작업",
+ * "다음 세션", "next", "next up", "todo", "후속", "📋". Returns the section's
+ * content lines (bullets de-marked, blanks dropped), capped. Empty if no such
+ * section. Stops at the next heading of the same-or-higher level.
+ */
+declare function extractNextUp(body: string, max?: number): string[];
+/**
+ * Pull unchecked GitHub-style checkboxes (`- [ ]` / `* [ ]`, any indent) from a
+ * worklog body. Checked items (`- [x]`) are ignored. Returns the trimmed label.
+ */
+declare function extractOpenTasks(body: string): string[];
+/**
+ * Collect the agenda inputs. Read-only; tolerant of missing dirs (both stores
+ * return empty rather than throwing), so a brand-new instance yields an empty —
+ * but well-formed — report.
+ */
+declare function collectAgenda(ctx: ModuleContext, opts?: CollectAgendaOptions): Promise<AgendaReport>;
+/**
+ * Render the agenda as a compact markdown block. Branches on data state so the
+ * output is sensible whether the instance is brand-new, quiet, or busy:
+ *   - brand-new (no records)     → a short "getting started" nudge
+ *   - records but nothing open   → "you're clear" + last activity
+ *   - open tasks / decisions     → an actionable list
+ */
+declare function renderAgenda(report: AgendaReport): string;
+
+/**
+ * `/agenda` — "What should I do today?" Read-only synthesis over existing
+ * worklog + decision-log records (open `- [ ]` tasks, active decisions, last
+ * activity). Returns structured {@link AgendaReport} data; the host renders it
+ * (or calls `renderAgenda`). No writes, no new store — answers from what's
+ * already recorded, and adapts to any data state (new / quiet / busy).
+ */
+declare const agendaCommand: Command<AgendaReport>;
+
+/**
+ * `/vortex <sub>` — Root command for VortEX instance operations.
+ *
+ * Subcommands:
+ *   init    — first-time setup wizard (user profile + first worklog; detects
+ *             external folders in $HOME and surfaces an import hint)
+ *   status  — instance state report (counts, profile, latestWorklog, missing)
+ *   import  — copy a folder into the instance, auto-classify into 5 categories
+ *             or preserve user folder structure, inject frontmatter, scan
+ *             wiki-link health via @vortex-os/link-rewriter
+ *   doctor  — 8-check health diagnosis (system dirs, profile, indexes,
+ *             wiki links, data-lint rules, runbook aging, node version,
+ *             git remote)
+ *   sync    — framework-developer workflow: git pull → npm install → npm run
+ *             build → npm run verify. Stops on first failure with stdout/stderr
+ *             tail. End users who consume vortex from npm registry do not need
+ *             this — they get pre-built dist via `npm install @vortex-os/*`.
+ *   help    — list available subcommands
+ */
+declare const PLANNED_SUBS: readonly [];
+type PlannedSub = (typeof PLANNED_SUBS)[number];
+interface VortexInitResult {
+    readonly subcommand: "init";
+    readonly status: "completed" | "needs-input" | "already-initialized";
+    readonly created: readonly string[];
+    readonly nextActions: readonly string[];
+    readonly missingInputs?: readonly {
+        name: string;
+        prompt: string;
+    }[];
+    readonly externalFolders?: readonly {
+        readonly path: string;
+        readonly basename: string;
+        readonly mdCount: number;
+    }[];
+}
+interface VortexPlannedResult {
+    readonly subcommand: PlannedSub | "unknown";
+    readonly status: "not-implemented";
+    readonly message: string;
+}
+interface VortexHelpResult {
+    readonly subcommand: "help";
+    readonly status: "ok";
+    /** `/vortex <sub>` subcommands routed inside this command. */
+    readonly subcommands: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly state: "active" | "planned";
+    }[];
+    /**
+     * Other top-level slash commands shipped by the same plugin
+     * (`session-rituals`). Independent commands, not `/vortex` subcommands —
+     * surfaced here so users discover the full plugin surface from a single
+     * `/vortex help` call instead of needing to know they exist separately.
+     */
+    readonly siblingCommands: readonly {
+        readonly name: string;
+        readonly description: string;
+    }[];
+}
+interface VortexStatusResult {
+    readonly subcommand: "status";
+    readonly status: "ok" | "uninitialized";
+    readonly instance: {
+        readonly dataDir: string;
+        readonly initialized: boolean;
+        readonly profile?: {
+            readonly name?: string;
+            readonly role?: string;
+        };
+    };
+    readonly counts: {
+        readonly memory: number;
+        readonly worklog: number;
+        readonly decisionLog: number;
+        readonly runbooks: number;
+        readonly hubs: number;
+    };
+    readonly latestWorklog?: {
+        readonly date: string;
+        readonly keyword: string;
+        readonly path: string;
+    };
+    readonly missing: readonly string[];
+    readonly nextActions: readonly string[];
+}
+interface VortexImportResult {
+    readonly subcommand: "import";
+    readonly status: "completed" | "dry-run" | "needs-input" | "source-missing";
+    readonly source?: string;
+    readonly totalFiles: number;
+    readonly copied: number;
+    readonly classified: {
+        readonly worklog: number;
+        readonly decisionLog: number;
+        readonly runbooks: number;
+        readonly hubs: number;
+        readonly memory: number;
+        readonly preserved: number;
+    };
+    readonly frontmatterInjected: number;
+    readonly frontmatterPreserved: number;
+    readonly systemDirsCreated: readonly string[];
+    readonly skipped: number;
+    readonly links?: {
+        readonly filesScanned: number;
+        readonly total: number;
+        readonly resolved: number;
+        readonly broken: number;
+        readonly ambiguous: number;
+    };
+    readonly missingInputs?: readonly {
+        name: string;
+        prompt: string;
+    }[];
+    readonly nextActions: readonly string[];
+}
+type DoctorCheckStatus = "pass" | "warn" | "fail" | "info";
+interface DoctorCheck {
+    readonly id: string;
+    readonly label: string;
+    readonly status: DoctorCheckStatus;
+    readonly detail?: string;
+}
+interface VortexDoctorResult {
+    readonly subcommand: "doctor";
+    readonly status: "ok" | "warnings" | "errors";
+    readonly checks: readonly DoctorCheck[];
+    readonly summary: {
+        readonly pass: number;
+        readonly warn: number;
+        readonly fail: number;
+        readonly info: number;
+    };
+    readonly nextActions: readonly string[];
+}
+type VortexSyncStepId = "pull" | "install" | "build" | "verify";
+type VortexSyncStepStatus = "ok" | "failed" | "skipped";
+interface VortexSyncStep {
+    readonly id: VortexSyncStepId;
+    readonly label: string;
+    readonly status: VortexSyncStepStatus;
+    readonly exitCode?: number;
+    readonly durationMs?: number;
+    readonly stdoutTail?: string;
+    readonly stderrTail?: string;
+}
+interface VortexSyncResult {
+    readonly subcommand: "sync";
+    readonly status: "completed" | "failed" | "dry-run";
+    readonly steps: readonly VortexSyncStep[];
+    readonly failedAt?: VortexSyncStepId;
+    readonly nextActions: readonly string[];
+}
+type VortexResult = VortexInitResult | VortexStatusResult | VortexImportResult | VortexDoctorResult | VortexSyncResult | VortexPlannedResult | VortexHelpResult;
+declare const vortexCommand: Command<VortexResult>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d_AgendaReport = AgendaReport;
+type index_d_AmbientRecallFactoryOptions = AmbientRecallFactoryOptions;
+type index_d_CatchUpOptions = CatchUpOptions;
+type index_d_CatchUpResult = CatchUpResult;
+type index_d_ClaudeSettings = ClaudeSettings;
+type index_d_CollectAgendaOptions = CollectAgendaOptions;
+type index_d_CurateAnyProposal = CurateAnyProposal;
+type index_d_CurateOptions = CurateOptions;
+type index_d_CurateResult = CurateResult;
+type index_d_EnsureHooksResult = EnsureHooksResult;
+type index_d_EnsureWorklogResult = EnsureWorklogResult;
+type index_d_GitPullResult = GitPullResult;
+type index_d_NewDecisionResult = NewDecisionResult;
+type index_d_OpenDecision = OpenDecision;
+type index_d_OpenTask = OpenTask;
+type index_d_RecallOptions = RecallOptions;
+type index_d_RecentWorklog = RecentWorklog;
+type index_d_ReindexResult = ReindexResult;
+type index_d_RitualRegistryOptions = RitualRegistryOptions;
+declare const index_d_SESSION_END_COMMAND: typeof SESSION_END_COMMAND;
+declare const index_d_SESSION_START_COMMAND: typeof SESSION_START_COMMAND;
+type index_d_SessionStartHookReport = SessionStartHookReport;
+type index_d_SessionStartReport = SessionStartReport;
+type index_d_VortexHelpResult = VortexHelpResult;
+type index_d_VortexInitResult = VortexInitResult;
+type index_d_VortexPlannedResult = VortexPlannedResult;
+type index_d_VortexResult = VortexResult;
+type index_d_VortexSyncResult = VortexSyncResult;
+type index_d_VortexSyncStep = VortexSyncStep;
+type index_d_VortexSyncStepId = VortexSyncStepId;
+type index_d_VortexSyncStepStatus = VortexSyncStepStatus;
+type index_d_WorklogAppendResult = WorklogAppendResult;
+declare const index_d_agendaCommand: typeof agendaCommand;
+declare const index_d_catchUpSessions: typeof catchUpSessions;
+declare const index_d_collectAgenda: typeof collectAgenda;
+declare const index_d_collectSessionStartReport: typeof collectSessionStartReport;
+declare const index_d_createAmbientRecaller: typeof createAmbientRecaller;
+declare const index_d_createRitualRegistry: typeof createRitualRegistry;
+declare const index_d_curateCommand: typeof curateCommand;
+declare const index_d_decisionCommand: typeof decisionCommand;
+declare const index_d_detectWorklogGaps: typeof detectWorklogGaps;
+declare const index_d_ensureVortexHooks: typeof ensureVortexHooks;
+declare const index_d_ensureWorklogEntry: typeof ensureWorklogEntry;
+declare const index_d_extractNextUp: typeof extractNextUp;
+declare const index_d_extractOpenTasks: typeof extractOpenTasks;
+declare const index_d_logCommand: typeof logCommand;
+declare const index_d_parseSettings: typeof parseSettings;
+declare const index_d_recallCommand: typeof recallCommand;
+declare const index_d_reindexCommand: typeof reindexCommand;
+declare const index_d_renderAgenda: typeof renderAgenda;
+declare const index_d_renderSessionStartReport: typeof renderSessionStartReport;
+declare const index_d_serializeSettings: typeof serializeSettings;
+declare const index_d_sessionStartCommand: typeof sessionStartCommand;
+declare const index_d_vortexCommand: typeof vortexCommand;
+declare namespace index_d {
+  export { type index_d_AgendaReport as AgendaReport, type index_d_AmbientRecallFactoryOptions as AmbientRecallFactoryOptions, type index_d_CatchUpOptions as CatchUpOptions, type index_d_CatchUpResult as CatchUpResult, type index_d_ClaudeSettings as ClaudeSettings, type index_d_CollectAgendaOptions as CollectAgendaOptions, type index_d_CurateAnyProposal as CurateAnyProposal, type index_d_CurateOptions as CurateOptions, type index_d_CurateResult as CurateResult, type index_d_EnsureHooksResult as EnsureHooksResult, type index_d_EnsureWorklogResult as EnsureWorklogResult, type index_d_GitPullResult as GitPullResult, type index_d_NewDecisionResult as NewDecisionResult, type index_d_OpenDecision as OpenDecision, type index_d_OpenTask as OpenTask, type index_d_RecallOptions as RecallOptions, type index_d_RecentWorklog as RecentWorklog, type index_d_ReindexResult as ReindexResult, type index_d_RitualRegistryOptions as RitualRegistryOptions, index_d_SESSION_END_COMMAND as SESSION_END_COMMAND, index_d_SESSION_START_COMMAND as SESSION_START_COMMAND, type index_d_SessionStartHookReport as SessionStartHookReport, type index_d_SessionStartReport as SessionStartReport, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, type index_d_VortexSyncResult as VortexSyncResult, type index_d_VortexSyncStep as VortexSyncStep, type index_d_VortexSyncStepId as VortexSyncStepId, type index_d_VortexSyncStepStatus as VortexSyncStepStatus, type index_d_WorklogAppendResult as WorklogAppendResult, index_d_agendaCommand as agendaCommand, index_d_catchUpSessions as catchUpSessions, index_d_collectAgenda as collectAgenda, index_d_collectSessionStartReport as collectSessionStartReport, index_d_createAmbientRecaller as createAmbientRecaller, index_d_createRitualRegistry as createRitualRegistry, index_d_curateCommand as curateCommand, index_d_decisionCommand as decisionCommand, index_d_detectWorklogGaps as detectWorklogGaps, index_d_ensureVortexHooks as ensureVortexHooks, index_d_ensureWorklogEntry as ensureWorklogEntry, index_d_extractNextUp as extractNextUp, index_d_extractOpenTasks as extractOpenTasks, index_d_logCommand as logCommand, index_d_parseSettings as parseSettings, index_d_recallCommand as recallCommand, index_d_reindexCommand as reindexCommand, index_d_renderAgenda as renderAgenda, index_d_renderSessionStartReport as renderSessionStartReport, index_d_serializeSettings as serializeSettings, index_d_sessionStartCommand as sessionStartCommand, index_d_vortexCommand as vortexCommand };
+}
+
+export { index_d$9 as aiCodingPitfalls, index_d$d as core, index_d$a as dataLint, index_d$5 as decisionLog, index_d$4 as indexGenerator, index_d$2 as linkRewriter, index_d$b as memorySystem, index_d$1 as proactiveCurator, index_d$7 as reportGenerator, index_d$3 as runbooks, index_d as sessionRituals, index_d$c as slashCommands, index_d$8 as toolRules, index_d$6 as worklog };