@vortex-os/base 0.1.0 → 0.2.3

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { vector, recall, sessionArchive } from '@vortex-os/memory-extended';
+
 /**
  * Three-tier privacy classification used across VortEX.
  *
@@ -82,20 +84,95 @@ declare function makeContext(repoRoot: string): ModuleContext;
  */
 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$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 };
+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 };
 }
 
 /**
@@ -180,17 +257,17 @@ declare function runSlash(input: string, { registry, context }: RunOptions): Pro
 
 //# 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 };
+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 };
 }
 
 /**
@@ -303,17 +380,17 @@ 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 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";
@@ -409,20 +486,20 @@ 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 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";
@@ -481,13 +558,13 @@ declare class PitfallCatalog {
 
 //# 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 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";
@@ -543,13 +620,13 @@ declare class ToolRuleCatalog {
 
 //# 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 };
+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 {
@@ -618,25 +695,25 @@ declare function applyTemplate(template: string, vars: Readonly<Record<string, s
 
 //# 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 };
+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 TIL file. All fields besides `type` are
+ * Frontmatter expected on a worklog file. All fields besides `type` are
  * conventional — the store tolerates absence and surfaces what is present.
  */
-interface TilFrontmatter {
-    type: "til";
+interface WorklogFrontmatter {
+    type: "worklog";
     status?: string;
     privacy?: string;
     created?: string;
@@ -646,41 +723,41 @@ interface TilFrontmatter {
     [key: string]: unknown;
 }
 /**
- * A parsed TIL entry.
+ * 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 TilEntry {
+interface WorklogEntry {
     readonly date: string;
     readonly keyword: string;
     readonly path: string;
-    readonly frontmatter: TilFrontmatter;
+    readonly frontmatter: WorklogFrontmatter;
     readonly body: string;
 }
 
 /**
- * Directory-backed TIL store. Expected layout: `<rootDir>/YYYY/MM/YYYY-MM-DD-keyword.md`.
+ * 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 TilStore {
+declare class WorklogStore {
     readonly rootDir: string;
     constructor(rootDir: string);
     /** All entries across all years and months, sorted by date ascending. */
-    list(): Promise<readonly TilEntry[]>;
+    list(): Promise<readonly WorklogEntry[]>;
     /** Entries within one calendar month. */
-    listByMonth(year: number, month: number): Promise<readonly TilEntry[]>;
+    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<TilEntry | undefined>;
+    get(date: string): Promise<WorklogEntry | undefined>;
     /** Most recent entry by date (descending), then keyword (descending). */
-    getLatest(): Promise<TilEntry | undefined>;
+    getLatest(): Promise<WorklogEntry | undefined>;
     /** Resolve the file path for a given (date, keyword), without creating it. */
     pathFor(date: string, keyword: string): string;
     private listSubdirs;
@@ -688,24 +765,24 @@ declare class TilStore {
 }
 
 /**
- * Append a new section to the end of an existing TIL entry's file.
+ * 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: TilEntry, title: string, body: string): Promise<string>;
+declare function appendSection(entry: WorklogEntry, 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 };
+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 };
 }
 
 /**
@@ -814,15 +891,15 @@ 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 };
+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 };
 }
 
 /**
@@ -837,7 +914,7 @@ interface IndexEntry {
     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`). */
+    /** 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;
@@ -869,7 +946,7 @@ interface ScanOptions {
  * Input for {@link renderIndex}.
  */
 interface RenderIndexInput {
-    /** Page H1 — typically the directory's human name (e.g. "Memory", "TIL"). */
+    /** 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
@@ -964,14 +1041,14 @@ declare function findIndexableDirs(rootDir: string, options?: {
 
 //# 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 };
+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 };
 }
 
 /**
@@ -984,7 +1061,7 @@ interface RunbookFrontmatter {
     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`). */
+    /** Free-form incident category (e.g. `network-outage`, `mail-outage`). */
     "incident-type"?: string;
     created?: string;
     updated?: string;
@@ -997,7 +1074,7 @@ interface RunbookFrontmatter {
  *
  * `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-장애복구`).
+ * descriptive (`service-restart-procedure`, `database-restore`).
  */
 interface RunbookEntry {
     readonly slug: string;
@@ -1048,13 +1125,13 @@ declare class RunbookStore {
 
 //# 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 };
+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 };
 }
 
 /**
@@ -1358,37 +1435,979 @@ declare function rewriteBody(body: string, redirections: RedirectionMap): {
 
 //# 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;
+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_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 };
+  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."
+ * 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(): CommandRegistry;
+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
@@ -1412,6 +2431,175 @@ interface SessionStartReport {
  */
 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";
@@ -1444,38 +2632,143 @@ interface NewDecisionResult {
  */
 declare const decisionCommand: Command<NewDecisionResult>;
 
-interface TilAppendResult {
+interface WorklogAppendResult {
     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.
+ * `/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 TIL" a one-liner, not to replace a real editor.
+ * note to today's worklog" a one-liner, not to replace a real editor.
  */
-declare const tilCommand: Command<TilAppendResult>;
+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 (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
+ *   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
- *
- * 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"];
+declare const PLANNED_SUBS: readonly [];
 type PlannedSub = (typeof PLANNED_SUBS)[number];
 interface VortexInitResult {
     readonly subcommand: "init";
@@ -1486,6 +2779,11 @@ interface VortexInitResult {
         name: string;
         prompt: string;
     }[];
+    readonly externalFolders?: readonly {
+        readonly path: string;
+        readonly basename: string;
+        readonly mdCount: number;
+    }[];
 }
 interface VortexPlannedResult {
     readonly subcommand: PlannedSub | "unknown";
@@ -1495,33 +2793,178 @@ interface VortexPlannedResult {
 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 | VortexPlannedResult | VortexHelpResult;
+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_TilAppendResult = TilAppendResult;
 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_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 { 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$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 };
+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 };