@vortex-os/base 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -1,24 +1,1527 @@
 /**
- * @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;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$c_FrontmatterDoc<T = Record<string, unknown>> = FrontmatterDoc<T>;
+type index_d$c_ModuleContext = ModuleContext;
+type index_d$c_Privacy = Privacy;
+declare const index_d$c_isVisibleAt: typeof isVisibleAt;
+declare const index_d$c_makeContext: typeof makeContext;
+declare const index_d$c_maxPrivacy: typeof maxPrivacy;
+declare const index_d$c_moduleDir: typeof moduleDir;
+declare const index_d$c_normalizePrivacy: typeof normalizePrivacy;
+declare const index_d$c_parseFrontmatter: typeof parseFrontmatter;
+declare const index_d$c_serializeFrontmatter: typeof serializeFrontmatter;
+declare namespace index_d$c {
+  export { type index_d$c_FrontmatterDoc as FrontmatterDoc, type index_d$c_ModuleContext as ModuleContext, type index_d$c_Privacy as Privacy, index_d$c_isVisibleAt as isVisibleAt, index_d$c_makeContext as makeContext, index_d$c_maxPrivacy as maxPrivacy, index_d$c_moduleDir as moduleDir, index_d$c_normalizePrivacy as normalizePrivacy, index_d$c_parseFrontmatter as parseFrontmatter, index_d$c_serializeFrontmatter as serializeFrontmatter };
+}
+
+/**
+ * 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$b_Command<Result = unknown> = Command<Result>;
+type index_d$b_CommandArg = CommandArg;
+type index_d$b_CommandInput = CommandInput;
+type index_d$b_CommandNotFoundError = CommandNotFoundError;
+declare const index_d$b_CommandNotFoundError: typeof CommandNotFoundError;
+type index_d$b_CommandRegistry = CommandRegistry;
+declare const index_d$b_CommandRegistry: typeof CommandRegistry;
+type index_d$b_RunOptions = RunOptions;
+declare const index_d$b_runSlash: typeof runSlash;
+declare namespace index_d$b {
+  export { type index_d$b_Command as Command, type index_d$b_CommandArg as CommandArg, type index_d$b_CommandInput as CommandInput, index_d$b_CommandNotFoundError as CommandNotFoundError, index_d$b_CommandRegistry as CommandRegistry, type index_d$b_RunOptions as RunOptions, index_d$b_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$a_Memory = Memory;
+type index_d$a_MemoryFrontmatter = MemoryFrontmatter;
+type index_d$a_MemoryStore = MemoryStore;
+declare const index_d$a_MemoryStore: typeof MemoryStore;
+type index_d$a_MemoryType = MemoryType;
+type index_d$a_SyncDiff = SyncDiff;
+type index_d$a_WriteMemoryIndexOptions = WriteMemoryIndexOptions;
+declare const index_d$a_diffStores: typeof diffStores;
+declare const index_d$a_writeMemoryIndex: typeof writeMemoryIndex;
+declare namespace index_d$a {
+  export { type index_d$a_Memory as Memory, type index_d$a_MemoryFrontmatter as MemoryFrontmatter, index_d$a_MemoryStore as MemoryStore, type index_d$a_MemoryType as MemoryType, type index_d$a_SyncDiff as SyncDiff, type index_d$a_WriteMemoryIndexOptions as WriteMemoryIndexOptions, index_d$a_diffStores as diffStores, index_d$a_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$9_LintFinding = LintFinding;
+type index_d$9_LintInput = LintInput;
+type index_d$9_LintOptions = LintOptions;
+type index_d$9_LintReport = LintReport;
+type index_d$9_LintRule = LintRule;
+type index_d$9_RequireFrontmatterOptions = RequireFrontmatterOptions;
+type index_d$9_Severity = Severity;
+type index_d$9_WikiLinkResolvesOptions = WikiLinkResolvesOptions;
+declare const index_d$9_lintDirectory: typeof lintDirectory;
+declare const index_d$9_privacyValid: typeof privacyValid;
+declare const index_d$9_requireFrontmatter: typeof requireFrontmatter;
+declare const index_d$9_wikiLinkResolves: typeof wikiLinkResolves;
+declare namespace index_d$9 {
+  export { type index_d$9_LintFinding as LintFinding, type index_d$9_LintInput as LintInput, type index_d$9_LintOptions as LintOptions, type index_d$9_LintReport as LintReport, type index_d$9_LintRule as LintRule, type index_d$9_RequireFrontmatterOptions as RequireFrontmatterOptions, type index_d$9_Severity as Severity, type index_d$9_WikiLinkResolvesOptions as WikiLinkResolvesOptions, index_d$9_lintDirectory as lintDirectory, index_d$9_privacyValid as privacyValid, index_d$9_requireFrontmatter as requireFrontmatter, index_d$9_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$8_Pitfall = Pitfall;
+type index_d$8_PitfallCatalog = PitfallCatalog;
+declare const index_d$8_PitfallCatalog: typeof PitfallCatalog;
+type index_d$8_PitfallFrontmatter = PitfallFrontmatter;
+type index_d$8_PitfallSeverity = PitfallSeverity;
+declare namespace index_d$8 {
+  export { type index_d$8_Pitfall as Pitfall, index_d$8_PitfallCatalog as PitfallCatalog, type index_d$8_PitfallFrontmatter as PitfallFrontmatter, type index_d$8_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$7_ToolRule = ToolRule;
+type index_d$7_ToolRuleCatalog = ToolRuleCatalog;
+declare const index_d$7_ToolRuleCatalog: typeof ToolRuleCatalog;
+type index_d$7_ToolRuleFrontmatter = ToolRuleFrontmatter;
+type index_d$7_ToolRuleSeverity = ToolRuleSeverity;
+declare namespace index_d$7 {
+  export { type index_d$7_ToolRule as ToolRule, index_d$7_ToolRuleCatalog as ToolRuleCatalog, type index_d$7_ToolRuleFrontmatter as ToolRuleFrontmatter, type index_d$7_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$6_DEFAULT_TEMPLATE: typeof DEFAULT_TEMPLATE;
+type index_d$6_RenderOptions = RenderOptions;
+type index_d$6_RenderResult = RenderResult;
+type index_d$6_RenderWarning = RenderWarning;
+type index_d$6_StripResult = StripResult;
+type index_d$6_WarningKind = WarningKind;
+declare const index_d$6_applyTemplate: typeof applyTemplate;
+declare const index_d$6_renderHtml: typeof renderHtml;
+declare const index_d$6_stripPrivateSections: typeof stripPrivateSections;
+declare namespace index_d$6 {
+  export { index_d$6_DEFAULT_TEMPLATE as DEFAULT_TEMPLATE, type index_d$6_RenderOptions as RenderOptions, type index_d$6_RenderResult as RenderResult, type index_d$6_RenderWarning as RenderWarning, type index_d$6_StripResult as StripResult, type index_d$6_WarningKind as WarningKind, index_d$6_applyTemplate as applyTemplate, index_d$6_renderHtml as renderHtml, index_d$6_stripPrivateSections as stripPrivateSections };
+}
+
+/**
+ * Frontmatter expected on a TIL file. All fields besides `type` are
+ * conventional — the store tolerates absence and surfaces what is present.
+ */
+interface TilFrontmatter {
+    type: "til";
+    status?: string;
+    privacy?: string;
+    created?: string;
+    updated?: string;
+    tags?: readonly string[];
+    related?: readonly string[];
+    [key: string]: unknown;
+}
+/**
+ * A parsed TIL 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 TilEntry {
+    readonly date: string;
+    readonly keyword: string;
+    readonly path: string;
+    readonly frontmatter: TilFrontmatter;
+    readonly body: string;
+}
+
+/**
+ * Directory-backed TIL 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 TilStore {
+    readonly rootDir: string;
+    constructor(rootDir: string);
+    /** All entries across all years and months, sorted by date ascending. */
+    list(): Promise<readonly TilEntry[]>;
+    /** Entries within one calendar month. */
+    listByMonth(year: number, month: number): Promise<readonly TilEntry[]>;
+    /**
+     * 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<TilEntry | undefined>;
+    /** Most recent entry by date (descending), then keyword (descending). */
+    getLatest(): Promise<TilEntry | 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 TIL 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: TilEntry, title: string, body: string): Promise<string>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d$5_TilEntry = TilEntry;
+type index_d$5_TilFrontmatter = TilFrontmatter;
+type index_d$5_TilStore = TilStore;
+declare const index_d$5_TilStore: typeof TilStore;
+declare const index_d$5_appendSection: typeof appendSection;
+declare namespace index_d$5 {
+  export { type index_d$5_TilEntry as TilEntry, type index_d$5_TilFrontmatter as TilFrontmatter, index_d$5_TilStore as TilStore, index_d$5_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$4_DecisionEntry = DecisionEntry;
+type index_d$4_DecisionFilter = DecisionFilter;
+type index_d$4_DecisionLogFrontmatter = DecisionLogFrontmatter;
+type index_d$4_DecisionStore = DecisionStore;
+declare const index_d$4_DecisionStore: typeof DecisionStore;
+type index_d$4_DecisionTemplateInput = DecisionTemplateInput;
+declare const index_d$4_renderTemplate: typeof renderTemplate;
+declare namespace index_d$4 {
+  export { type index_d$4_DecisionEntry as DecisionEntry, type index_d$4_DecisionFilter as DecisionFilter, type index_d$4_DecisionLogFrontmatter as DecisionLogFrontmatter, index_d$4_DecisionStore as DecisionStore, type index_d$4_DecisionTemplateInput as DecisionTemplateInput, index_d$4_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. `til`, `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", "TIL"). */
+    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$3_IndexEntry = IndexEntry;
+type index_d$3_RenderIndexInput = RenderIndexInput;
+type index_d$3_ScanOptions = ScanOptions;
+declare const index_d$3_findIndexableDirs: typeof findIndexableDirs;
+declare const index_d$3_renderIndex: typeof renderIndex;
+declare const index_d$3_scanDirectory: typeof scanDirectory;
+declare namespace index_d$3 {
+  export { type index_d$3_IndexEntry as IndexEntry, type index_d$3_RenderIndexInput as RenderIndexInput, type index_d$3_ScanOptions as ScanOptions, index_d$3_findIndexableDirs as findIndexableDirs, index_d$3_renderIndex as renderIndex, index_d$3_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. `네트워크-순단`, `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 (`K3s-노드-재부팅-절차`, `메일서버-Mbox-장애복구`).
+ */
+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$2_RunbookEntry = RunbookEntry;
+type index_d$2_RunbookFilter = RunbookFilter;
+type index_d$2_RunbookFrontmatter = RunbookFrontmatter;
+type index_d$2_RunbookStore = RunbookStore;
+declare const index_d$2_RunbookStore: typeof RunbookStore;
+declare namespace index_d$2 {
+  export { type index_d$2_RunbookEntry as RunbookEntry, type index_d$2_RunbookFilter as RunbookFilter, type index_d$2_RunbookFrontmatter as RunbookFrontmatter, index_d$2_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$1_BrokenLink = BrokenLink;
+type index_d$1_BuildIndexOptions = BuildIndexOptions;
+type index_d$1_CheckDirectoryOptions = CheckDirectoryOptions;
+type index_d$1_FileIndex = FileIndex;
+type index_d$1_FileRewrite = FileRewrite;
+type index_d$1_LinkCheckResult = LinkCheckResult;
+type index_d$1_RedirectionMap = RedirectionMap;
+type index_d$1_ResolveOpts = ResolveOpts;
+type index_d$1_ResolveOutcome = ResolveOutcome;
+type index_d$1_RewriteOptions = RewriteOptions;
+type index_d$1_RewriteResult = RewriteResult;
+type index_d$1_WikiLink = WikiLink;
+declare const index_d$1_buildFileIndex: typeof buildFileIndex;
+declare const index_d$1_checkDirectory: typeof checkDirectory;
+declare const index_d$1_extractWikiLinks: typeof extractWikiLinks;
+declare const index_d$1_resolveLink: typeof resolveLink;
+declare const index_d$1_rewriteBody: typeof rewriteBody;
+declare const index_d$1_rewriteDirectory: typeof rewriteDirectory;
+declare const index_d$1_toRel: typeof toRel;
+declare const index_d$1_topBrokenTargets: typeof topBrokenTargets;
+declare namespace index_d$1 {
+  export { type index_d$1_BrokenLink as BrokenLink, type index_d$1_BuildIndexOptions as BuildIndexOptions, type index_d$1_CheckDirectoryOptions as CheckDirectoryOptions, type index_d$1_FileIndex as FileIndex, type index_d$1_FileRewrite as FileRewrite, type index_d$1_LinkCheckResult as LinkCheckResult, type index_d$1_RedirectionMap as RedirectionMap, type index_d$1_ResolveOpts as ResolveOpts, type index_d$1_ResolveOutcome as ResolveOutcome, type index_d$1_RewriteOptions as RewriteOptions, type index_d$1_RewriteResult as RewriteResult, type index_d$1_WikiLink as WikiLink, index_d$1_buildFileIndex as buildFileIndex, index_d$1_checkDirectory as checkDirectory, index_d$1_extractWikiLinks as extractWikiLinks, index_d$1_resolveLink as resolveLink, index_d$1_rewriteBody as rewriteBody, index_d$1_rewriteDirectory as rewriteDirectory, index_d$1_toRel as toRel, index_d$1_topBrokenTargets as topBrokenTargets };
+}
+
+/**
+ * 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."
+ */
+declare function createRitualRegistry(): CommandRegistry;
+
+/**
+ * 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 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 TilAppendResult {
+    readonly path: string;
+    readonly date: string;
+    readonly keyword: string;
+    readonly sectionTitle: string;
+}
+/**
+ * `/til <section-title>` — Append a `## <section-title>` section to today's
+ * TIL entry. If no TIL 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 TIL" a one-liner, not to replace a real editor.
+ */
+declare const tilCommand: Command<TilAppendResult>;
+
+/**
+ * `/vortex <sub>` — Root command for VortEX instance operations.
+ *
+ * Subcommands:
+ *   init    — first-time setup wizard (creates user profile memory, first TIL, first topic hub)
+ *   status  — (planned) instance state report
+ *   import  — (planned) bring an existing folder into data/imported/
+ *   doctor  — (planned) diagnose common setup issues
+ *   help    — list available subcommands
+ *
+ * Phase 8 ships `init` and `help` as active; the rest are stubs that
+ * advertise their planned name so users can discover them.
+ */
+declare const PLANNED_SUBS: readonly ["status", "import", "doctor"];
+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;
+    }[];
+}
+interface VortexPlannedResult {
+    readonly subcommand: PlannedSub | "unknown";
+    readonly status: "not-implemented";
+    readonly message: string;
+}
+interface VortexHelpResult {
+    readonly subcommand: "help";
+    readonly status: "ok";
+    readonly subcommands: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly state: "active" | "planned";
+    }[];
+}
+type VortexResult = VortexInitResult | VortexPlannedResult | VortexHelpResult;
+declare const vortexCommand: Command<VortexResult>;
+
+//# sourceMappingURL=index.d.ts.map
+
+type index_d_NewDecisionResult = NewDecisionResult;
+type index_d_ReindexResult = ReindexResult;
+type index_d_SessionStartReport = SessionStartReport;
+type index_d_TilAppendResult = TilAppendResult;
+type index_d_VortexHelpResult = VortexHelpResult;
+type index_d_VortexInitResult = VortexInitResult;
+type index_d_VortexPlannedResult = VortexPlannedResult;
+type index_d_VortexResult = VortexResult;
+declare const index_d_createRitualRegistry: typeof createRitualRegistry;
+declare const index_d_decisionCommand: typeof decisionCommand;
+declare const index_d_reindexCommand: typeof reindexCommand;
+declare const index_d_sessionStartCommand: typeof sessionStartCommand;
+declare const index_d_tilCommand: typeof tilCommand;
+declare const index_d_vortexCommand: typeof vortexCommand;
+declare namespace index_d {
+  export { type index_d_NewDecisionResult as NewDecisionResult, type index_d_ReindexResult as ReindexResult, type index_d_SessionStartReport as SessionStartReport, type index_d_TilAppendResult as TilAppendResult, type index_d_VortexHelpResult as VortexHelpResult, type index_d_VortexInitResult as VortexInitResult, type index_d_VortexPlannedResult as VortexPlannedResult, type index_d_VortexResult as VortexResult, index_d_createRitualRegistry as createRitualRegistry, index_d_decisionCommand as decisionCommand, index_d_reindexCommand as reindexCommand, index_d_sessionStartCommand as sessionStartCommand, index_d_tilCommand as tilCommand, index_d_vortexCommand as vortexCommand };
+}
+
+export { index_d$8 as aiCodingPitfalls, index_d$c as core, index_d$9 as dataLint, index_d$4 as decisionLog, index_d$3 as indexGenerator, index_d$1 as linkRewriter, index_d$a as memorySystem, index_d$6 as reportGenerator, index_d$2 as runbooks, index_d as sessionRituals, index_d$b as slashCommands, index_d$5 as til, index_d$7 as toolRules };