@vortex-os/base 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,20 +1,22 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export,
+  catchUpSessions
+} from "./chunk-6SO4DAWJ.js";
 
 // ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   Privacy: () => Privacy,
   isVisibleAt: () => isVisibleAt,
+  loadVortexConfig: () => loadVortexConfig,
   makeContext: () => makeContext,
   maxPrivacy: () => maxPrivacy,
   moduleDir: () => moduleDir,
   normalizePrivacy: () => normalizePrivacy,
   parseFrontmatter: () => parseFrontmatter,
-  serializeFrontmatter: () => serializeFrontmatter
+  resolveEnvironment: () => resolveEnvironment,
+  serializeFrontmatter: () => serializeFrontmatter,
+  vortexConfigPath: () => vortexConfigPath
 });
 
 // ../core/dist/types.js
@@ -93,6 +95,54 @@ function moduleDir(ctx, moduleName) {
   return join(ctx.modulesDir, moduleName);
 }
 
+// ../core/dist/config.js
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_CONFIG = {
+  autoRecord: { sessionStart: true, worklog: true, decision: true, ambientRecall: true, archive: true },
+  environments: []
+};
+function vortexConfigPath(ctx) {
+  return join2(ctx.agentDir, "vortex.json");
+}
+function loadVortexConfig(ctx) {
+  const path = vortexConfigPath(ctx);
+  if (!existsSync(path))
+    return DEFAULT_CONFIG;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return {
+      autoRecord: { ...DEFAULT_CONFIG.autoRecord, ...raw.autoRecord ?? {} },
+      environments: Array.isArray(raw.environments) ? raw.environments : []
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function resolveEnvironment(config, signals) {
+  const host = signals.hostname?.toLowerCase();
+  const env = signals.env ?? {};
+  const pathExists = signals.pathExists ?? (() => false);
+  for (const rule of config.environments) {
+    if (rule.pathExists && pathExists(rule.pathExists))
+      return rule.label;
+    if (rule.hostname && host && rule.hostname.toLowerCase() === host)
+      return rule.label;
+    if (rule.envVar) {
+      if (typeof rule.envVar === "string") {
+        if (env[rule.envVar] !== void 0)
+          return rule.label;
+      } else {
+        const v2 = env[rule.envVar.name];
+        if (v2 !== void 0 && (rule.envVar.equals === void 0 || v2 === rule.envVar.equals)) {
+          return rule.label;
+        }
+      }
+    }
+  }
+  return null;
+}
+
 // ../modules/slash-commands/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -188,7 +238,7 @@ var MemoryType = {
 
 // ../modules/memory-system/dist/store.js
 import { readdir, readFile, writeFile, mkdir, unlink, stat } from "fs/promises";
-import { join as join2, basename, extname } from "path";
+import { join as join3, basename, extname } from "path";
 var MemoryStore = class {
   dir;
   constructor(dir) {
@@ -246,13 +296,13 @@ var MemoryStore = class {
   }
   /** Absolute path of a memory file (file may not exist). */
   pathFor(id) {
-    return join2(this.dir, `${id}.md`);
+    return join3(this.dir, `${id}.md`);
   }
 };
 
 // ../modules/memory-system/dist/memory-index.js
 import { writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 async function writeMemoryIndex(store, options = {}) {
   const ids = await store.list();
   const lines = [];
@@ -264,7 +314,7 @@ async function writeMemoryIndex(store, options = {}) {
     const memory = await store.read(id);
     lines.push(`- [${memory.frontmatter.name}](${id}.md) \u2014 ${memory.frontmatter.description}`);
   }
-  await writeFile2(join3(store.dir, "MEMORY.md"), `${lines.join("\n")}
+  await writeFile2(join4(store.dir, "MEMORY.md"), `${lines.join("\n")}
 `, "utf8");
 }
 
@@ -301,7 +351,7 @@ __export(dist_exports4, {
 
 // ../modules/data-lint/dist/runner.js
 import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 async function lintDirectory(options) {
   const start = Date.now();
   const extensions = options.extensions ?? [".md"];
@@ -338,7 +388,7 @@ async function collectFiles(dir, extensions) {
       throw e;
     }
     for (const entry of entries) {
-      const full = join4(current, entry.name);
+      const full = join5(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
       } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
@@ -399,7 +449,7 @@ function privacyValid() {
 
 // ../modules/data-lint/dist/rules/wiki-link-resolves.js
 import { readdir as readdir3 } from "fs/promises";
-import { basename as basename2, extname as extname2, join as join5 } from "path";
+import { basename as basename2, extname as extname2, join as join6 } from "path";
 var WIKI_LINK = /\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]/g;
 function wikiLinkResolves(options) {
   let cache;
@@ -420,7 +470,7 @@ function wikiLinkResolves(options) {
         continue;
       }
       for (const entry of entries) {
-        const full = join5(current, entry.name);
+        const full = join6(current, entry.name);
         if (entry.isDirectory()) {
           stack.push(full);
         } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
@@ -465,7 +515,7 @@ __export(dist_exports5, {
 
 // ../modules/ai-coding-pitfalls/dist/catalog.js
 import { readdir as readdir4, readFile as readFile4 } from "fs/promises";
-import { basename as basename3, extname as extname3, join as join6 } from "path";
+import { basename as basename3, extname as extname3, join as join7 } from "path";
 var PitfallCatalog = class {
   dir;
   constructor(dir) {
@@ -493,7 +543,7 @@ var PitfallCatalog = class {
   async entries() {
     try {
       const names = await readdir4(this.dir);
-      return names.filter((n) => n.endsWith(".md")).map((n) => join6(this.dir, n));
+      return names.filter((n) => n.endsWith(".md")).map((n) => join7(this.dir, n));
     } catch (e) {
       if (e.code === "ENOENT")
         return [];
@@ -525,7 +575,7 @@ __export(dist_exports6, {
 
 // ../modules/tool-rules/dist/catalog.js
 import { readdir as readdir5, readFile as readFile5 } from "fs/promises";
-import { basename as basename4, extname as extname4, join as join7 } from "path";
+import { basename as basename4, extname as extname4, join as join8 } from "path";
 var ToolRuleCatalog = class {
   dir;
   constructor(dir) {
@@ -558,7 +608,7 @@ var ToolRuleCatalog = class {
   async entries() {
     try {
       const names = await readdir5(this.dir);
-      return names.filter((n) => n.endsWith(".md")).map((n) => join7(this.dir, n));
+      return names.filter((n) => n.endsWith(".md")).map((n) => join8(this.dir, n));
     } catch (e) {
       if (e.code === "ENOENT")
         return [];
@@ -1813,20 +1863,20 @@ async function renderHtml(source, options) {
   };
 }
 
-// ../modules/til/dist/index.js
+// ../modules/worklog/dist/index.js
 var dist_exports8 = {};
 __export(dist_exports8, {
-  TilStore: () => TilStore,
+  WorklogStore: () => WorklogStore,
   appendSection: () => appendSection
 });
 
-// ../modules/til/dist/store.js
+// ../modules/worklog/dist/store.js
 import { readdir as readdir6, readFile as readFile6, stat as stat2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9, resolve as resolve2, sep } from "path";
 var FILENAME_PATTERN = /^(\d{4}-\d{2}-\d{2})-(.+)\.md$/;
 var MONTH_PATTERN = /^\d{2}$/;
 var YEAR_PATTERN = /^\d{4}$/;
-var TilStore = class {
+var WorklogStore = class {
   rootDir;
   constructor(rootDir) {
     this.rootDir = rootDir;
@@ -1836,17 +1886,17 @@ var TilStore = class {
     const years = await this.listSubdirs(this.rootDir, YEAR_PATTERN);
     const entries = [];
     for (const year of years) {
-      const yearDir = join8(this.rootDir, year);
+      const yearDir = join9(this.rootDir, year);
       const months = await this.listSubdirs(yearDir, MONTH_PATTERN);
       for (const month of months) {
-        entries.push(...await this.entriesIn(join8(yearDir, month)));
+        entries.push(...await this.entriesIn(join9(yearDir, month)));
       }
     }
     return entries.sort((a, b2) => a.date === b2.date ? a.keyword.localeCompare(b2.keyword) : a.date.localeCompare(b2.date));
   }
   /** Entries within one calendar month. */
   async listByMonth(year, month) {
-    const monthDir = join8(this.rootDir, String(year).padStart(4, "0"), String(month).padStart(2, "0"));
+    const monthDir = join9(this.rootDir, String(year).padStart(4, "0"), String(month).padStart(2, "0"));
     const entries = await this.entriesIn(monthDir);
     return entries.sort((a, b2) => a.date === b2.date ? a.keyword.localeCompare(b2.keyword) : a.date.localeCompare(b2.date));
   }
@@ -1859,7 +1909,7 @@ var TilStore = class {
     const [year, month] = date.split("-");
     if (!year || !month)
       return void 0;
-    const monthDir = join8(this.rootDir, year, month);
+    const monthDir = join9(this.rootDir, year, month);
     const entries = (await this.entriesIn(monthDir)).filter((e) => e.date === date).sort((a, b2) => a.keyword.localeCompare(b2.keyword));
     return entries[0];
   }
@@ -1872,11 +1922,14 @@ var TilStore = class {
   }
   /** Resolve the file path for a given (date, keyword), without creating it. */
   pathFor(date, keyword) {
-    const [year, month] = date.split("-");
-    if (!year || !month) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
       throw new Error(`Invalid date: ${date} (expected YYYY-MM-DD)`);
     }
-    return join8(this.rootDir, year, month, `${date}-${keyword}.md`);
+    const [year, month] = date.split("-");
+    validateSegment("keyword", keyword);
+    const abs = join9(this.rootDir, year, month, `${date}-${keyword}.md`);
+    assertContained(abs, this.rootDir);
+    return abs;
   }
   async listSubdirs(dir, pattern) {
     try {
@@ -1902,7 +1955,7 @@ var TilStore = class {
       const match = name.match(FILENAME_PATTERN);
       if (!match)
         continue;
-      const path = join8(monthDir, name);
+      const path = join9(monthDir, name);
       try {
         const info = await stat2(path);
         if (!info.isFile())
@@ -1919,8 +1972,28 @@ var TilStore = class {
     return out;
   }
 };
+function validateSegment(label, value) {
+  const v2 = (value ?? "").trim();
+  if (v2.length === 0)
+    throw new Error(`${label} is required`);
+  if (v2.includes("/") || v2.includes("\\"))
+    throw new Error(`${label} must not contain path separators: ${value}`);
+  if (/(^|[\\/])\.\.([\\/]|$)/.test(v2) || v2 === "..")
+    throw new Error(`${label} must not contain '..': ${value}`);
+  if (v2.startsWith("/") || v2.startsWith("\\") || /^[a-zA-Z]:/.test(v2))
+    throw new Error(`${label} must be a relative name, not an absolute path: ${value}`);
+  if (/[\u0000-\u001f\u007f]/.test(v2))
+    throw new Error(`${label} must not contain NUL or control characters: ${value}`);
+}
+function assertContained(abs, rootDir) {
+  const root = resolve2(rootDir);
+  const target = resolve2(abs);
+  if (target !== root && !(target + sep).startsWith(root + sep)) {
+    throw new Error(`Refusing to write outside the store directory: ${abs}`);
+  }
+}
 
-// ../modules/til/dist/append.js
+// ../modules/worklog/dist/append.js
 import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 async function appendSection(entry, title, body) {
   const original = await readFile7(entry.path, "utf8");
@@ -1945,7 +2018,7 @@ __export(dist_exports9, {
 
 // ../modules/decision-log/dist/store.js
 import { readdir as readdir7, readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10, resolve as resolve3, sep as sep2 } from "path";
 var FILENAME_PATTERN2 = /^(\d{4}-\d{2}-\d{2})-(.+)\.md$/;
 var DecisionStore = class {
   rootDir;
@@ -1967,7 +2040,7 @@ var DecisionStore = class {
       const match = name.match(FILENAME_PATTERN2);
       if (!match)
         continue;
-      const path = join9(this.rootDir, name);
+      const path = join10(this.rootDir, name);
       try {
         const info = await stat3(path);
         if (!info.isFile())
@@ -2038,9 +2111,32 @@ var DecisionStore = class {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
       throw new Error(`Invalid date: ${date} (expected YYYY-MM-DD)`);
     }
-    return join9(this.rootDir, `${date}-${slug}.md`);
+    validateSegment2("slug", slug);
+    const abs = join10(this.rootDir, `${date}-${slug}.md`);
+    assertContained2(abs, this.rootDir);
+    return abs;
   }
 };
+function validateSegment2(label, value) {
+  const v2 = (value ?? "").trim();
+  if (v2.length === 0)
+    throw new Error(`${label} is required`);
+  if (v2.includes("/") || v2.includes("\\"))
+    throw new Error(`${label} must not contain path separators: ${value}`);
+  if (/(^|[\\/])\.\.([\\/]|$)/.test(v2) || v2 === "..")
+    throw new Error(`${label} must not contain '..': ${value}`);
+  if (v2.startsWith("/") || v2.startsWith("\\") || /^[a-zA-Z]:/.test(v2))
+    throw new Error(`${label} must be a relative name, not an absolute path: ${value}`);
+  if (/[\u0000-\u001f\u007f]/.test(v2))
+    throw new Error(`${label} must not contain NUL or control characters: ${value}`);
+}
+function assertContained2(abs, rootDir) {
+  const root = resolve3(rootDir);
+  const target = resolve3(abs);
+  if (target !== root && !(target + sep2).startsWith(root + sep2)) {
+    throw new Error(`Refusing to write outside the store directory: ${abs}`);
+  }
+}
 
 // ../modules/decision-log/dist/template.js
 function renderTemplate(input) {
@@ -2102,7 +2198,7 @@ __export(dist_exports10, {
 
 // ../modules/index-generator/dist/scan.js
 import { readdir as readdir8, readFile as readFile9, stat as stat4 } from "fs/promises";
-import { basename as basename5, extname as extname5, join as join10, relative } from "path";
+import { basename as basename5, extname as extname5, join as join11, relative } from "path";
 var RESERVED_FILES = /* @__PURE__ */ new Set(["README.md", "_INDEX.md"]);
 var H1_PATTERN = /^#\s+(.+?)\s*$/m;
 async function scanDirectory(rootDir, opts = {}) {
@@ -2132,7 +2228,7 @@ async function walk(rootDir, currentDir, recursive, skipFilenames, skipPrefixes,
         continue;
       if (name.startsWith(".") || name.startsWith("_"))
         continue;
-      await walk(rootDir, join10(currentDir, name), recursive, skipFilenames, skipPrefixes, out);
+      await walk(rootDir, join11(currentDir, name), recursive, skipFilenames, skipPrefixes, out);
       continue;
     }
     if (!dirent.isFile())
@@ -2144,7 +2240,7 @@ async function walk(rootDir, currentDir, recursive, skipFilenames, skipPrefixes,
     const nameNoExt = basename5(name, ".md");
     if (skipPrefixes.some((p) => nameNoExt.startsWith(p)))
       continue;
-    const fullPath = join10(currentDir, name);
+    const fullPath = join11(currentDir, name);
     let info;
     try {
       info = await stat4(fullPath);
@@ -2254,7 +2350,7 @@ function today() {
 
 // ../modules/index-generator/dist/nested.js
 import { readdir as readdir9, stat as stat5 } from "fs/promises";
-import { extname as extname6, join as join11 } from "path";
+import { extname as extname6, join as join12 } from "path";
 async function findIndexableDirs(rootDir, options = {}) {
   const minEntries = options.minEntries ?? 1;
   const skipPrefixes = options.skipPrefixes ?? [];
@@ -2290,7 +2386,7 @@ async function walk2(dir, minEntries, skipPrefixes, out) {
     if (skipPrefixes.some((p) => nameNoExt.startsWith(p)))
       continue;
     try {
-      const info = await stat5(join11(dir, dirent.name));
+      const info = await stat5(join12(dir, dirent.name));
       if (!info.isFile())
         continue;
     } catch {
@@ -2302,7 +2398,7 @@ async function walk2(dir, minEntries, skipPrefixes, out) {
     out.push(dir);
   }
   for (const name of subdirs) {
-    await walk2(join11(dir, name), minEntries, skipPrefixes, out);
+    await walk2(join12(dir, name), minEntries, skipPrefixes, out);
   }
 }
 
@@ -2314,7 +2410,7 @@ __export(dist_exports11, {
 
 // ../modules/runbooks/dist/store.js
 import { readdir as readdir10, readFile as readFile10, stat as stat6 } from "fs/promises";
-import { extname as extname7, join as join12 } from "path";
+import { extname as extname7, join as join13 } from "path";
 var RESERVED_FILES2 = /* @__PURE__ */ new Set(["README.md", "_INDEX.md"]);
 var RunbookStore = class {
   rootDir;
@@ -2337,7 +2433,7 @@ var RunbookStore = class {
         continue;
       if (RESERVED_FILES2.has(name))
         continue;
-      const path = join12(this.rootDir, name);
+      const path = join13(this.rootDir, name);
       try {
         const info = await stat6(path);
         if (!info.isFile())
@@ -2446,7 +2542,7 @@ function extractWikiLinks(body) {
 
 // ../modules/link-rewriter/dist/resolve.js
 import { readdir as readdir11, stat as stat7 } from "fs/promises";
-import { basename as basename6, dirname, extname as extname8, isAbsolute, join as join13, relative as relative2, resolve as pathResolve } from "path";
+import { basename as basename6, dirname, extname as extname8, isAbsolute, join as join14, relative as relative2, resolve as pathResolve } from "path";
 async function buildFileIndex(rootDir, options = {}) {
   const byBasename = /* @__PURE__ */ new Map();
   const byRelPath = /* @__PURE__ */ new Map();
@@ -2477,7 +2573,7 @@ async function walk3(rootDir, dir, byBasename, byRelPath, additionalExts) {
     if (dirent.isDirectory()) {
       if (name.startsWith("."))
         continue;
-      await walk3(rootDir, join13(dir, name), byBasename, byRelPath, additionalExts);
+      await walk3(rootDir, join14(dir, name), byBasename, byRelPath, additionalExts);
       continue;
     }
     if (!dirent.isFile())
@@ -2486,7 +2582,7 @@ async function walk3(rootDir, dir, byBasename, byRelPath, additionalExts) {
     const isMd = ext === ".md";
     if (!isMd && !additionalExts.has(ext))
       continue;
-    const path = join13(dir, name);
+    const path = join14(dir, name);
     try {
       const info = await stat7(path);
       if (!info.isFile())
@@ -2657,611 +2753,3655 @@ function rewriteBody(body, redirections) {
   return { newBody: out, fileRewrites };
 }
 
-// ../plugins/session-rituals/dist/index.js
+// ../modules/proactive-curator/dist/index.js
 var dist_exports13 = {};
 __export(dist_exports13, {
-  createRitualRegistry: () => createRitualRegistry,
-  decisionCommand: () => decisionCommand,
-  reindexCommand: () => reindexCommand,
-  sessionStartCommand: () => sessionStartCommand,
-  tilCommand: () => tilCommand,
-  vortexCommand: () => vortexCommand
+  AmbientBackpressure: () => AmbientBackpressure,
+  AmbientRecaller: () => AmbientRecaller,
+  ClaudeCodeLLMJudge: () => ClaudeCodeLLMJudge,
+  ClaudeCodeLLMJudgeError: () => ClaudeCodeLLMJudgeError,
+  ClaudeDesktopLLMJudge: () => ClaudeDesktopLLMJudge,
+  ClaudeDesktopLLMJudgeError: () => ClaudeDesktopLLMJudgeError,
+  CodexLLMJudge: () => CodexLLMJudge,
+  CodexLLMJudgeError: () => CodexLLMJudgeError,
+  GeminiLLMJudge: () => GeminiLLMJudge,
+  GeminiLLMJudgeError: () => GeminiLLMJudgeError,
+  HubProposer: () => HubProposer,
+  InjectedLLMJudge: () => InjectedLLMJudge,
+  InsightProposer: () => InsightProposer,
+  LLMJudgeError: () => LLMJudgeError,
+  TurnBuffer: () => TurnBuffer,
+  computeFingerprint: () => computeFingerprint,
+  deriveQueryFromTurns: () => deriveQueryFromTurns,
+  frameForJudge: () => frameForJudge,
+  loadDeclinedFingerprints: () => loadDeclinedFingerprints,
+  parseJudgeResponse: () => parseJudgeResponse,
+  recordAcceptance: () => recordAcceptance,
+  recordDecline: () => recordDecline,
+  resetDeclined: () => resetDeclined
 });
 
-// ../plugins/session-rituals/dist/commands/decision.js
-import { writeFile as writeFile5 } from "fs/promises";
-import { join as join14 } from "path";
-import { existsSync } from "fs";
-var decisionCommand = {
-  name: "decision",
-  description: "Create a new Decision Log entry from the template.",
-  args: [
-    { name: "slug", description: "Kebab-style identifier used in the filename.", required: true },
-    { name: "title", description: "One-line decision title (rest of the input).", required: true }
-  ],
-  handler: async (input) => {
-    const slug = input.args.slug;
-    if (!slug) {
-      throw new Error("`/decision` requires a slug argument.");
+// ../modules/proactive-curator/dist/fingerprint.js
+import { createHash } from "crypto";
+function computeFingerprint(input) {
+  const normalized = normalizeForHash(input);
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function normalizeForHash(input) {
+  if (input.kind === "capture-insight") {
+    return JSON.stringify({
+      kind: "capture-insight",
+      turnIds: [...input.turnIds].sort(),
+      topic: normalizeTopic(input.topic),
+      actionKind: input.actionKind,
+      targetPath: normalizePath(input.targetPath)
+    });
+  }
+  return JSON.stringify({
+    kind: "create-hub",
+    topic: normalizeTopic(input.topic),
+    sourceDocs: [...input.sourceDocs].map(normalizePath).sort(),
+    actionKind: input.actionKind,
+    targetPath: normalizePath(input.targetPath)
+  });
+}
+function normalizeTopic(t) {
+  return t.trim().toLowerCase();
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// ../modules/proactive-curator/dist/decline-store.js
+import { existsSync as existsSync2 } from "fs";
+import { appendFile, mkdir as mkdir2, readFile as readFile13, writeFile as writeFile5 } from "fs/promises";
+import { join as join15 } from "path";
+var STORE_DIR = "data/_proactive-curator";
+var DECLINED_FILE = "declined.json";
+var ACCEPTED_LOG = "accepted.log";
+var DEFAULT_EXPIRY_DAYS = 30;
+async function loadDeclinedFingerprints(cwd, now) {
+  const parsed = await readDeclinedFile(cwd);
+  if (!parsed)
+    return /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const nowMs = now.getTime();
+  for (const kind of ["capture-insight", "create-hub"]) {
+    const entries = parsed[kind] ?? {};
+    for (const [fp, entry] of Object.entries(entries)) {
+      if (isActive(entry, nowMs))
+        active.add(fp);
     }
-    const title = extractTitle2(input.rest, slug);
-    if (!title) {
-      throw new Error("`/decision` requires a title after the slug.");
+  }
+  return active;
+}
+async function recordDecline(cwd, args) {
+  await ensureStoreDir(cwd);
+  const existing = await readDeclinedFile(cwd) ?? emptyDeclinedFile();
+  const expiryDays = args.expiryDays ?? DEFAULT_EXPIRY_DAYS;
+  const expiresAt = new Date(args.now.getTime() + expiryDays * 24 * 60 * 60 * 1e3).toISOString();
+  const updated = {
+    "capture-insight": purgeExpired(existing["capture-insight"], args.now),
+    "create-hub": purgeExpired(existing["create-hub"], args.now)
+  };
+  const entry = {
+    declinedAt: args.now.toISOString(),
+    topic: args.topic,
+    expiresAt,
+    actionKind: args.actionKind,
+    targetPath: args.targetPath,
+    ...args.sourceDocs ? { sourceDocs: args.sourceDocs } : {}
+  };
+  updated[args.kind] = { ...updated[args.kind], [args.fingerprint]: entry };
+  await writeFile5(join15(cwd, STORE_DIR, DECLINED_FILE), JSON.stringify(updated, null, 2) + "\n", "utf8");
+}
+async function recordAcceptance(cwd, args) {
+  await ensureStoreDir(cwd);
+  const line = JSON.stringify({
+    acceptedAt: args.now.toISOString(),
+    kind: args.kind,
+    fingerprint: args.fingerprint,
+    topic: args.topic,
+    actionKind: args.actionKind,
+    writtenPath: args.writtenPath
+  });
+  await appendFile(join15(cwd, STORE_DIR, ACCEPTED_LOG), line + "\n", "utf8");
+}
+async function resetDeclined(cwd, kind) {
+  const file = join15(cwd, STORE_DIR, DECLINED_FILE);
+  if (!existsSync2(file))
+    return;
+  if (kind === void 0) {
+    await writeFile5(file, JSON.stringify(emptyDeclinedFile(), null, 2) + "\n", "utf8");
+    return;
+  }
+  const parsed = await readDeclinedFile(cwd) ?? emptyDeclinedFile();
+  parsed[kind] = {};
+  await writeFile5(file, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+}
+function isActive(entry, nowMs) {
+  const expiresMs = new Date(entry.expiresAt).getTime();
+  return Number.isFinite(expiresMs) && expiresMs > nowMs;
+}
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function purgeExpired(entries, now) {
+  if (!entries)
+    return {};
+  const out = /* @__PURE__ */ Object.create(null);
+  const nowMs = now.getTime();
+  for (const [fp, entry] of Object.entries(entries)) {
+    if (DANGEROUS_KEYS.has(fp))
+      continue;
+    if (isActive(entry, nowMs))
+      out[fp] = entry;
+  }
+  return out;
+}
+async function readDeclinedFile(cwd) {
+  const file = join15(cwd, STORE_DIR, DECLINED_FILE);
+  if (!existsSync2(file))
+    return null;
+  try {
+    const raw = await readFile13(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      "capture-insight": parsed["capture-insight"] ?? {},
+      "create-hub": parsed["create-hub"] ?? {}
+    };
+  } catch {
+    return null;
+  }
+}
+function emptyDeclinedFile() {
+  return { "capture-insight": {}, "create-hub": {} };
+}
+async function ensureStoreDir(cwd) {
+  await mkdir2(join15(cwd, STORE_DIR), { recursive: true });
+}
+
+// ../modules/proactive-curator/dist/insight-proposer.js
+import { existsSync as existsSync3 } from "fs";
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile14, readdir as readdir12, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname2, join as join16 } from "path";
+var SYSTEM_META_DIRS = /* @__PURE__ */ new Set([
+  "worklog",
+  "decision-log",
+  "runbooks",
+  "hubs",
+  "_memory",
+  "_templates",
+  "_proactive-curator"
+]);
+var InsightProposer = class {
+  options;
+  kind = "capture-insight";
+  constructor(options) {
+    this.options = options;
+  }
+  async evaluate(input, ctx) {
+    if (input.accumulatedTokens < this.options.minTokensAccumulated)
+      return null;
+    if (input.recentTurns.length < this.options.minTurnsBeforeFirstCheck)
+      return null;
+    const capture = await askCaptureDecision(ctx.llm, input.recentTurns);
+    if (capture.verdict === "no" || !capture.summary || !capture.topic)
+      return null;
+    const tree = await scanTopicTree(ctx.cwd, this.options.maxTreeEntries ?? 100);
+    const placement = await askPlacementDecision(ctx.llm, capture.summary, capture.topic, tree);
+    if (!placement)
+      return null;
+    const action = buildAction(placement, capture.summary, capture.topic, ctx.now);
+    if (!action)
+      return null;
+    const targetPath = targetPathFromAction(action);
+    const fingerprint = computeFingerprint({
+      kind: "capture-insight",
+      turnIds: input.recentTurns.map((t) => t.turnId),
+      topic: capture.topic,
+      actionKind: action.kind,
+      targetPath
+    });
+    if (ctx.declinedFingerprints.has(fingerprint))
+      return null;
+    const sourceRefs = input.recentTurns.map((t) => t.turnId);
+    const declineExpiryDays = this.options.declineExpiryDays;
+    return {
+      kind: "capture-insight",
+      fingerprint,
+      action,
+      preview: capture.summary,
+      rationale: placement.rationale,
+      sourceRefs,
+      onAccept: async () => {
+        const writtenPath = await applyAction(ctx.cwd, action);
+        await recordAcceptance(ctx.cwd, {
+          kind: "capture-insight",
+          fingerprint,
+          topic: capture.topic,
+          actionKind: action.kind,
+          writtenPath,
+          now: ctx.now
+        });
+        return {
+          writtenPath,
+          actionApplied: action.kind,
+          nextActionHint: nextActionHintFor(action)
+        };
+      },
+      onDecline: async () => {
+        await recordDecline(ctx.cwd, {
+          kind: "capture-insight",
+          fingerprint,
+          topic: capture.topic,
+          actionKind: action.kind,
+          targetPath,
+          now: ctx.now,
+          ...declineExpiryDays !== void 0 ? { expiryDays: declineExpiryDays } : {}
+        });
+      }
+    };
+  }
+};
+async function askCaptureDecision(llm, turns) {
+  const prompt = renderCapturePrompt(turns);
+  const expected = {
+    shape: "json",
+    schema: {
+      verdict: "yes|no",
+      summary: "string (required when verdict=yes)",
+      topic: "string (required when verdict=yes, 1-3 words)"
     }
-    const date = todayIso();
-    const dir = join14(input.context.dataDir, "decision-log");
-    const store = new DecisionStore(dir);
-    const path = store.pathFor(date, slug);
-    if (existsSync(path)) {
-      throw new Error(`Refusing to overwrite existing entry: ${path}`);
+  };
+  const raw = await llm.ask(prompt, expected);
+  return normalizeCaptureDecision(raw);
+}
+function renderCapturePrompt(turns) {
+  const transcript = turns.map((t) => `[${t.role}] ${t.content}`).join("\n\n");
+  return [
+    "You are reviewing a conversation snippet to decide whether anything in it deserves to be captured as a standalone note.",
+    "",
+    "Capture only if the recent turns produced an insight, decision, or piece of structured thought that would be lost if the session ended right now. Routine status updates, command output, or trivial back-and-forth do not qualify.",
+    "",
+    "Return JSON:",
+    `  { "verdict": "yes" | "no", "summary": "3-5 sentences if verdict=yes", "topic": "1-3 words if verdict=yes" }`,
+    "",
+    "Recent turns:",
+    transcript
+  ].join("\n");
+}
+function normalizeCaptureDecision(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return { verdict: "no" };
+  const obj = raw;
+  if (obj.verdict !== "yes")
+    return { verdict: "no" };
+  const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
+  const topic = typeof obj.topic === "string" ? obj.topic.trim() : "";
+  if (!summary || !topic)
+    return { verdict: "no" };
+  return { verdict: "yes", summary, topic };
+}
+async function askPlacementDecision(llm, summary, topic, tree) {
+  const prompt = renderPlacementPrompt(summary, topic, tree);
+  const expected = {
+    shape: "json",
+    schema: {
+      actionKind: "create-folder|create-file|append-section|update-file",
+      rationale: "string (one line)",
+      folderPath: "string (create-folder, create-file)",
+      filename: "string (create-folder, create-file)",
+      filePath: "string (append-section, update-file)",
+      sectionHeader: "string (append-section)",
+      reason: "string (update-file)"
     }
-    const body = renderTemplate({ date, slug, title });
-    await writeFile5(path, body, "utf8");
-    return { path, date, slug };
+  };
+  const raw = await llm.ask(prompt, expected);
+  return normalizePlacementDecision(raw);
+}
+function renderPlacementPrompt(summary, topic, tree) {
+  const treeText = tree.folders.length === 0 ? "(no existing topic folders)" : tree.folders.map((f) => {
+    const fileLines = f.files.map((file) => `    - ${file.filename}${file.frontmatterTopic ? ` [topic: ${file.frontmatterTopic}]` : ""}`).join("\n");
+    return `  ${f.path}/
+${fileLines}`;
+  }).join("\n");
+  const truncationNote = tree.truncated ? "\n\n(Tree snapshot truncated \u2014 additional folders exist but are omitted for brevity.)" : "";
+  return [
+    "You are deciding where to place a captured insight in the user's existing topic tree.",
+    "",
+    `Insight topic: ${topic}`,
+    `Insight summary: ${summary}`,
+    "",
+    "Existing topic tree (data-relative paths, system-meta dirs excluded):",
+    treeText + truncationNote,
+    "",
+    "Pick one placement action. Preference order \u2014 extend existing structure before adding new:",
+    "  1. append-section  \u2014 an existing file is the right home; add a `## <sectionHeader>` section to it.",
+    "  2. create-file     \u2014 a topic folder exists; add a new sibling file alongside its current contents.",
+    "  3. create-folder   \u2014 the topic is genuinely new; create a folder and seed it with the first file.",
+    "  4. update-file     \u2014 an existing file needs in-place revision (rare; prefer append).",
+    "",
+    "Return JSON:",
+    `  { "actionKind": "append-section", "rationale": "one line why", "filePath": "<data-relative path>", "sectionHeader": "<section title without leading ##>" }`,
+    `  { "actionKind": "create-file",    "rationale": "one line why", "folderPath": "<data-relative folder>", "filename": "<slug>.md" }`,
+    `  { "actionKind": "create-folder",  "rationale": "one line why", "folderPath": "<data-relative folder>", "filename": "<slug>.md" }`,
+    `  { "actionKind": "update-file",    "rationale": "one line why", "filePath": "<data-relative path>", "reason": "what needs revising" }`,
+    "",
+    "Paths must be relative to data/. Do not propose paths inside system-meta directories (worklog/, decision-log/, runbooks/, hubs/, _memory/, _templates/, _proactive-curator/, or any other _* directory)."
+  ].join("\n");
+}
+function normalizePlacementDecision(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const obj = raw;
+  const actionKind = String(obj.actionKind ?? "");
+  const rationale = typeof obj.rationale === "string" ? obj.rationale.trim() : "";
+  if (!rationale)
+    return null;
+  switch (actionKind) {
+    case "create-folder":
+    case "create-file": {
+      const folderPath = typeof obj.folderPath === "string" ? obj.folderPath.trim() : "";
+      const filename = typeof obj.filename === "string" ? obj.filename.trim() : "";
+      if (!folderPath || !filename)
+        return null;
+      if (isSystemMetaPath(folderPath))
+        return null;
+      return { actionKind, rationale, folderPath, filename };
+    }
+    case "append-section": {
+      const filePath = typeof obj.filePath === "string" ? obj.filePath.trim() : "";
+      const sectionHeader = typeof obj.sectionHeader === "string" ? obj.sectionHeader.trim() : "";
+      if (!filePath || !sectionHeader)
+        return null;
+      if (isSystemMetaPath(filePath))
+        return null;
+      return { actionKind: "append-section", rationale, filePath, sectionHeader };
+    }
+    case "update-file": {
+      const filePath = typeof obj.filePath === "string" ? obj.filePath.trim() : "";
+      const reason = typeof obj.reason === "string" ? obj.reason.trim() : "";
+      if (!filePath || !reason)
+        return null;
+      if (isSystemMetaPath(filePath))
+        return null;
+      return { actionKind: "update-file", rationale, filePath, reason };
+    }
+    default:
+      return null;
   }
-};
-function extractTitle2(rest, slug) {
-  const trimmed = rest.trim();
-  if (trimmed.startsWith(slug)) {
-    return trimmed.slice(slug.length).trim();
+}
+function isSystemMetaPath(p) {
+  const normalized = p.replace(/\\/g, "/").replace(/^\/+/, "");
+  const first = normalized.split("/")[0] ?? "";
+  if (SYSTEM_META_DIRS.has(first))
+    return true;
+  if (first.startsWith("_"))
+    return true;
+  return false;
+}
+function buildAction(placement, summary, topic, now) {
+  const body = renderCaptureBody(summary, topic, now);
+  switch (placement.actionKind) {
+    case "create-folder":
+    case "create-file":
+      if (!placement.folderPath || !placement.filename)
+        return null;
+      return {
+        kind: placement.actionKind,
+        folderPath: placement.folderPath,
+        filename: placement.filename,
+        body
+      };
+    case "append-section":
+      if (!placement.filePath || !placement.sectionHeader)
+        return null;
+      return {
+        kind: "append-section",
+        filePath: placement.filePath,
+        sectionHeader: placement.sectionHeader,
+        body: renderSectionBody(summary, now)
+      };
+    case "update-file":
+      if (!placement.filePath || !placement.reason)
+        return null;
+      return {
+        kind: "update-file",
+        filePath: placement.filePath,
+        body: renderUpdateBody(summary, topic, placement.reason, now),
+        reason: placement.reason
+      };
   }
-  return trimmed;
 }
-function todayIso() {
-  const d2 = /* @__PURE__ */ new Date();
+function renderCaptureBody(summary, topic, now) {
+  const today2 = formatYmd(now);
+  return `---
+type: note
+topic: ${topic}
+created: ${today2}
+updated: ${today2}
+tags: [note, proactive-curator]
+---
+
+# ${topic}
+
+> Captured by proactive-curator on ${today2}. The user accepted this proposal; edit freely.
+
+${summary}
+`;
+}
+function renderSectionBody(summary, now) {
+  const ymd = formatYmd(now);
+  return `
+_Appended ${ymd} by proactive-curator._
+
+${summary}
+`;
+}
+function renderUpdateBody(summary, topic, reason, now) {
+  const ymd = formatYmd(now);
+  return `---
+type: note
+topic: ${topic}
+updated: ${ymd}
+---
+
+# ${topic}
+
+> Updated ${ymd} by proactive-curator. Reason: ${reason}
+
+${summary}
+`;
+}
+function formatYmd(d2) {
   const y2 = d2.getFullYear();
   const m2 = String(d2.getMonth() + 1).padStart(2, "0");
   const day = String(d2.getDate()).padStart(2, "0");
   return `${y2}-${m2}-${day}`;
 }
-
-// ../plugins/session-rituals/dist/commands/reindex.js
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile13, writeFile as writeFile6 } from "fs/promises";
-import { join as join15 } from "path";
-var TARGETS = [
-  {
-    dir: "_memory",
-    title: "Memory",
-    description: "\uC138\uC158 \uAC04 \uACF5\uC720\uB418\uB294 \uC601\uC18D \uBA54\uBAA8\uB9AC \uD56D\uBAA9\uB4E4. MEMORY.md\uB294 \uBCF8 \uB514\uB809\uD1A0\uB9AC\uC758 \uC6D0\uBCF8 \uC778\uB371\uC2A4\uC774\uBA70, \uBCF8 _INDEX.md\uB294 \uC0AC\uB78C\xB7Obsidian \uCE5C\uD654 \uC591\uC2DD\uC758 \uD30C\uC0DD\uBB3C\uC785\uB2C8\uB2E4.",
-    privacy: "internal",
-    recursive: false,
-    skipPrefixes: [],
-    skipFilenames: ["MEMORY.md"]
-  },
-  {
-    dir: "til",
-    title: "TIL",
-    description: "\uB0A0\uC9DC\uBCC4 \uC791\uC5C5 \uAE30\uB85D. `YYYY/MM/YYYY-MM-DD-keyword.md` \uAD6C\uC870.",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "decision-log",
-    title: "Decision Log",
-    description: "\uAC1C\uC778 \uC758\uC0AC\uACB0\uC815 \uAE30\uB85D \u2014 \uC65C \uADF8\uAC78 \uACE8\uB790\uB294\uC9C0\uB97C \uB0A8\uAE41\uB2C8\uB2E4.",
-    privacy: "personal",
-    recursive: false,
-    skipPrefixes: ["_TEMPLATE"],
-    skipFilenames: []
-  },
-  {
-    dir: "runbooks",
-    title: "Runbooks",
-    description: "\uC7A5\uC560 \uB300\uC751\xB7\uC815\uAE30 \uC815\uBE44 \uC808\uCC28. `last_tested`\uB85C \uAC31\uC2E0 \uAE30\uD55C \uCD94\uC801.",
-    privacy: "internal",
-    recursive: false,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "hubs",
-    title: "Hubs",
-    description: "\uC8FC\uC81C\uBCC4 \uC9C4\uC785\uC810 \u2014 \uAD00\uB828 \uC790\uB8CC\uB97C \uD55C \uACF3\uC5D0\uC11C \uBB36\uB294 \uC778\uB371\uC2A4 \uD398\uC774\uC9C0 \uBAA8\uC74C.",
-    privacy: "internal",
-    recursive: false,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "projects",
-    title: "Projects",
-    description: "\uC9C4\uD589 \uC911\xB7\uC644\uB8CC \uD504\uB85C\uC81D\uD2B8 \uBAA8\uC74C (Work\xB7Home). \uBCF8 _INDEX\uB294 \uD3C9\uD0C4 \uBAA9\uB85D\uC774\uBA70, \uD558\uC704 \uD504\uB85C\uC81D\uD2B8 \uD3F4\uB354\uBCC4 _INDEX\uAC00 \uB354 \uC720\uC6A9\uD560 \uC218 \uC788\uC74C (\uB2E4\uC74C \uC0AC\uC774\uD074 \uAC80\uD1A0).",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "reference",
-    title: "Reference",
-    description: "AI \uADDC\uCE59\xB7\uAE30\uC220 \uCE58\uD2B8\uC2DC\uD2B8\xB7\uC7A5\uBE44\xB7\uC2A4\uD0AC \uB4F1 \uB808\uD37C\uB7F0\uC2A4 \uC790\uB8CC (AI-Rules\xB7Games\xB7Gear\xB7Infra\xB7Org\xB7Skills\xB7Tech).",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "reports",
-    title: "Reports",
-    description: "\uC815\uAE30 \uAC74\uAC15\uAC80\uC9C4 \uB9AC\uD3EC\uD2B8 (Service-Health\xB7Homelab-Health). \uC2DC\uC810 \uC2A4\uB0C5\uC0F7 \uB204\uC801.",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "inbox",
-    title: "Inbox",
-    description: "\uBBF8\uBD84\uB958 \uC784\uC2DC \uBA54\uBAA8\xB7\uC544\uC774\uB514\uC5B4\xB7\uBC31\uB85C\uADF8. \uC815\uC2DD \uBD84\uB958 \uC2DC \uD574\uB2F9 \uCE74\uD14C\uACE0\uB9AC\uB85C \uC774\uB3D9.",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
-  },
-  {
-    dir: "_templates",
-    title: "Templates",
-    description: "\uBCF4\uACE0\uC6A9\xB7\uACF5\uC720\uC6A9 \uC790\uB8CC \uD15C\uD50C\uB9BF \uBAA8\uC74C (Sharing \uB4F1).",
-    privacy: "internal",
-    recursive: true,
-    skipPrefixes: [],
-    skipFilenames: []
+function targetPathFromAction(action) {
+  if (action.kind === "create-folder" || action.kind === "create-file") {
+    return joinDataPath(action.folderPath, action.filename);
   }
-];
-var reindexCommand = {
-  name: "reindex",
-  description: "Regenerate _INDEX.md for one or all data directories (memory, til, decision-log).",
-  args: [
-    {
-      name: "dir",
-      description: "Optional directory name. Omit to reindex all targets."
+  return joinDataPath(action.filePath);
+}
+function joinDataPath(...parts) {
+  return parts.filter((p) => p.length > 0).map((p) => p.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "")).join("/");
+}
+async function applyAction(cwd, action) {
+  const dataDir = join16(cwd, "data");
+  switch (action.kind) {
+    case "create-folder":
+    case "create-file": {
+      const folder = join16(dataDir, action.folderPath);
+      await mkdir3(folder, { recursive: true });
+      const file = join16(folder, action.filename);
+      await writeFile6(file, action.body, "utf8");
+      return file;
     }
-  ],
-  handler: async (input) => {
-    const requested = input.args.dir;
-    const targets = requested ? TARGETS.filter((t) => t.dir === requested) : TARGETS;
-    if (requested && targets.length === 0) {
-      throw new Error(`Unknown reindex target: "${requested}". Known: ${TARGETS.map((t) => t.dir).join(", ")}`);
+    case "append-section": {
+      const file = join16(dataDir, action.filePath);
+      await mkdir3(dirname2(file), { recursive: true });
+      const existing = existsSync3(file) ? await readFile14(file, "utf8") : "";
+      const newline = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+      const section = `${newline}
+## ${action.sectionHeader}
+${action.body}`;
+      await appendFile2(file, section, "utf8");
+      return file;
     }
-    const results = [];
-    for (const t of targets) {
-      const dir = join15(input.context.dataDir, t.dir);
-      if (!existsSync2(dir)) {
-        results.push({ dir: t.dir, status: "missing", entries: 0, bytes: 0 });
-        continue;
+    case "update-file": {
+      const file = join16(dataDir, action.filePath);
+      await mkdir3(dirname2(file), { recursive: true });
+      await writeFile6(file, action.body, "utf8");
+      return file;
+    }
+  }
+}
+function nextActionHintFor(action) {
+  if (action.kind === "append-section") {
+    return `Section appended to ${action.filePath}. Open it to see the full thread of this topic.`;
+  }
+  if (action.kind === "update-file") {
+    return `File updated at ${action.filePath}. The original content was replaced; check git history if you need to recover it.`;
+  }
+  return `New file at ${action.folderPath}/${action.filename}. Add cross-links from related docs as the topic grows.`;
+}
+async function scanTopicTree(cwd, maxEntries) {
+  const dataDir = join16(cwd, "data");
+  if (!existsSync3(dataDir)) {
+    return { folders: [], truncated: false };
+  }
+  const folders = [];
+  let counted = 0;
+  let truncated = false;
+  async function visit(absDir, relDir) {
+    if (counted >= maxEntries) {
+      truncated = true;
+      return;
+    }
+    let entries;
+    try {
+      entries = await readdir12(absDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const files = [];
+    const subdirs = [];
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (isReservedDir(e.name, relDir === ""))
+          continue;
+        subdirs.push(e.name);
+      } else if (e.isFile() && e.name.endsWith(".md")) {
+        if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md")
+          continue;
+        const filePath = join16(absDir, e.name);
+        let frontmatterTopic;
+        let tags;
+        try {
+          const raw = await readFile14(filePath, "utf8");
+          const parsed = parseFrontmatter(raw);
+          if (typeof parsed.frontmatter.topic === "string") {
+            frontmatterTopic = parsed.frontmatter.topic;
+          }
+          if (Array.isArray(parsed.frontmatter.tags)) {
+            tags = parsed.frontmatter.tags.filter((t) => typeof t === "string");
+          }
+        } catch {
+        }
+        files.push({
+          path: joinDataPath(relDir, e.name),
+          filename: e.name,
+          ...frontmatterTopic ? { frontmatterTopic } : {},
+          ...tags ? { tags } : {}
+        });
       }
-      const entries = await scanDirectory(dir, {
-        recursive: t.recursive,
-        skipPrefixes: t.skipPrefixes,
-        skipFilenames: t.skipFilenames
-      });
-      const body = renderIndex({
-        title: t.title,
-        description: t.description,
-        entries,
-        privacy: t.privacy
-      });
-      const target = join15(dir, "_INDEX.md");
-      let existing;
-      try {
-        existing = await readFile13(target, "utf8");
-      } catch {
-        existing = void 0;
+    }
+    if (files.length > 0 || subdirs.length === 0) {
+      if (relDir !== "") {
+        folders.push({ path: relDir, files });
+        counted += 1 + files.length;
+      } else if (files.length > 0) {
+        folders.push({ path: ".", files });
+        counted += 1 + files.length;
       }
-      if (existing === body) {
-        results.push({
-          dir: t.dir,
-          status: "unchanged",
-          entries: entries.length,
-          bytes: body.length
+    }
+    for (const d2 of subdirs) {
+      if (counted >= maxEntries) {
+        truncated = true;
+        return;
+      }
+      const childRel = joinDataPath(relDir, d2);
+      await visit(join16(absDir, d2), childRel);
+    }
+  }
+  await visit(dataDir, "");
+  return { folders, truncated };
+}
+function isReservedDir(name, atRoot) {
+  if (atRoot && SYSTEM_META_DIRS.has(name))
+    return true;
+  if (name.startsWith("."))
+    return true;
+  if (atRoot && name.startsWith("_"))
+    return true;
+  return false;
+}
+
+// ../modules/proactive-curator/dist/hub-proposer.js
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir4, readFile as readFile15, readdir as readdir13, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname3, join as join17 } from "path";
+var DEFAULT_CATEGORIES = [
+  "worklog",
+  "decision-log",
+  "runbooks"
+];
+var HUB_DIR = "hubs";
+var MIN_KEYWORD_LENGTH = 3;
+var MAX_LLM_DOC_LIST = 30;
+var HubProposer = class {
+  options;
+  kind = "create-hub";
+  constructor(options) {
+    this.options = options;
+  }
+  async evaluate(input, ctx) {
+    const categories = input.hint?.onlyCategories ?? this.options.scanCategories ?? DEFAULT_CATEGORIES;
+    const docs = await scanDocs(ctx.cwd, categories);
+    if (docs.length === 0)
+      return null;
+    const clusters = groupByTopic(docs);
+    const candidate = pickCluster(clusters, this.options.weakSignalAt, ctx.cwd);
+    if (!candidate)
+      return null;
+    const verdict = await askCoherence(ctx.llm, candidate, candidate.docs.length >= this.options.strongSignalAt);
+    if (!verdict)
+      return null;
+    const slug = candidate.topic;
+    const filename = `_HUB-${slug}.md`;
+    const action = {
+      kind: "create-file",
+      folderPath: HUB_DIR,
+      filename,
+      body: renderHubBody(candidate, verdict.contextParagraph, ctx.now)
+    };
+    const targetPath = `${HUB_DIR}/${filename}`;
+    const sourceDocs = candidate.docs.map((d2) => d2.path);
+    const fingerprint = computeFingerprint({
+      kind: "create-hub",
+      topic: candidate.topic,
+      sourceDocs,
+      actionKind: action.kind,
+      targetPath
+    });
+    if (ctx.declinedFingerprints.has(fingerprint))
+      return null;
+    const rationale = candidate.docs.length >= this.options.strongSignalAt ? `${candidate.docs.length} docs about "${candidate.topic}" \u2014 strong-signal cluster (above ${this.options.strongSignalAt}); LLM concurred.` : `${candidate.docs.length} docs about "${candidate.topic}" \u2014 weak-signal cluster (\u2265 ${this.options.weakSignalAt}); LLM affirmed cohesion.`;
+    const declineExpiryDays = this.options.declineExpiryDays;
+    return {
+      kind: "create-hub",
+      fingerprint,
+      action,
+      preview: renderPreview(candidate, verdict.contextParagraph),
+      rationale,
+      sourceRefs: sourceDocs,
+      onAccept: async () => {
+        const writtenPath = await applyHubCreate(ctx.cwd, action);
+        await recordAcceptance(ctx.cwd, {
+          kind: "create-hub",
+          fingerprint,
+          topic: candidate.topic,
+          actionKind: action.kind,
+          writtenPath,
+          now: ctx.now
+        });
+        return {
+          writtenPath,
+          actionApplied: action.kind,
+          nextActionHint: `Hub created at hubs/${filename}. Open it to review the cross-links; the source docs were not modified.`
+        };
+      },
+      onDecline: async () => {
+        await recordDecline(ctx.cwd, {
+          kind: "create-hub",
+          fingerprint,
+          topic: candidate.topic,
+          actionKind: action.kind,
+          targetPath,
+          sourceDocs,
+          now: ctx.now,
+          ...declineExpiryDays !== void 0 ? { expiryDays: declineExpiryDays } : {}
         });
+      }
+    };
+  }
+};
+async function scanDocs(cwd, categories) {
+  const dataDir = join17(cwd, "data");
+  if (!existsSync4(dataDir))
+    return [];
+  const out = [];
+  for (const category of categories) {
+    const abs = join17(dataDir, category);
+    if (!existsSync4(abs))
+      continue;
+    await walk4(abs, category, out);
+  }
+  return out;
+}
+async function walk4(absDir, relPath, acc) {
+  let entries;
+  try {
+    entries = await readdir13(absDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (e.name.startsWith(".") || e.name.startsWith("_"))
         continue;
+      await walk4(join17(absDir, e.name), `${relPath}/${e.name}`, acc);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md")
+        continue;
+      if (e.name.startsWith("_TEMPLATE"))
+        continue;
+      const filePath = join17(absDir, e.name);
+      let frontmatterTopic;
+      let tags = [];
+      try {
+        const raw = await readFile15(filePath, "utf8");
+        const parsed = parseFrontmatter(raw);
+        if (typeof parsed.frontmatter.topic === "string") {
+          frontmatterTopic = parsed.frontmatter.topic.trim();
+        }
+        if (Array.isArray(parsed.frontmatter.tags)) {
+          tags = parsed.frontmatter.tags.filter((t) => typeof t === "string");
+        }
+      } catch {
       }
-      await writeFile6(target, body, "utf8");
-      results.push({
-        dir: t.dir,
-        status: "written",
-        entries: entries.length,
-        bytes: body.length
+      acc.push({
+        path: `${relPath}/${e.name}`,
+        filename: e.name,
+        ...frontmatterTopic ? { frontmatterTopic } : {},
+        tags,
+        filenameKeywords: extractFilenameKeywords(e.name)
       });
     }
-    return results;
+  }
+}
+function extractFilenameKeywords(filename) {
+  const stem = filename.replace(/\.md$/i, "");
+  const withoutDate = stem.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+  return withoutDate.split(/[-_\s]+/).map((s) => s.toLowerCase()).filter((s) => s.length >= MIN_KEYWORD_LENGTH);
+}
+function groupByTopic(docs) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    const topics = candidateTopicsFor(doc);
+    for (const topic of topics) {
+      const list = buckets.get(topic);
+      if (list) {
+        if (!list.some((d2) => d2.path === doc.path))
+          list.push(doc);
+      } else {
+        buckets.set(topic, [doc]);
+      }
+    }
+  }
+  const clusters = [];
+  for (const [topic, list] of buckets) {
+    clusters.push({ topic, docs: list });
+  }
+  clusters.sort((a, b2) => b2.docs.length - a.docs.length);
+  return clusters;
+}
+function candidateTopicsFor(doc) {
+  const topics = /* @__PURE__ */ new Set();
+  if (doc.frontmatterTopic)
+    topics.add(slugify(doc.frontmatterTopic));
+  for (const tag of doc.tags) {
+    const slug = slugify(tag);
+    if (slug.length >= MIN_KEYWORD_LENGTH)
+      topics.add(slug);
+  }
+  for (const kw of doc.filenameKeywords) {
+    topics.add(kw);
+  }
+  return [...topics];
+}
+function slugify(s) {
+  return s.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function pickCluster(clusters, weakThreshold, cwd) {
+  for (const c of clusters) {
+    if (c.docs.length < weakThreshold)
+      return null;
+    const hubPath = join17(cwd, "data", HUB_DIR, `_HUB-${c.topic}.md`);
+    if (existsSync4(hubPath))
+      continue;
+    return c;
+  }
+  return null;
+}
+async function askCoherence(llm, cluster, isStrongSignal) {
+  const prompt = renderCoherencePrompt(cluster, isStrongSignal);
+  const expected = {
+    shape: "json",
+    schema: {
+      verdict: "yes|no",
+      contextParagraph: "string (1-2 sentences, used in the hub body when verdict=yes)"
+    }
+  };
+  const raw = await llm.ask(prompt, expected);
+  return interpretCoherence(raw, isStrongSignal);
+}
+function renderCoherencePrompt(cluster, isStrongSignal) {
+  const docList = cluster.docs.slice(0, MAX_LLM_DOC_LIST).map((d2) => `  - ${d2.path}`).join("\n");
+  const truncationNote = cluster.docs.length > MAX_LLM_DOC_LIST ? `
+  (... ${cluster.docs.length - MAX_LLM_DOC_LIST} more docs omitted for brevity)` : "";
+  if (isStrongSignal) {
+    return [
+      `${cluster.docs.length} documents share the candidate topic "${cluster.topic}" \u2014 a strong-signal cluster.`,
+      "",
+      "Documents:",
+      docList + truncationNote,
+      "",
+      "Default action is to propose creating a `_HUB-` page that cross-links them. Reject *only* if the docs are clearly incoherent \u2014 sharing a keyword but not a real subject. If the cluster has any reasonable cohesion, return verdict=yes.",
+      "",
+      `Return JSON: { "verdict": "yes" | "no", "contextParagraph": "1-2 sentences describing the topic for the hub body (required if verdict=yes)" }`
+    ].join("\n");
+  }
+  return [
+    `${cluster.docs.length} documents share the candidate topic "${cluster.topic}" \u2014 a weak-signal cluster.`,
+    "",
+    "Documents:",
+    docList + truncationNote,
+    "",
+    "Affirm verdict=yes only if the topic is clearly cross-cutting and the cluster has real cohesion (not a coincidence of keywords or tags). When uncertain, return verdict=no.",
+    "",
+    `Return JSON: { "verdict": "yes" | "no", "contextParagraph": "1-2 sentences describing the topic for the hub body (required if verdict=yes)" }`
+  ].join("\n");
+}
+function interpretCoherence(raw, isStrongSignal) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const obj = raw;
+  const verdict = obj.verdict === "yes" ? "yes" : obj.verdict === "no" ? "no" : null;
+  if (verdict === null)
+    return null;
+  if (isStrongSignal) {
+    if (verdict === "no")
+      return null;
+    const contextParagraph2 = typeof obj.contextParagraph === "string" ? obj.contextParagraph.trim() || void 0 : void 0;
+    return contextParagraph2 ? { verdict: "yes", contextParagraph: contextParagraph2 } : { verdict: "yes" };
+  }
+  if (verdict !== "yes")
+    return null;
+  const contextParagraph = typeof obj.contextParagraph === "string" ? obj.contextParagraph.trim() : "";
+  if (!contextParagraph)
+    return null;
+  return { verdict: "yes", contextParagraph };
+}
+function renderPreview(cluster, contextParagraph) {
+  const lines = [
+    `Proposed hub: hubs/_HUB-${cluster.topic}.md`,
+    `Cluster size: ${cluster.docs.length} documents`
+  ];
+  if (contextParagraph) {
+    lines.push("", contextParagraph);
+  }
+  lines.push("", "Cross-linked docs:");
+  for (const d2 of cluster.docs.slice(0, MAX_LLM_DOC_LIST)) {
+    lines.push(`  - ${d2.path}`);
+  }
+  if (cluster.docs.length > MAX_LLM_DOC_LIST) {
+    lines.push(`  ... ${cluster.docs.length - MAX_LLM_DOC_LIST} more`);
+  }
+  return lines.join("\n");
+}
+function renderHubBody(cluster, contextParagraph, now) {
+  const ymd = formatYmd2(now);
+  const links = cluster.docs.map((d2) => `- [[${stripMdExtension(d2.path)}]]`).join("\n");
+  const context = contextParagraph ? `${contextParagraph}
+
+` : "";
+  return `---
+type: hub
+topic: ${cluster.topic}
+created: ${ymd}
+updated: ${ymd}
+tags: [hub, proactive-curator]
+---
+
+# ${cluster.topic}
+
+> Hub proposed by proactive-curator on ${ymd}. The user accepted this proposal; edit freely. The cross-linked source docs were not modified.
+
+${context}## Cross-linked docs
+
+${links}
+`;
+}
+function stripMdExtension(p) {
+  return p.replace(/\.md$/i, "");
+}
+function formatYmd2(d2) {
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
+async function applyHubCreate(cwd, action) {
+  const folder = join17(cwd, "data", action.folderPath);
+  await mkdir4(folder, { recursive: true });
+  const file = join17(folder, action.filename);
+  await mkdir4(dirname3(file), { recursive: true });
+  await writeFile7(file, action.body, "utf8");
+  return file;
+}
+
+// ../modules/proactive-curator/dist/ambient-tracker.js
+var TurnBuffer = class {
+  turns = [];
+  maxTurns;
+  estimator;
+  constructor(options) {
+    this.maxTurns = options?.maxTurns ?? 50;
+    this.estimator = options?.estimator ?? defaultTokenEstimator;
+  }
+  /** Append a turn, evicting the oldest entry if the buffer is full. */
+  add(turn) {
+    this.turns.push(turn);
+    while (this.turns.length > this.maxTurns) {
+      this.turns.shift();
+    }
+  }
+  /** Return the most recent `n` turns (or fewer if the buffer has fewer). */
+  recent(n) {
+    if (n >= this.turns.length)
+      return [...this.turns];
+    return this.turns.slice(-n);
+  }
+  /** Number of turns currently buffered. */
+  get length() {
+    return this.turns.length;
+  }
+  /** Estimated total token count over the entire buffer. */
+  tokenCount() {
+    let total = 0;
+    for (const t of this.turns)
+      total += this.estimator(t);
+    return total;
+  }
+  /** Reset the buffer — typically called at session-end. */
+  clear() {
+    this.turns.length = 0;
+  }
+};
+var AmbientBackpressure = class {
+  declineStreak = 0;
+  maxStreak;
+  constructor(options) {
+    this.maxStreak = options?.maxStreak ?? 3;
+  }
+  /** Record a user decline. Counts toward backpressure. */
+  recordDecline() {
+    this.declineStreak++;
+  }
+  /** Record a user acceptance. Clears the streak. */
+  recordAccept() {
+    this.declineStreak = 0;
+  }
+  /** Explicit reset (e.g. user runs `/curate` after backpressure activated). */
+  reset() {
+    this.declineStreak = 0;
+  }
+  /** True when the streak has reached the maximum and ambient should pause. */
+  isActive() {
+    return this.declineStreak >= this.maxStreak;
+  }
+  /** Current decline streak — exposed for diagnostics. */
+  get streak() {
+    return this.declineStreak;
   }
 };
+function defaultTokenEstimator(turn) {
+  return Math.ceil(turn.content.length / 4);
+}
 
-// ../plugins/session-rituals/dist/commands/session-start.js
-import { existsSync as existsSync3 } from "fs";
-import { readdir as readdir12 } from "fs/promises";
-import { join as join16 } from "path";
-var COUNTED_DIRS = ["_memory", "til", "decision-log"];
-var sessionStartCommand = {
-  name: "session-start",
-  description: "Emit a start-of-session report (time + data directory counts).",
-  handler: async (input) => {
-    const { dataDir, repoRoot } = input.context;
-    const counts = {};
-    const missing = [];
-    for (const name of COUNTED_DIRS) {
-      const dir = join16(dataDir, name);
-      if (!existsSync3(dir)) {
-        missing.push(name);
-        counts[name] = 0;
+// ../modules/proactive-curator/dist/ambient-recaller.js
+var DEFAULT_MIN_SCORE = 0.5;
+var DEFAULT_MAX_SUGGESTIONS = 1;
+var DEFAULT_MIN_QUERY_CHARS = 12;
+var AmbientRecaller = class {
+  recall;
+  minScore;
+  maxSuggestions;
+  minQueryChars;
+  candidateK;
+  backpressure;
+  surfaced = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.recall = options.recall;
+    this.minScore = options.minScore ?? DEFAULT_MIN_SCORE;
+    this.maxSuggestions = options.maxSuggestions ?? DEFAULT_MAX_SUGGESTIONS;
+    this.minQueryChars = options.minQueryChars ?? DEFAULT_MIN_QUERY_CHARS;
+    this.candidateK = options.candidateK ?? this.maxSuggestions + 4;
+    this.backpressure = options.backpressure ?? new AmbientBackpressure();
+  }
+  /**
+   * 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.
+   */
+  async consider(input) {
+    if (this.backpressure.isActive()) {
+      return emptyResult(true, null);
+    }
+    const query = (input.query ?? deriveQueryFromTurns(input.turns ?? [])).trim();
+    if (query.length < this.minQueryChars) {
+      return emptyResult(false, query.length === 0 ? null : query);
+    }
+    const { hits } = await this.recall(query, { k: this.candidateK });
+    let belowThreshold = 0;
+    let deduped = 0;
+    const suggestions = [];
+    for (const hit of hits) {
+      if (hit.score < this.minScore) {
+        belowThreshold++;
         continue;
       }
-      counts[name] = await countMarkdown(dir, name === "til");
+      if (this.surfaced.has(hit.id)) {
+        deduped++;
+        continue;
+      }
+      suggestions.push({ hit, score: hit.score });
+      if (suggestions.length >= this.maxSuggestions)
+        break;
+    }
+    for (const s of suggestions)
+      this.surfaced.add(s.hit.id);
+    return {
+      suggestions,
+      suppressed: false,
+      query,
+      considered: hits.length,
+      belowThreshold,
+      deduped
+    };
+  }
+  /** The user engaged with a surfaced suggestion — clears the decline streak. */
+  recordAccept() {
+    this.backpressure.recordAccept();
+  }
+  /** The user dismissed a surfaced suggestion — counts toward backpressure. */
+  recordDecline() {
+    this.backpressure.recordDecline();
+  }
+  /** True when backpressure has silenced ambient surfacing for the session. */
+  get suppressed() {
+    return this.backpressure.isActive();
+  }
+  /**
+   * 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() {
+    this.backpressure.reset();
+    this.surfaced.clear();
+  }
+};
+function deriveQueryFromTurns(turns) {
+  for (let i = turns.length - 1; i >= 0; i--) {
+    if (turns[i].role === "user")
+      return turns[i].content;
+  }
+  return turns.length > 0 ? turns[turns.length - 1].content : "";
+}
+function emptyResult(suppressed, query) {
+  return { suggestions: [], suppressed, query, considered: 0, belowThreshold: 0, deduped: 0 };
+}
+
+// ../modules/proactive-curator/dist/adapters/shared.js
+var LLMJudgeError = class extends Error {
+  raw;
+  constructor(message, raw) {
+    super(message);
+    this.raw = raw;
+    this.name = "LLMJudgeError";
+  }
+};
+function frameForJudge(prompt, expected) {
+  const tail = expected.shape === "json" ? '\n\nReturn ONLY the JSON object described above. No prose, no markdown code fences, no explanation around it. If you cannot answer, return the JSON with verdict="no" (for capture decisions) or actionKind="create-file" with a brief rationale (for placement decisions).' : "\n\nReturn ONLY the answer string. No prose preamble, no markdown formatting around it.";
+  return prompt + tail;
+}
+function parseJudgeResponse(raw, expected, makeError) {
+  if (typeof raw !== "string") {
+    throw makeError("Host LLM returned a non-string response.");
+  }
+  const stripped = raw.trim();
+  if (expected.shape === "string") {
+    return stripped;
+  }
+  const jsonPayload = extractJsonPayload(stripped);
+  try {
+    return JSON.parse(jsonPayload);
+  } catch (e) {
+    throw makeError(`Host LLM response was not valid JSON: ${e.message}`, raw);
+  }
+}
+function extractJsonPayload(s) {
+  const fenced = s.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  if (fenced)
+    return fenced[1].trim();
+  const firstBrace = s.indexOf("{");
+  const lastBrace = s.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    return s.slice(firstBrace, lastBrace + 1);
+  }
+  return s;
+}
+var InjectedLLMJudge = class {
+  invoker;
+  constructor(invoker) {
+    this.invoker = invoker;
+  }
+  /** Host adapters override to raise a host-named error subclass. */
+  makeError(message, raw) {
+    return new LLMJudgeError(message, raw);
+  }
+  async ask(prompt, expected) {
+    const framed = frameForJudge(prompt, expected);
+    const raw = await this.invoker({ prompt: framed });
+    return parseJudgeResponse(raw, expected, (m2, r) => this.makeError(m2, r));
+  }
+};
+
+// ../modules/proactive-curator/dist/adapters/claude-code.js
+var ClaudeCodeLLMJudgeError = class extends LLMJudgeError {
+  constructor(message, raw) {
+    super(message, raw);
+    this.name = "ClaudeCodeLLMJudgeError";
+  }
+};
+var ClaudeCodeLLMJudge = class extends InjectedLLMJudge {
+  host = "claude-code";
+  makeError(message, raw) {
+    return new ClaudeCodeLLMJudgeError(message, raw);
+  }
+};
+
+// ../modules/proactive-curator/dist/adapters/codex.js
+var CodexLLMJudgeError = class extends LLMJudgeError {
+  constructor(message, raw) {
+    super(message, raw);
+    this.name = "CodexLLMJudgeError";
+  }
+};
+var CodexLLMJudge = class extends InjectedLLMJudge {
+  host = "codex";
+  makeError(message, raw) {
+    return new CodexLLMJudgeError(message, raw);
+  }
+};
+
+// ../modules/proactive-curator/dist/adapters/gemini.js
+var GeminiLLMJudgeError = class extends LLMJudgeError {
+  constructor(message, raw) {
+    super(message, raw);
+    this.name = "GeminiLLMJudgeError";
+  }
+};
+var GeminiLLMJudge = class extends InjectedLLMJudge {
+  host = "gemini";
+  makeError(message, raw) {
+    return new GeminiLLMJudgeError(message, raw);
+  }
+};
+
+// ../modules/proactive-curator/dist/adapters/claude-desktop.js
+var ClaudeDesktopLLMJudgeError = class extends LLMJudgeError {
+  constructor(message, raw) {
+    super(message, raw);
+    this.name = "ClaudeDesktopLLMJudgeError";
+  }
+};
+var ClaudeDesktopLLMJudge = class extends InjectedLLMJudge {
+  host = "claude-desktop";
+  makeError(message, raw) {
+    return new ClaudeDesktopLLMJudgeError(message, raw);
+  }
+};
+
+// ../plugins/session-rituals/dist/index.js
+var dist_exports14 = {};
+__export(dist_exports14, {
+  SESSION_END_COMMAND: () => SESSION_END_COMMAND,
+  SESSION_START_COMMAND: () => SESSION_START_COMMAND,
+  agendaCommand: () => agendaCommand,
+  buildRegistry: () => buildRegistry,
+  catchUpSessions: () => catchUpSessions,
+  collectAgenda: () => collectAgenda,
+  collectSessionStartReport: () => collectSessionStartReport,
+  createAmbientRecaller: () => createAmbientRecaller,
+  createRitualRegistry: () => createRitualRegistry,
+  curateCommand: () => curateCommand,
+  decisionCommand: () => decisionCommand,
+  detectWorklogGaps: () => detectWorklogGaps,
+  ensureVortexHooks: () => ensureVortexHooks,
+  ensureWorklogEntry: () => ensureWorklogEntry,
+  extractNextUp: () => extractNextUp,
+  extractOpenTasks: () => extractOpenTasks,
+  logCommand: () => logCommand,
+  parseSettings: () => parseSettings,
+  recallCommand: () => recallCommand,
+  reindexCommand: () => reindexCommand,
+  renderAgenda: () => renderAgenda,
+  renderSessionStartReport: () => renderSessionStartReport,
+  resolveRepoRoot: () => resolveRepoRoot,
+  runVortexCli: () => runVortexCli,
+  serializeSettings: () => serializeSettings,
+  sessionStartCommand: () => sessionStartCommand,
+  vortexCommand: () => vortexCommand
+});
+
+// ../plugins/session-rituals/dist/commands/curate.js
+function parseCurateArgs(input) {
+  const args = {};
+  for (const t of input.split(/\s+/).filter(Boolean)) {
+    if (t === "--insight")
+      args.insightOnly = true;
+    else if (t === "--hub")
+      args.hubOnly = true;
+    else if (t === "--reset-declined")
+      args.resetDeclined = true;
+  }
+  return args;
+}
+function curateCommand(options) {
+  const insightProposer = options.insightProposer ?? new InsightProposer({
+    minTokensAccumulated: 2e3,
+    minTurnsBeforeFirstCheck: 6
+  });
+  const hubProposer = options.hubProposer ?? new HubProposer({
+    weakSignalAt: 3,
+    strongSignalAt: 5
+  });
+  return {
+    name: "curate",
+    description: "Run proactive-curator proposers and surface any proposals. Flags: --insight | --hub | --reset-declined.",
+    args: [
+      {
+        name: "flag",
+        description: "Optional: --insight, --hub, or --reset-declined.",
+        required: false
+      }
+    ],
+    handler: async (input) => {
+      const args = parseCurateArgs(input.rest);
+      const { repoRoot } = input.context;
+      const now = /* @__PURE__ */ new Date();
+      if (args.resetDeclined) {
+        await resetDeclined(repoRoot);
+        return {
+          subcommand: "curate",
+          status: "reset-declined",
+          proposals: [],
+          skipped: { insight: false, hub: false },
+          nextActions: [
+            "Decline list cleared. Both insight and hub proposers will re-evaluate previously declined topics on the next /curate."
+          ]
+        };
+      }
+      const runInsight = !args.hubOnly;
+      const runHub = !args.insightOnly;
+      const declinedFingerprints = await loadDeclinedFingerprints(repoRoot, now);
+      const proposals = [];
+      let insightSkipped = !runInsight;
+      let hubSkipped = !runHub;
+      if (runInsight) {
+        const insightInput = options.insightInputProvider?.() ?? null;
+        if (!insightInput) {
+          insightSkipped = true;
+        } else {
+          const p = await insightProposer.evaluate(insightInput, {
+            cwd: repoRoot,
+            declinedFingerprints,
+            llm: options.llm,
+            now
+          });
+          if (p)
+            proposals.push(p);
+        }
+      }
+      if (runHub) {
+        const p = await hubProposer.evaluate({}, {
+          cwd: repoRoot,
+          declinedFingerprints,
+          llm: options.llm,
+          now
+        });
+        if (p)
+          proposals.push(p);
+      }
+      const nextActions = [];
+      if (proposals.length === 0) {
+        nextActions.push("No proposals to surface right now.");
+        if (insightSkipped && hubSkipped) {
+          nextActions.push("Both proposers were skipped \u2014 run /curate without flags to enable both.");
+        } else if (insightSkipped && runInsight) {
+          nextActions.push("Insight proposer was skipped because no insightInputProvider was registered with this plugin.");
+        }
+      } else {
+        nextActions.push(`${proposals.length} proposal${proposals.length === 1 ? "" : "s"} ready. Review each preview and call onAccept() or onDecline() to apply or dismiss.`);
+      }
+      return {
+        subcommand: "curate",
+        status: "ok",
+        proposals,
+        skipped: { insight: insightSkipped, hub: hubSkipped },
+        nextActions
+      };
+    }
+  };
+}
+
+// ../plugins/session-rituals/dist/commands/recall.js
+import { join as join18 } from "path";
+function parseRecallArgs(rest, defaultK) {
+  const tokens = rest.split(/\s+/).filter(Boolean);
+  const out = { k: defaultK, query: "" };
+  const queryParts = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "--k" && i + 1 < tokens.length) {
+      const n = Number(tokens[++i]);
+      if (Number.isFinite(n) && n > 0)
+        out.k = Math.floor(n);
+    } else if (t.startsWith("--k=")) {
+      const n = Number(t.slice("--k=".length));
+      if (Number.isFinite(n) && n > 0)
+        out.k = Math.floor(n);
+    } else if (t === "--source" && i + 1 < tokens.length) {
+      out.source = tokens[++i];
+    } else if (t.startsWith("--source=")) {
+      out.source = t.slice("--source=".length);
+    } else if (t === "--no-filter") {
+      out.noHardFilter = true;
+    } else {
+      queryParts.push(t);
+    }
+  }
+  out.query = queryParts.join(" ");
+  return out;
+}
+function defaultDbPath(ctx) {
+  return join18(ctx.dataDir, "_indexes", "memory.sqlite");
+}
+function recallCommand(options) {
+  const defaultK = options.defaultK ?? 5;
+  const resolveDb = options.dbPath ?? defaultDbPath;
+  return {
+    name: "recall",
+    description: "Hybrid semantic search over memories. Usage: /recall <query> [--k N] [--source memory] [--no-filter].",
+    args: [{ name: "query", description: "Natural-language query.", required: true }],
+    handler: async (input) => {
+      const { sqlite, vector, recall: recallEngine, sessionArchive } = await import("@vortex-os/memory-extended");
+      const args = parseRecallArgs(input.rest, defaultK);
+      const dbPath = resolveDb(input.context);
+      if (args.query.trim().length === 0) {
+        return {
+          query: "",
+          intent: { filters: {}, semanticText: "", notes: ["empty query"] },
+          stage: { appliedFilters: {}, hardFilterCandidates: 0, hardFilterDropped: false, corpusSize: 0 },
+          hits: []
+        };
+      }
+      const sqlStore = new sqlite.MemorySqliteStore(dbPath);
+      const vecStore = new vector.MemoryVectorStore({ db: dbPath });
+      try {
+        const archive = new sessionArchive.SessionArchiveStore(input.context.dataDir);
+        try {
+          await vecStore.rebuildSessions(archive, options.embed, { onlyMissing: true });
+        } finally {
+          archive.close();
+        }
+      } catch {
+      }
+      const chunkStore = new vector.SessionChunkStore(dbPath);
+      try {
+        return await recallEngine.recall({ query: args.query, k: args.k, source: args.source, noHardFilter: args.noHardFilter }, { sqlite: sqlStore, vector: vecStore, embed: options.embed, sessionChunks: chunkStore });
+      } finally {
+        chunkStore.close();
+        vecStore.close();
+        sqlStore.close();
+      }
+    }
+  };
+}
+
+// ../plugins/session-rituals/dist/commands/decision.js
+import { writeFile as writeFile8 } from "fs/promises";
+import { join as join19 } from "path";
+import { existsSync as existsSync5 } from "fs";
+var decisionCommand = {
+  name: "decision",
+  description: "Create a new Decision Log entry from the canonical template at `data/decision-log/<today>-<slug>.md`. Refuses to overwrite an existing file.",
+  args: [
+    { name: "slug", description: "Kebab-style identifier used in the filename.", required: true },
+    { name: "title", description: "One-line decision title (rest of the input).", required: true }
+  ],
+  handler: async (input) => {
+    const slug = input.args.slug;
+    if (!slug) {
+      throw new Error("`/decision` requires a slug argument.");
+    }
+    const title = extractTitle2(input.rest, slug);
+    if (!title) {
+      throw new Error("`/decision` requires a title after the slug.");
+    }
+    const date = todayIso();
+    const dir = join19(input.context.dataDir, "decision-log");
+    const store = new DecisionStore(dir);
+    const path = store.pathFor(date, slug);
+    if (existsSync5(path)) {
+      throw new Error(`Refusing to overwrite existing entry: ${path}`);
+    }
+    const body = renderTemplate({ date, slug, title });
+    await writeFile8(path, body, "utf8");
+    return { path, date, slug };
+  }
+};
+function extractTitle2(rest, slug) {
+  const trimmed = rest.trim();
+  if (trimmed.startsWith(slug)) {
+    return trimmed.slice(slug.length).trim();
+  }
+  return trimmed;
+}
+function todayIso() {
+  const d2 = /* @__PURE__ */ new Date();
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
+
+// ../plugins/session-rituals/dist/commands/reindex.js
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
+import { join as join20 } from "path";
+var TARGETS = [
+  {
+    dir: "_memory",
+    title: "Memory",
+    description: "\uC138\uC158 \uAC04 \uACF5\uC720\uB418\uB294 \uC601\uC18D \uBA54\uBAA8\uB9AC \uD56D\uBAA9\uB4E4. MEMORY.md\uB294 \uBCF8 \uB514\uB809\uD1A0\uB9AC\uC758 \uC6D0\uBCF8 \uC778\uB371\uC2A4\uC774\uBA70, \uBCF8 _INDEX.md\uB294 \uC0AC\uB78C\xB7Obsidian \uCE5C\uD654 \uC591\uC2DD\uC758 \uD30C\uC0DD\uBB3C\uC785\uB2C8\uB2E4.",
+    privacy: "internal",
+    recursive: false,
+    skipPrefixes: [],
+    skipFilenames: ["MEMORY.md"]
+  },
+  {
+    dir: "worklog",
+    title: "Worklog",
+    description: "\uB0A0\uC9DC\uBCC4 \uC791\uC5C5 \uAE30\uB85D. `YYYY/MM/YYYY-MM-DD-keyword.md` \uAD6C\uC870.",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "decision-log",
+    title: "Decision Log",
+    description: "\uAC1C\uC778 \uC758\uC0AC\uACB0\uC815 \uAE30\uB85D \u2014 \uC65C \uADF8\uAC78 \uACE8\uB790\uB294\uC9C0\uB97C \uB0A8\uAE41\uB2C8\uB2E4.",
+    privacy: "personal",
+    recursive: false,
+    skipPrefixes: ["_TEMPLATE"],
+    skipFilenames: []
+  },
+  {
+    dir: "runbooks",
+    title: "Runbooks",
+    description: "\uC7A5\uC560 \uB300\uC751\xB7\uC815\uAE30 \uC815\uBE44 \uC808\uCC28. `last_tested`\uB85C \uAC31\uC2E0 \uAE30\uD55C \uCD94\uC801.",
+    privacy: "internal",
+    recursive: false,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "hubs",
+    title: "Hubs",
+    description: "\uC8FC\uC81C\uBCC4 \uC9C4\uC785\uC810 \u2014 \uAD00\uB828 \uC790\uB8CC\uB97C \uD55C \uACF3\uC5D0\uC11C \uBB36\uB294 \uC778\uB371\uC2A4 \uD398\uC774\uC9C0 \uBAA8\uC74C.",
+    privacy: "internal",
+    recursive: false,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "projects",
+    title: "Projects",
+    description: "\uC9C4\uD589 \uC911\xB7\uC644\uB8CC \uD504\uB85C\uC81D\uD2B8 \uBAA8\uC74C (Work\xB7Home). \uBCF8 _INDEX\uB294 \uD3C9\uD0C4 \uBAA9\uB85D\uC774\uBA70, \uD558\uC704 \uD504\uB85C\uC81D\uD2B8 \uD3F4\uB354\uBCC4 _INDEX\uAC00 \uB354 \uC720\uC6A9\uD560 \uC218 \uC788\uC74C (\uB2E4\uC74C \uC0AC\uC774\uD074 \uAC80\uD1A0).",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "reference",
+    title: "Reference",
+    description: "AI \uADDC\uCE59\xB7\uAE30\uC220 \uCE58\uD2B8\uC2DC\uD2B8\xB7\uC7A5\uBE44\xB7\uC2A4\uD0AC \uB4F1 \uB808\uD37C\uB7F0\uC2A4 \uC790\uB8CC (AI-Rules\xB7Games\xB7Gear\xB7Infra\xB7Org\xB7Skills\xB7Tech).",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "reports",
+    title: "Reports",
+    description: "\uC815\uAE30 \uAC74\uAC15\uAC80\uC9C4 \uB9AC\uD3EC\uD2B8 (Service-Health\xB7Infra-Health). \uC2DC\uC810 \uC2A4\uB0C5\uC0F7 \uB204\uC801.",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "inbox",
+    title: "Inbox",
+    description: "\uBBF8\uBD84\uB958 \uC784\uC2DC \uBA54\uBAA8\xB7\uC544\uC774\uB514\uC5B4\xB7\uBC31\uB85C\uADF8. \uC815\uC2DD \uBD84\uB958 \uC2DC \uD574\uB2F9 \uCE74\uD14C\uACE0\uB9AC\uB85C \uC774\uB3D9.",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  },
+  {
+    dir: "_templates",
+    title: "Templates",
+    description: "\uBCF4\uACE0\uC6A9\xB7\uACF5\uC720\uC6A9 \uC790\uB8CC \uD15C\uD50C\uB9BF \uBAA8\uC74C (Sharing \uB4F1).",
+    privacy: "internal",
+    recursive: true,
+    skipPrefixes: [],
+    skipFilenames: []
+  }
+];
+var reindexCommand = {
+  name: "reindex",
+  description: "Regenerate _INDEX.md for any configured target directory (or all targets when called with no argument). Idempotent \u2014 unchanged indexes are not rewritten.",
+  args: [
+    {
+      name: "dir",
+      description: "Optional directory name. Omit to reindex all targets."
+    }
+  ],
+  handler: async (input) => {
+    const requested = input.args.dir;
+    const targets = requested ? TARGETS.filter((t) => t.dir === requested) : TARGETS;
+    if (requested && targets.length === 0) {
+      throw new Error(`Unknown reindex target: "${requested}". Known: ${TARGETS.map((t) => t.dir).join(", ")}`);
+    }
+    const results = [];
+    for (const t of targets) {
+      const dir = join20(input.context.dataDir, t.dir);
+      if (!existsSync6(dir)) {
+        results.push({ dir: t.dir, status: "missing", entries: 0, bytes: 0 });
+        continue;
+      }
+      const entries = await scanDirectory(dir, {
+        recursive: t.recursive,
+        skipPrefixes: t.skipPrefixes,
+        skipFilenames: t.skipFilenames
+      });
+      const body = renderIndex({
+        title: t.title,
+        description: t.description,
+        entries,
+        privacy: t.privacy
+      });
+      const target = join20(dir, "_INDEX.md");
+      let existing;
+      try {
+        existing = await readFile16(target, "utf8");
+      } catch {
+        existing = void 0;
+      }
+      if (existing === body) {
+        results.push({
+          dir: t.dir,
+          status: "unchanged",
+          entries: entries.length,
+          bytes: body.length
+        });
+        continue;
+      }
+      await writeFile9(target, body, "utf8");
+      results.push({
+        dir: t.dir,
+        status: "written",
+        entries: entries.length,
+        bytes: body.length
+      });
+    }
+    return results;
+  }
+};
+
+// ../plugins/session-rituals/dist/commands/session-start.js
+import { existsSync as existsSync7 } from "fs";
+import { readdir as readdir14 } from "fs/promises";
+import { join as join21 } from "path";
+var COUNTED_DIRS = ["_memory", "worklog", "decision-log"];
+var sessionStartCommand = {
+  name: "session-start",
+  description: "Emit a start-of-session report (time + data directory counts).",
+  handler: async (input) => {
+    const { dataDir, repoRoot } = input.context;
+    const counts = {};
+    const missing = [];
+    for (const name of COUNTED_DIRS) {
+      const dir = join21(dataDir, name);
+      if (!existsSync7(dir)) {
+        missing.push(name);
+        counts[name] = 0;
+        continue;
+      }
+      counts[name] = await countMarkdown(dir, name === "worklog");
+    }
+    return {
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      repoRoot,
+      dataDir,
+      counts,
+      missing
+    };
+  }
+};
+async function countMarkdown(dir, recursive) {
+  let total = 0;
+  const entries = await readdir14(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isFile()) {
+      if (!e.name.endsWith(".md"))
+        continue;
+      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md") {
+        continue;
+      }
+      if (e.name.startsWith("_TEMPLATE"))
+        continue;
+      total++;
+    } else if (e.isDirectory() && recursive) {
+      if (e.name.startsWith(".") || e.name.startsWith("_"))
+        continue;
+      total += await countMarkdown(join21(dir, e.name), recursive);
+    }
+  }
+  return total;
+}
+
+// ../plugins/session-rituals/dist/commands/log.js
+var logCommand = {
+  name: "log",
+  description: "Append a `## <section-title>` section to today's worklog entry. Throws if today's worklog does not exist (run `/vortex init` once to bootstrap).",
+  args: [
+    {
+      name: "section",
+      description: "Title for the new `## ` section (rest of the input).",
+      required: true
+    }
+  ],
+  handler: async (input) => {
+    const sectionTitle = input.rest.trim();
+    if (!sectionTitle) {
+      throw new Error("`/log` requires a section title.");
+    }
+    const date = todayIso2();
+    const store = new WorklogStore(`${input.context.dataDir}/worklog`);
+    const todayEntry = await store.get(date);
+    if (!todayEntry) {
+      throw new Error(`No worklog entry exists for ${date}. Create one first; this command only appends sections.`);
+    }
+    await appendSection(todayEntry, sectionTitle, "");
+    return {
+      path: todayEntry.path,
+      date: todayEntry.date,
+      keyword: todayEntry.keyword,
+      sectionTitle
+    };
+  }
+};
+function todayIso2() {
+  const d2 = /* @__PURE__ */ new Date();
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
+
+// ../plugins/session-rituals/dist/commands/vortex.js
+import { spawn } from "child_process";
+import { existsSync as existsSync8 } from "fs";
+import { copyFile, mkdir as mkdir5, readdir as readdir15, readFile as readFile17, stat as stat8, writeFile as writeFile10 } from "fs/promises";
+import { basename as basename7, dirname as dirname4, join as join22 } from "path";
+import { fileURLToPath } from "url";
+
+// ../plugins/session-rituals/dist/ensure-hooks.js
+var SESSION_START_COMMAND = "npx --no-install -p @vortex-os/base vortex session-start";
+var SESSION_END_COMMAND = "npx --no-install -p @vortex-os/base vortex session-end";
+function parseSettings(text) {
+  const trimmed = (text ?? "").trim();
+  if (trimmed.length === 0)
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (e) {
+    throw new Error(`.claude/settings.json is not valid JSON \u2014 refusing to overwrite. Fix or remove it first. (${e.message})`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(".claude/settings.json is not a JSON object \u2014 refusing to overwrite.");
+  }
+  return parsed;
+}
+function hasCommand(groups, command) {
+  if (!groups)
+    return false;
+  return groups.some((g) => g.hooks?.some((h) => h.command === command));
+}
+function ensureVortexHooks(existing) {
+  const base = existing && typeof existing === "object" ? existing : {};
+  const hooks = { ...base.hooks ?? {} };
+  const added = [];
+  const wire = (event, command) => {
+    const groups = hooks[event] ? [...hooks[event]] : [];
+    if (hasCommand(groups, command))
+      return;
+    groups.push({ hooks: [{ type: "command", command }] });
+    hooks[event] = groups;
+    added.push(event);
+  };
+  wire("SessionStart", SESSION_START_COMMAND);
+  wire("SessionEnd", SESSION_END_COMMAND);
+  const settings = { ...base, hooks };
+  return { settings, added, alreadyWired: added.length === 0 };
+}
+function serializeSettings(settings) {
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+
+// ../plugins/session-rituals/dist/commands/vortex.js
+var PLANNED_SUBS = [];
+var vortexCommand = {
+  name: "vortex",
+  description: "VortEX root command. Subcommands: init | status | import | doctor | sync | help.",
+  args: [
+    {
+      name: "sub",
+      description: "Subcommand (init|status|import|doctor|sync|help).",
+      required: false
+    }
+  ],
+  handler: async (input) => {
+    const tokens = tokenize(input.rest);
+    const sub = tokens[0] ?? "help";
+    const restAfterSub = tokens.slice(1);
+    if (sub === "init")
+      return runInit(input, restAfterSub);
+    if (sub === "status")
+      return runStatus(input);
+    if (sub === "import")
+      return runImport(input, restAfterSub);
+    if (sub === "doctor")
+      return runDoctor(input);
+    if (sub === "sync")
+      return runSync(input, restAfterSub);
+    if (sub === "help" || sub === "")
+      return runHelp();
+    if (PLANNED_SUBS.includes(sub)) {
+      return {
+        subcommand: sub,
+        status: "not-implemented",
+        message: `\`/vortex ${sub}\` is reserved but not yet implemented. Planned in a future phase. Run \`/vortex help\` for available subcommands.`
+      };
+    }
+    return {
+      subcommand: "unknown",
+      status: "not-implemented",
+      message: `Unknown subcommand "${sub}". Run \`/vortex help\` for the list.`
+    };
+  }
+};
+function runHelp() {
+  return {
+    subcommand: "help",
+    status: "ok",
+    subcommands: [
+      {
+        name: "init",
+        description: "First-time setup wizard. Creates user profile memory and first worklog (hubs grow organically \u2014 not seeded here).",
+        state: "active"
+      },
+      {
+        name: "status",
+        description: "Show instance state (memory count, latest worklog, missing skeletons).",
+        state: "active"
+      },
+      {
+        name: "import",
+        description: "Bring an existing folder into data/ \u2014 preserves your folder structure, auto-classifies worklog/decision-log/runbooks/hubs/_memory files, injects missing frontmatter.",
+        state: "active"
+      },
+      {
+        name: "doctor",
+        description: "Diagnose instance health (system dirs, profile, indexes, wiki links, frontmatter, runbook freshness, node version, git remote).",
+        state: "active"
+      },
+      {
+        name: "sync",
+        description: "Framework-developer workflow: git pull \u2192 npm install \u2192 npm run build \u2192 npm run verify. Stops on first failure. End users on npm registry do not need this.",
+        state: "active"
+      },
+      { name: "help", description: "Show this list.", state: "active" }
+    ],
+    siblingCommands: [
+      {
+        name: "session-start",
+        description: "Emit a start-of-session report (time + data directory counts + missing dirs)."
+      },
+      {
+        name: "log",
+        description: "Append a `## <section-title>` section to today's worklog entry. Throws if today's worklog does not exist (run `/vortex init` once to bootstrap)."
+      },
+      {
+        name: "decision",
+        description: "Create a new Decision Log entry from the canonical template at `data/decision-log/<today>-<slug>.md`. Refuses to overwrite an existing file."
+      },
+      {
+        name: "reindex",
+        description: "Regenerate _INDEX.md for any configured target directory (or all targets when called with no argument). Idempotent \u2014 unchanged indexes are not rewritten."
+      }
+    ]
+  };
+}
+function resolveTemplatesDir() {
+  const here = dirname4(fileURLToPath(import.meta.url));
+  const candidates = [
+    join22(here, "..", "..", "templates"),
+    // session-rituals: dist/commands -> templates
+    join22(here, "..", "templates"),
+    // base aggregate: dist -> templates
+    join22(here, "templates")
+    // defensive: alongside the bundle
+  ];
+  for (const c of candidates) {
+    if (existsSync8(join22(c, "commands")) || existsSync8(join22(c, "routers")))
+      return c;
+  }
+  return null;
+}
+async function installCommandTemplates(repoRoot, templatesDir) {
+  if (!templatesDir)
+    return [];
+  const commandsDir = join22(templatesDir, "commands");
+  if (!existsSync8(commandsDir))
+    return [];
+  const destDir = join22(repoRoot, ".claude", "commands");
+  await mkdir5(destDir, { recursive: true });
+  const written = [];
+  for (const name of await readdir15(commandsDir)) {
+    if (!name.endsWith(".md"))
+      continue;
+    const dest = join22(destDir, name);
+    if (existsSync8(dest))
+      continue;
+    await copyFile(join22(commandsDir, name), dest);
+    written.push(dest);
+  }
+  return written;
+}
+var ROUTER_FILES = [
+  "AGENT.md",
+  "CLAUDE.md",
+  "CODEX.md",
+  "GEMINI.md",
+  ".cursorrules"
+];
+async function installRouterTemplates(repoRoot, templatesDir) {
+  if (!templatesDir)
+    return [];
+  const routersDir = join22(templatesDir, "routers");
+  if (!existsSync8(routersDir))
+    return [];
+  const written = [];
+  for (const name of ROUTER_FILES) {
+    const src = join22(routersDir, name);
+    if (!existsSync8(src))
+      continue;
+    const dest = join22(repoRoot, name);
+    if (existsSync8(dest))
+      continue;
+    await copyFile(src, dest);
+    written.push(dest);
+  }
+  return written;
+}
+async function seedInstanceConfig(repoRoot, templatesDir) {
+  const written = [];
+  const agentDir = join22(repoRoot, ".agent");
+  const vortexJson = join22(agentDir, "vortex.json");
+  if (!existsSync8(vortexJson)) {
+    await mkdir5(agentDir, { recursive: true });
+    const tmpl = templatesDir ? join22(templatesDir, "config", "vortex.json") : null;
+    if (tmpl && existsSync8(tmpl)) {
+      await copyFile(tmpl, vortexJson);
+    } else {
+      await writeFile10(vortexJson, JSON.stringify({
+        autoRecord: {
+          sessionStart: true,
+          worklog: true,
+          decision: true,
+          ambientRecall: true,
+          archive: true
+        },
+        environments: []
+      }, null, 2) + "\n", "utf8");
+    }
+    written.push(vortexJson);
+  }
+  const pkgPath = join22(repoRoot, "package.json");
+  if (!existsSync8(pkgPath)) {
+    await writeFile10(pkgPath, JSON.stringify({
+      name: "vortex-instance",
+      version: "0.0.0",
+      private: true,
+      type: "module",
+      description: "A VortEX instance (created by `vortex init`)."
+    }, null, 2) + "\n", "utf8");
+    written.push(pkgPath);
+  }
+  return written;
+}
+async function runInit(input, tokens) {
+  const args = parseInitArgs(tokens);
+  const { dataDir, repoRoot } = input.context;
+  const templatesDir = resolveTemplatesDir();
+  const requiredDirs = ["_memory", "worklog", "decision-log", "hubs", "inbox", "runbooks"];
+  for (const d2 of requiredDirs) {
+    const p = join22(dataDir, d2);
+    if (!existsSync8(p))
+      await mkdir5(p, { recursive: true });
+  }
+  const scaffolded = [];
+  try {
+    scaffolded.push(...await installRouterTemplates(repoRoot, templatesDir));
+  } catch {
+  }
+  try {
+    scaffolded.push(...await seedInstanceConfig(repoRoot, templatesDir));
+  } catch {
+  }
+  const profilePath = join22(dataDir, "_memory", "user_profile.md");
+  if (existsSync8(profilePath) && !args.force) {
+    return {
+      subcommand: "init",
+      status: "already-initialized",
+      created: scaffolded,
+      nextActions: [
+        `VortEX instance is already initialized (${profilePath} exists).`,
+        scaffolded.length > 0 ? `Seeded ${scaffolded.length} missing scaffolding file(s): ${scaffolded.map((p) => p.replace(repoRoot, ".")).join(", ")}.` : "All scaffolding (routers, .agent/vortex.json, package.json) already present.",
+        "To re-run, pass `--force` (existing user_profile / first worklog will be overwritten).",
+        "To check current state, try `/session-start`."
+      ]
+    };
+  }
+  const missing = [];
+  if (!args.name) {
+    missing.push({
+      name: "name",
+      prompt: 'What name or handle should VortEX use for you? (e.g. "Alex" or "team-lead")'
+    });
+  }
+  if (!args.role) {
+    missing.push({
+      name: "role",
+      prompt: 'What is your main role in one word? (e.g. "engineer", "researcher", "writer")'
+    });
+  }
+  if (!args.task) {
+    missing.push({
+      name: "task",
+      prompt: "What is one thing you're working on right now? (one sentence \u2014 this becomes your first worklog seed)"
+    });
+  }
+  if (missing.length > 0) {
+    return {
+      subcommand: "init",
+      status: "needs-input",
+      created: [],
+      missingInputs: missing,
+      nextActions: [
+        "Ask the user the prompts in `missingInputs`, then re-run with the answers:",
+        '  /vortex init --name "<name>" --role "<role>" --task "<task>"',
+        "Optional: append `--force` to overwrite an already-initialized instance."
+      ]
+    };
+  }
+  const today2 = todayIso3();
+  const created = [...scaffolded];
+  const scaffoldNotes = [];
+  if (scaffolded.length > 0) {
+    const names = scaffolded.map((p) => p.replace(repoRoot, ".").replace(/\\/g, "/"));
+    scaffoldNotes.push(`Seeded instance scaffolding: ${names.join(", ")}.`);
+  }
+  await writeFile10(profilePath, renderUserProfile(args.name, args.role, args.task, today2), "utf8");
+  created.push(profilePath);
+  const [year, month] = today2.split("-");
+  const worklogDir = join22(dataDir, "worklog", year, month);
+  await mkdir5(worklogDir, { recursive: true });
+  const worklogPath = join22(worklogDir, `${today2}-vortex-init.md`);
+  await writeFile10(worklogPath, renderFirstWorklog(args.name, args.role, args.task, today2), "utf8");
+  created.push(worklogPath);
+  const hookNotes = [];
+  try {
+    const settingsPath = join22(input.context.repoRoot, ".claude", "settings.json");
+    const existingText = existsSync8(settingsPath) ? await readFile17(settingsPath, "utf8") : null;
+    const { settings, added, alreadyWired } = ensureVortexHooks(parseSettings(existingText));
+    if (!alreadyWired) {
+      await mkdir5(join22(input.context.repoRoot, ".claude"), { recursive: true });
+      await writeFile10(settingsPath, serializeSettings(settings), "utf8");
+      created.push(settingsPath);
+      hookNotes.push(`Wired ${added.join(" + ")} hook(s) into .claude/settings.json \u2014 the VortEX boot report runs automatically at session start.`);
+    } else {
+      hookNotes.push("Session hooks already wired in .claude/settings.json.");
+    }
+  } catch (e) {
+    hookNotes.push(`\u26A0\uFE0F Could not wire session hooks automatically: ${e.message} Copy .claude/settings.example.json to .claude/settings.json by hand to enable the boot report.`);
+  }
+  try {
+    const cmds = await installCommandTemplates(input.context.repoRoot, templatesDir);
+    created.push(...cmds);
+    if (cmds.length > 0) {
+      hookNotes.push(`Installed ${cmds.length} slash command(s) into .claude/commands/ (${cmds.map((c) => "/" + basename7(c, ".md")).join(", ")}).`);
+    }
+  } catch (e) {
+    hookNotes.push(`\u26A0\uFE0F Could not install slash commands: ${e.message}`);
+  }
+  const externalFolders = await detectExternalFolders(input.context.repoRoot);
+  const baseNext = [
+    `Done. Created ${created.length} files.`,
+    ...scaffoldNotes,
+    ...hookNotes,
+    "Next 3 things you can try right now:",
+    "  /log <one-line update>       \u2014 append a section to today's worklog",
+    "  /decision <slug> <title>     \u2014 record a decision",
+    "  /session-start               \u2014 daily start-of-session report",
+    `Open ${worklogPath} to see your first worklog \u2014 it already names "${args.task}".`,
+    "Hubs grow organically: once 3+ categories accumulate on the same topic, create `hubs/_HUB-<topic>.md` to cross-link them."
+  ];
+  const importPrompt = [];
+  if (externalFolders && externalFolders.length > 0) {
+    importPrompt.push("");
+    importPrompt.push("\u{1F4C1} Detected existing folders that look like notes/vaults you may want to import:");
+    for (const f of externalFolders) {
+      importPrompt.push(`  - ${f.path} (${f.mdCount} .md files)`);
+    }
+    importPrompt.push("  Import any of them now with:");
+    for (const f of externalFolders) {
+      importPrompt.push(`    /vortex import --from "${f.path}"`);
+    }
+    importPrompt.push("  (Append --dry-run first to preview without copying. You can also do this later \u2014 these folders are not modified.)");
+  }
+  return {
+    subcommand: "init",
+    status: "completed",
+    created,
+    externalFolders,
+    nextActions: [...baseNext, ...importPrompt]
+  };
+}
+function parseInitArgs(tokens) {
+  const args = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "--force") {
+      args.force = true;
+      continue;
+    }
+    if (t === "--name" && i + 1 < tokens.length) {
+      args.name = tokens[++i];
+      continue;
+    }
+    if (t === "--role" && i + 1 < tokens.length) {
+      args.role = tokens[++i];
+      continue;
+    }
+    if (t === "--task" && i + 1 < tokens.length) {
+      args.task = tokens[++i];
+      continue;
+    }
+  }
+  return args;
+}
+function tokenize(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    while (i < s.length && /\s/.test(s[i]))
+      i++;
+    if (i >= s.length)
+      break;
+    const ch = s[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      let buf = "";
+      while (i < s.length && s[i] !== quote) {
+        buf += s[i++];
+      }
+      if (i < s.length)
+        i++;
+      out.push(buf);
+    } else {
+      let buf = "";
+      while (i < s.length && !/\s/.test(s[i])) {
+        buf += s[i++];
+      }
+      out.push(buf);
+    }
+  }
+  return out;
+}
+function renderUserProfile(name, role, task, date) {
+  return `---
+name: user-profile
+description: Operator profile captured by /vortex init.
+type: user
+created: ${date}
+updated: ${date}
+---
+
+# User Profile
+
+- **Name/handle**: ${name}
+- **Role**: ${role}
+- **Initial focus**: ${task}
+
+This memory was created by \`/vortex init\` on ${date}. Edit freely as your role evolves.
+`;
+}
+function renderFirstWorklog(name, role, task, date) {
+  return `---
+type: worklog
+status: active
+created: ${date}
+updated: ${date}
+tags: [worklog, onboarding]
+---
+
+# ${date} \u2014 VortEX \uC2DC\uC791
+
+> First worklog, created by \`/vortex init\`. ${name} (${role}). Today's focus: ${task}
+
+## What I'm working on
+
+${task}
+
+## Notes
+
+(append more with \`/log <section-title>\`)
+
+## Next
+
+- [ ] Try \`/decision <slug> <title>\` for your first decision record
+- [ ] Add a memory by editing \`data/_memory/user_profile.md\` or creating new ones
+- [ ] Run \`/session-start\` tomorrow to see your accumulated state
+`;
+}
+function todayIso3() {
+  const d2 = /* @__PURE__ */ new Date();
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
+var COUNT_KEY_TO_DIR = {
+  memory: "_memory",
+  worklog: "worklog",
+  decisionLog: "decision-log",
+  runbooks: "runbooks",
+  hubs: "hubs"
+};
+async function runStatus(input) {
+  const { dataDir } = input.context;
+  const profilePath = join22(dataDir, "_memory", "user_profile.md");
+  const initialized = existsSync8(profilePath);
+  const counts = {
+    memory: await safeCount(join22(dataDir, "_memory"), false),
+    worklog: await safeCount(join22(dataDir, "worklog"), true),
+    decisionLog: await safeCount(join22(dataDir, "decision-log"), false),
+    runbooks: await safeCount(join22(dataDir, "runbooks"), false),
+    hubs: await safeCount(join22(dataDir, "hubs"), false)
+  };
+  let latestWorklog;
+  try {
+    const store = new WorklogStore(join22(dataDir, "worklog"));
+    const latest = await store.getLatest();
+    if (latest) {
+      latestWorklog = {
+        date: latest.date,
+        keyword: latest.keyword,
+        path: latest.path
+      };
+    }
+  } catch {
+  }
+  let profile;
+  if (initialized) {
+    try {
+      const raw = await readFile17(profilePath, "utf8");
+      const { body } = parseFrontmatter(raw);
+      profile = extractProfile(body);
+    } catch {
+    }
+  }
+  const missing = [];
+  if (!initialized) {
+    missing.push("_memory/user_profile.md \u2014 run `/vortex init`");
+  }
+  for (const [key, count] of Object.entries(counts)) {
+    if (count === 0) {
+      const dirName = COUNT_KEY_TO_DIR[key];
+      const dirPath = join22(dataDir, dirName);
+      missing.push(existsSync8(dirPath) ? `${dirName}/ is empty` : `${dirName}/ does not exist`);
+    }
+  }
+  const nextActions = [];
+  if (!initialized) {
+    nextActions.push("Run `/vortex init --name <name> --role <role> --task <task>` to set up this instance.");
+  } else {
+    nextActions.push("Run `/session-start` for a fuller session-opening report.", "Run `/log <section-title>` to append a section to today's worklog.");
+    if (counts.decisionLog === 0) {
+      nextActions.push("Try `/decision <slug> <title>` to record your first decision.");
+    }
+  }
+  return {
+    subcommand: "status",
+    status: initialized ? "ok" : "uninitialized",
+    instance: { dataDir, initialized, profile },
+    counts,
+    latestWorklog,
+    missing,
+    nextActions
+  };
+}
+function extractProfile(body) {
+  const nameMatch = body.match(/^- \*\*Name\/handle\*\*:\s*(.+)$/m);
+  const roleMatch = body.match(/^- \*\*Role\*\*:\s*(.+)$/m);
+  if (!nameMatch && !roleMatch)
+    return void 0;
+  const out = {};
+  if (nameMatch)
+    out.name = nameMatch[1].trim();
+  if (roleMatch)
+    out.role = roleMatch[1].trim();
+  return out;
+}
+async function safeCount(dir, recursive) {
+  if (!existsSync8(dir))
+    return 0;
+  try {
+    return await countMarkdown2(dir, recursive);
+  } catch {
+    return 0;
+  }
+}
+async function countMarkdown2(dir, recursive) {
+  let total = 0;
+  const entries = await readdir15(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isFile()) {
+      if (!e.name.endsWith(".md"))
+        continue;
+      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md") {
+        continue;
+      }
+      if (e.name.startsWith("_TEMPLATE"))
+        continue;
+      total++;
+    } else if (e.isDirectory() && recursive) {
+      if (e.name.startsWith(".") || e.name.startsWith("_"))
+        continue;
+      total += await countMarkdown2(join22(dir, e.name), recursive);
+    }
+  }
+  return total;
+}
+var IMPORT_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".vscode",
+  ".idea",
+  "dist",
+  "build",
+  ".obsidian",
+  ".trash"
+]);
+var IMPORT_SKIP_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", ".gitkeep"]);
+var WORKLOG_FOLDER_NAMES = /* @__PURE__ */ new Set([
+  "worklog",
+  "til",
+  "daily",
+  "journal",
+  "diary",
+  "daily-notes",
+  "logs",
+  "log",
+  "\uC77C\uC9C0",
+  "\uB0A0\uC9DC\uBCC4"
+]);
+var DECISION_FOLDER_NAMES = /* @__PURE__ */ new Set([
+  "decision-log",
+  "decisions",
+  "decision"
+]);
+var RUNBOOK_FOLDER_NAMES = /* @__PURE__ */ new Set(["runbooks", "runbook", "sop"]);
+var HUB_FOLDER_NAMES = /* @__PURE__ */ new Set(["hubs", "hub", "_hub"]);
+var MEMORY_FOLDER_NAMES = /* @__PURE__ */ new Set(["_memory", "memory", "memories"]);
+var LEGACY_WORKLOG_TYPES = /* @__PURE__ */ new Set([
+  "til",
+  "daily",
+  "journal",
+  "diary",
+  "log"
+]);
+var FILENAME_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}-/;
+function parseImportArgs(tokens) {
+  const args = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (t === "--from" && i + 1 < tokens.length) {
+      args.from = tokens[++i];
+      continue;
+    }
+  }
+  return args;
+}
+async function runImport(input, tokens) {
+  const args = parseImportArgs(tokens);
+  const { dataDir } = input.context;
+  const emptyClassified = {
+    worklog: 0,
+    decisionLog: 0,
+    runbooks: 0,
+    hubs: 0,
+    memory: 0,
+    preserved: 0
+  };
+  if (!args.from) {
+    return {
+      subcommand: "import",
+      status: "needs-input",
+      totalFiles: 0,
+      copied: 0,
+      classified: emptyClassified,
+      frontmatterInjected: 0,
+      frontmatterPreserved: 0,
+      systemDirsCreated: [],
+      skipped: 0,
+      missingInputs: [
+        {
+          name: "from",
+          prompt: "Where is the folder you want to import? (absolute path, e.g. C:/Users/me/notes)"
+        }
+      ],
+      nextActions: [
+        "Re-run with the path:",
+        '  /vortex import --from "<absolute path>"',
+        "Optional: append --dry-run to preview without copying."
+      ]
+    };
+  }
+  if (!existsSync8(args.from)) {
+    return {
+      subcommand: "import",
+      status: "source-missing",
+      source: args.from,
+      totalFiles: 0,
+      copied: 0,
+      classified: emptyClassified,
+      frontmatterInjected: 0,
+      frontmatterPreserved: 0,
+      systemDirsCreated: [],
+      skipped: 0,
+      nextActions: [
+        `Source folder does not exist: ${args.from}`,
+        "Check the path and re-run."
+      ]
+    };
+  }
+  const systemDirs = [
+    "_memory",
+    "worklog",
+    "decision-log",
+    "runbooks",
+    "hubs",
+    "inbox"
+  ];
+  const systemDirsCreated = [];
+  if (!args.dryRun) {
+    for (const d2 of systemDirs) {
+      const p = join22(dataDir, d2);
+      if (!existsSync8(p)) {
+        await mkdir5(p, { recursive: true });
+        systemDirsCreated.push(d2);
+      }
+    }
+  }
+  const stats = {
+    totalFiles: 0,
+    copied: 0,
+    classified: { ...emptyClassified },
+    frontmatterInjected: 0,
+    frontmatterPreserved: 0,
+    skipped: 0
+  };
+  await walkAndImport(args.from, args.from, dataDir, args.dryRun ?? false, stats);
+  let links;
+  if (!args.dryRun && stats.copied > 0) {
+    try {
+      const check = await checkDirectory(dataDir, { caseInsensitive: true });
+      links = {
+        filesScanned: check.filesScanned,
+        total: check.totalLinks,
+        resolved: check.resolved,
+        broken: check.broken.length,
+        ambiguous: check.ambiguous.length
+      };
+    } catch {
+    }
+  }
+  const nextActions = [];
+  if (args.dryRun) {
+    nextActions.push("This was a dry-run \u2014 no files were copied. Re-run without --dry-run to apply.");
+  } else {
+    nextActions.push("Run `/vortex status` to see the new counts.");
+    if (stats.classified.preserved > 0) {
+      nextActions.push(`${stats.classified.preserved} files preserved your original folder structure (under <dataDir>/<same-paths>).`);
+    }
+    const autoClassified = stats.classified.worklog + stats.classified.decisionLog + stats.classified.runbooks + stats.classified.hubs + stats.classified.memory;
+    if (autoClassified > 0) {
+      nextActions.push(`${autoClassified} files auto-classified into vortex categories (worklog/decision-log/runbooks/hubs/_memory).`);
+    }
+    if (links && (links.broken > 0 || links.ambiguous > 0)) {
+      nextActions.push(`Wiki-link health: ${links.resolved}/${links.total} resolved across ${links.filesScanned} files; ${links.broken} broken, ${links.ambiguous} ambiguous. Review and curate links over time.`);
+    } else if (links && links.total > 0) {
+      nextActions.push(`Wiki-link health: ${links.resolved}/${links.total} resolved across ${links.filesScanned} files \u2014 all clean.`);
     }
-    return {
-      time: (/* @__PURE__ */ new Date()).toISOString(),
-      repoRoot,
-      dataDir,
-      counts,
-      missing
-    };
   }
-};
-async function countMarkdown(dir, recursive) {
-  let total = 0;
-  const entries = await readdir12(dir, { withFileTypes: true });
+  return {
+    subcommand: "import",
+    status: args.dryRun ? "dry-run" : "completed",
+    source: args.from,
+    totalFiles: stats.totalFiles,
+    copied: stats.copied,
+    classified: stats.classified,
+    frontmatterInjected: stats.frontmatterInjected,
+    frontmatterPreserved: stats.frontmatterPreserved,
+    systemDirsCreated,
+    skipped: stats.skipped,
+    links,
+    nextActions
+  };
+}
+async function walkAndImport(rootSource, currentDir, dataDir, dryRun, stats) {
+  const entries = await readdir15(currentDir, { withFileTypes: true });
   for (const e of entries) {
-    if (e.isFile()) {
-      if (!e.name.endsWith(".md"))
+    const sourcePath = join22(currentDir, e.name);
+    if (e.isDirectory()) {
+      if (IMPORT_SKIP_DIRS.has(e.name.toLowerCase()))
         continue;
-      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md") {
+      await walkAndImport(rootSource, sourcePath, dataDir, dryRun, stats);
+    } else if (e.isFile()) {
+      if (IMPORT_SKIP_FILES.has(e.name)) {
+        stats.skipped++;
         continue;
       }
-      if (e.name.startsWith("_TEMPLATE"))
-        continue;
-      total++;
-    } else if (e.isDirectory() && recursive) {
-      if (e.name.startsWith(".") || e.name.startsWith("_"))
+      if (!e.name.endsWith(".md")) {
+        stats.skipped++;
         continue;
-      total += await countMarkdown(join16(dir, e.name), recursive);
+      }
+      stats.totalFiles++;
+      const raw = await readFile17(sourcePath, "utf8");
+      const parsed = parseFrontmatter(raw);
+      const hasFrontmatter = Object.keys(parsed.frontmatter).length > 0;
+      const category = classifyFile(sourcePath, rootSource, e.name, parsed.frontmatter);
+      stats.classified[category]++;
+      if (hasFrontmatter) {
+        stats.frontmatterPreserved++;
+      } else {
+        stats.frontmatterInjected++;
+      }
+      if (!dryRun) {
+        const fileStat = await stat8(sourcePath);
+        const enhanced = enhanceFrontmatter(parsed.frontmatter, category, fileStat.birthtime, fileStat.mtime, sourcePath, rootSource);
+        const targetPath = computeTargetPath(category, sourcePath, rootSource, dataDir, e.name);
+        await mkdir5(dirname4(targetPath), { recursive: true });
+        const out = serializeFrontmatter({
+          frontmatter: enhanced,
+          body: parsed.body
+        });
+        await writeFile10(targetPath, out, "utf8");
+        stats.copied++;
+      }
     }
   }
-  return total;
 }
-
-// ../plugins/session-rituals/dist/commands/til.js
-var tilCommand = {
-  name: "til",
-  description: "Append a section to today's TIL entry.",
-  args: [
-    {
-      name: "section",
-      description: "Title for the new `## ` section (rest of the input).",
-      required: true
-    }
-  ],
-  handler: async (input) => {
-    const sectionTitle = input.rest.trim();
-    if (!sectionTitle) {
-      throw new Error("`/til` requires a section title.");
-    }
-    const date = todayIso2();
-    const store = new TilStore(`${input.context.dataDir}/til`);
-    const todayEntry = await store.get(date);
-    if (!todayEntry) {
-      throw new Error(`No TIL entry exists for ${date}. Create one first; this command only appends sections.`);
+function classifyFile(sourcePath, rootSource, filename, frontmatter) {
+  const type = String(frontmatter.type ?? "").toLowerCase();
+  if (type === "worklog" || LEGACY_WORKLOG_TYPES.has(type))
+    return "worklog";
+  if (type === "decision-log" || type === "decision")
+    return "decisionLog";
+  if (type === "runbook")
+    return "runbooks";
+  if (type === "hub")
+    return "hubs";
+  if (type === "memory" || type === "user")
+    return "memory";
+  if (filename.startsWith("_HUB-"))
+    return "hubs";
+  if (FILENAME_DATE_PATTERN.test(filename))
+    return "worklog";
+  const relPath = sourcePath.substring(rootSource.length).replace(/^[/\\]/, "");
+  const parts = relPath.split(/[/\\]/).map((p) => p.toLowerCase());
+  for (const part of parts) {
+    if (WORKLOG_FOLDER_NAMES.has(part))
+      return "worklog";
+    if (DECISION_FOLDER_NAMES.has(part))
+      return "decisionLog";
+    if (RUNBOOK_FOLDER_NAMES.has(part))
+      return "runbooks";
+    if (HUB_FOLDER_NAMES.has(part))
+      return "hubs";
+    if (MEMORY_FOLDER_NAMES.has(part))
+      return "memory";
+  }
+  return "preserved";
+}
+function computeTargetPath(category, sourcePath, rootSource, dataDir, filename) {
+  if (category === "preserved") {
+    const relPath = sourcePath.substring(rootSource.length).replace(/^[/\\]/, "");
+    return join22(dataDir, relPath);
+  }
+  if (category === "worklog") {
+    const match = filename.match(/^(\d{4})-(\d{2})-/);
+    if (match) {
+      return join22(dataDir, "worklog", match[1], match[2], filename);
     }
-    await appendSection(todayEntry, sectionTitle, "");
-    return {
-      path: todayEntry.path,
-      date: todayEntry.date,
-      keyword: todayEntry.keyword,
-      sectionTitle
+    const d2 = /* @__PURE__ */ new Date();
+    const y2 = String(d2.getFullYear());
+    const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+    return join22(dataDir, "worklog", y2, m2, filename);
+  }
+  if (category === "decisionLog")
+    return join22(dataDir, "decision-log", filename);
+  if (category === "runbooks")
+    return join22(dataDir, "runbooks", filename);
+  if (category === "hubs")
+    return join22(dataDir, "hubs", filename);
+  if (category === "memory")
+    return join22(dataDir, "_memory", filename);
+  return join22(dataDir, filename);
+}
+function enhanceFrontmatter(frontmatter, category, birthtime, mtime, sourcePath, rootSource) {
+  const enhanced = { ...frontmatter };
+  const existingType = String(enhanced.type ?? "").toLowerCase();
+  if (!existingType) {
+    const typeMap = {
+      worklog: "worklog",
+      decisionLog: "decision-log",
+      runbooks: "runbook",
+      hubs: "hub",
+      memory: "memory",
+      preserved: "note"
     };
+    enhanced.type = typeMap[category];
+  } else if (LEGACY_WORKLOG_TYPES.has(existingType)) {
+    enhanced.type = "worklog";
+  }
+  if (Array.isArray(enhanced.tags)) {
+    enhanced.tags = enhanced.tags.map((t) => {
+      const s = String(t).toLowerCase();
+      if (LEGACY_WORKLOG_TYPES.has(s))
+        return "worklog";
+      return t;
+    });
   }
-};
-function todayIso2() {
-  const d2 = /* @__PURE__ */ new Date();
+  if (!enhanced.created) {
+    enhanced.created = formatYmd3(birthtime);
+  }
+  if (!enhanced.updated) {
+    enhanced.updated = formatYmd3(mtime);
+  }
+  if (!enhanced.privacy) {
+    const relLower = sourcePath.substring(rootSource.length).toLowerCase();
+    if (relLower.includes("personal-records") || relLower.includes("personal_records")) {
+      enhanced.privacy = "personal";
+    } else {
+      enhanced.privacy = "internal";
+    }
+  }
+  return enhanced;
+}
+function formatYmd3(d2) {
   const y2 = d2.getFullYear();
   const m2 = String(d2.getMonth() + 1).padStart(2, "0");
   const day = String(d2.getDate()).padStart(2, "0");
   return `${y2}-${m2}-${day}`;
 }
-
-// ../plugins/session-rituals/dist/commands/vortex.js
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir2, writeFile as writeFile7 } from "fs/promises";
-import { join as join17 } from "path";
-var PLANNED_SUBS = ["status", "import", "doctor"];
-var vortexCommand = {
-  name: "vortex",
-  description: "VortEX root command. Subcommands: init | status | import | doctor | help.",
-  args: [
-    {
-      name: "sub",
-      description: "Subcommand (init|status|import|doctor|help).",
-      required: false
+var DOCTOR_SYSTEM_DIRS = [
+  "_memory",
+  "worklog",
+  "decision-log",
+  "runbooks",
+  "hubs"
+];
+var RUNBOOK_AGING_DAYS = 90;
+var NODE_MIN_MAJOR = 18;
+async function runDoctor(input) {
+  const { dataDir, repoRoot } = input.context;
+  const checks = [];
+  checks.push(checkSystemDirs(dataDir));
+  checks.push(checkUserProfile(dataDir));
+  checks.push(await checkIndexes(dataDir));
+  checks.push(await checkWikilinks(dataDir));
+  checks.push(await checkFrontmatterLint(dataDir));
+  checks.push(await checkRunbookAging(dataDir));
+  checks.push(checkNodeVersion());
+  checks.push(await checkGitRemote(repoRoot));
+  const summary = { pass: 0, warn: 0, fail: 0, info: 0 };
+  for (const c of checks)
+    summary[c.status]++;
+  const status = summary.fail > 0 ? "errors" : summary.warn > 0 ? "warnings" : "ok";
+  const nextActions = [];
+  if (summary.fail > 0) {
+    nextActions.push(`${summary.fail} check(s) failed. Address them before relying on the instance.`);
+  }
+  if (summary.warn > 0) {
+    nextActions.push(`${summary.warn} warning(s). Review the detail lines \u2014 most are recoverable in one command.`);
+  }
+  if (status === "ok") {
+    nextActions.push("All checks pass. Run `/vortex status` for activity counts or `/log <section>` to keep working.");
+  }
+  return { subcommand: "doctor", status, checks, summary, nextActions };
+}
+function checkSystemDirs(dataDir) {
+  const missing = DOCTOR_SYSTEM_DIRS.filter((d2) => !existsSync8(join22(dataDir, d2)));
+  if (missing.length === 0) {
+    return {
+      id: "system-dirs",
+      label: "vortex system directories present",
+      status: "pass"
+    };
+  }
+  return {
+    id: "system-dirs",
+    label: "vortex system directories present",
+    status: "fail",
+    detail: `Missing: ${missing.join(", ")}. Run \`/vortex init\` or create them manually.`
+  };
+}
+function checkUserProfile(dataDir) {
+  const profilePath = join22(dataDir, "_memory", "user_profile.md");
+  if (existsSync8(profilePath)) {
+    return {
+      id: "user-profile",
+      label: "user_profile.md exists",
+      status: "pass"
+    };
+  }
+  return {
+    id: "user-profile",
+    label: "user_profile.md exists",
+    status: "fail",
+    detail: "Missing _memory/user_profile.md. Run `/vortex init` to bootstrap the instance."
+  };
+}
+async function checkIndexes(dataDir) {
+  const missing = [];
+  for (const d2 of DOCTOR_SYSTEM_DIRS) {
+    const dirPath = join22(dataDir, d2);
+    if (!existsSync8(dirPath))
+      continue;
+    const indexPath = join22(dirPath, "_INDEX.md");
+    if (!existsSync8(indexPath))
+      missing.push(`${d2}/_INDEX.md`);
+  }
+  if (missing.length === 0) {
+    return {
+      id: "indexes",
+      label: "_INDEX.md present in each system directory",
+      status: "pass"
+    };
+  }
+  return {
+    id: "indexes",
+    label: "_INDEX.md present in each system directory",
+    status: "warn",
+    detail: `Missing: ${missing.join(", ")}. Run \`/reindex\` to generate them.`
+  };
+}
+async function checkWikilinks(dataDir) {
+  try {
+    const result = await checkDirectory(dataDir, { caseInsensitive: true });
+    if (result.totalLinks === 0) {
+      return {
+        id: "wikilinks",
+        label: "wiki links resolve",
+        status: "pass",
+        detail: "No wiki links found."
+      };
     }
-  ],
-  handler: async (input) => {
-    const tokens = tokenize(input.rest);
-    const sub = tokens[0] ?? "help";
-    const restAfterSub = tokens.slice(1);
-    if (sub === "init")
-      return runInit(input, restAfterSub);
-    if (sub === "help" || sub === "")
-      return runHelp();
-    if (PLANNED_SUBS.includes(sub)) {
+    const broken = result.broken.length;
+    const ambiguous = result.ambiguous.length;
+    if (broken === 0 && ambiguous === 0) {
       return {
-        subcommand: sub,
-        status: "not-implemented",
-        message: `\`/vortex ${sub}\` is reserved but not yet implemented. Planned in a future phase. Run \`/vortex help\` for available subcommands.`
+        id: "wikilinks",
+        label: "wiki links resolve",
+        status: "pass",
+        detail: `${result.resolved}/${result.totalLinks} resolved across ${result.filesScanned} files.`
       };
     }
     return {
-      subcommand: "unknown",
-      status: "not-implemented",
-      message: `Unknown subcommand "${sub}". Run \`/vortex help\` for the list.`
+      id: "wikilinks",
+      label: "wiki links resolve",
+      status: "warn",
+      detail: `${broken} broken, ${ambiguous} ambiguous out of ${result.totalLinks} total. Curate or run a rewrite pass.`
+    };
+  } catch (e) {
+    return {
+      id: "wikilinks",
+      label: "wiki links resolve",
+      status: "warn",
+      detail: `Could not scan: ${e.message}`
+    };
+  }
+}
+async function checkFrontmatterLint(dataDir) {
+  try {
+    const report = await lintDirectory({
+      dir: dataDir,
+      rules: [
+        requireFrontmatter({ required: ["type"] }),
+        privacyValid(),
+        wikiLinkResolves({ searchRoot: dataDir })
+      ]
+    });
+    const errors = report.findings.filter((f) => f.severity === "error").length;
+    const warnings = report.findings.filter((f) => f.severity === "warning").length;
+    if (errors === 0 && warnings === 0) {
+      return {
+        id: "frontmatter-lint",
+        label: "frontmatter / privacy / wiki-link rules",
+        status: "pass",
+        detail: `${report.filesScanned} files scanned, 0 findings.`
+      };
+    }
+    if (errors > 0) {
+      return {
+        id: "frontmatter-lint",
+        label: "frontmatter / privacy / wiki-link rules",
+        status: "fail",
+        detail: `${errors} error(s), ${warnings} warning(s) across ${report.filesScanned} files.`
+      };
+    }
+    return {
+      id: "frontmatter-lint",
+      label: "frontmatter / privacy / wiki-link rules",
+      status: "warn",
+      detail: `${warnings} warning(s) across ${report.filesScanned} files.`
+    };
+  } catch (e) {
+    return {
+      id: "frontmatter-lint",
+      label: "frontmatter / privacy / wiki-link rules",
+      status: "warn",
+      detail: `Could not lint: ${e.message}`
+    };
+  }
+}
+async function checkRunbookAging(dataDir) {
+  const runbooksDir = join22(dataDir, "runbooks");
+  if (!existsSync8(runbooksDir)) {
+    return {
+      id: "runbook-aging",
+      label: `runbooks tested within ${RUNBOOK_AGING_DAYS} days`,
+      status: "pass",
+      detail: "No runbooks directory."
+    };
+  }
+  const stale = [];
+  let total = 0;
+  const cutoff = Date.now() - RUNBOOK_AGING_DAYS * 24 * 60 * 60 * 1e3;
+  try {
+    const entries = await readdir15(runbooksDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isFile() || !e.name.endsWith(".md"))
+        continue;
+      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name.startsWith("_TEMPLATE")) {
+        continue;
+      }
+      total++;
+      const filePath = join22(runbooksDir, e.name);
+      const raw = await readFile17(filePath, "utf8");
+      const { frontmatter } = parseFrontmatter(raw);
+      if (!frontmatter.last_tested) {
+        stale.push(`${e.name} (no last_tested)`);
+        continue;
+      }
+      const testedAt = new Date(String(frontmatter.last_tested)).getTime();
+      if (Number.isNaN(testedAt) || testedAt < cutoff) {
+        stale.push(`${e.name} (${String(frontmatter.last_tested)})`);
+      }
+    }
+  } catch (e) {
+    return {
+      id: "runbook-aging",
+      label: `runbooks tested within ${RUNBOOK_AGING_DAYS} days`,
+      status: "warn",
+      detail: `Could not scan: ${e.message}`
+    };
+  }
+  if (total === 0 || stale.length === 0) {
+    return {
+      id: "runbook-aging",
+      label: `runbooks tested within ${RUNBOOK_AGING_DAYS} days`,
+      status: "pass",
+      detail: total === 0 ? "No runbooks." : `${total} runbook(s), all fresh.`
     };
   }
-};
-function runHelp() {
   return {
-    subcommand: "help",
-    status: "ok",
-    subcommands: [
-      {
-        name: "init",
-        description: "First-time setup wizard. Creates user profile memory, first TIL, first topic hub.",
-        state: "active"
-      },
-      {
-        name: "status",
-        description: "Show instance state (memory count, latest TIL, missing skeletons).",
-        state: "planned"
-      },
-      {
-        name: "import",
-        description: "Bring an existing folder into data/imported/ for gradual sorting.",
-        state: "planned"
-      },
-      {
-        name: "doctor",
-        description: "Diagnose common setup issues (missing modules, broken links).",
-        state: "planned"
-      },
-      { name: "help", description: "Show this list.", state: "active" }
-    ]
+    id: "runbook-aging",
+    label: `runbooks tested within ${RUNBOOK_AGING_DAYS} days`,
+    status: "warn",
+    detail: `${stale.length}/${total} runbook(s) stale or untested: ${stale.slice(0, 3).join("; ")}${stale.length > 3 ? "\u2026" : ""}. Even rarely-used runbooks stay valuable \u2014 re-verify when the environment changes, do not delete.`
   };
 }
-async function runInit(input, tokens) {
-  const args = parseInitArgs(tokens);
-  const { dataDir } = input.context;
-  const requiredDirs = ["_memory", "til", "decision-log", "hubs", "inbox"];
-  for (const d2 of requiredDirs) {
-    const p = join17(dataDir, d2);
-    if (!existsSync4(p))
-      await mkdir2(p, { recursive: true });
+function checkNodeVersion() {
+  const raw = process.version;
+  const match = raw.match(/^v?(\d+)\./);
+  if (!match) {
+    return {
+      id: "node-version",
+      label: `node >= ${NODE_MIN_MAJOR}`,
+      status: "warn",
+      detail: `Could not parse node version "${raw}".`
+    };
   }
-  const profilePath = join17(dataDir, "_memory", "user_profile.md");
-  if (existsSync4(profilePath) && !args.force) {
+  const major = Number.parseInt(match[1], 10);
+  if (major >= NODE_MIN_MAJOR) {
     return {
-      subcommand: "init",
-      status: "already-initialized",
-      created: [],
-      nextActions: [
-        `VortEX instance is already initialized (${profilePath} exists).`,
-        "To re-run, pass `--force` (existing user_profile / first TIL / first hub will be overwritten).",
-        "To check current state, try `/session-start`."
-      ]
+      id: "node-version",
+      label: `node >= ${NODE_MIN_MAJOR}`,
+      status: "pass",
+      detail: `Running ${raw}.`
     };
   }
-  const missing = [];
-  if (!args.name) {
-    missing.push({
-      name: "name",
-      prompt: 'What name or handle should VortEX use for you? (e.g. "Alex" or "team-lead")'
-    });
+  return {
+    id: "node-version",
+    label: `node >= ${NODE_MIN_MAJOR}`,
+    status: "fail",
+    detail: `Found ${raw}. TypeScript modules require node ${NODE_MIN_MAJOR} or later. Upgrade node.`
+  };
+}
+async function checkGitRemote(repoRoot) {
+  const gitConfig = join22(repoRoot, ".git", "config");
+  if (!existsSync8(gitConfig)) {
+    return {
+      id: "git-remote",
+      label: "git remote for sync",
+      status: "info",
+      detail: "Not a git repository. VortEX works fine without git, but git + a hosted remote (GitHub, Gitea, GitLab) is recommended if you want to sync across machines (work / home / USB)."
+    };
   }
-  if (!args.role) {
-    missing.push({
-      name: "role",
-      prompt: 'What is your main role in one word? (e.g. "engineer", "researcher", "writer")'
-    });
+  try {
+    const raw = await readFile17(gitConfig, "utf8");
+    const match = raw.match(/\[remote "origin"\][\s\S]*?url\s*=\s*(.+)/);
+    if (!match) {
+      return {
+        id: "git-remote",
+        label: "git remote for sync",
+        status: "info",
+        detail: "Git repo present but no `origin` remote configured. Add one (`git remote add origin <url>`) if you want cross-machine sync."
+      };
+    }
+    return {
+      id: "git-remote",
+      label: "git remote for sync",
+      status: "pass",
+      detail: `origin = ${match[1].trim()}`
+    };
+  } catch (e) {
+    return {
+      id: "git-remote",
+      label: "git remote for sync",
+      status: "info",
+      detail: `Could not read .git/config: ${e.message}`
+    };
   }
-  if (!args.task) {
-    missing.push({
-      name: "task",
-      prompt: "What is one thing you're working on right now? (one sentence \u2014 this becomes your first TIL seed)"
-    });
+}
+async function detectExternalFolders(excludePath) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  if (!home)
+    return void 0;
+  const candidates = [
+    join22(home, "Documents", "obsidian-vault"),
+    join22(home, "Documents", "notes"),
+    join22(home, "Documents", "Notebook"),
+    join22(home, "notes"),
+    join22(home, "Notes")
+  ];
+  const excludeNorm = excludePath.replace(/[/\\]+$/, "");
+  const found = [];
+  for (const candidate of candidates) {
+    const candNorm = candidate.replace(/[/\\]+$/, "");
+    if (candNorm === excludeNorm || candNorm.startsWith(excludeNorm + "/") || candNorm.startsWith(excludeNorm + "\\") || excludeNorm.startsWith(candNorm + "/") || excludeNorm.startsWith(candNorm + "\\")) {
+      continue;
+    }
+    if (!existsSync8(candidate))
+      continue;
+    let mdCount = 0;
+    try {
+      mdCount = await countMarkdown2(candidate, true);
+    } catch {
+      continue;
+    }
+    if (mdCount === 0)
+      continue;
+    found.push({ path: candidate, basename: basename7(candidate), mdCount });
   }
-  if (missing.length > 0) {
+  return found.length > 0 ? found : void 0;
+}
+function parseSyncArgs(tokens) {
+  const args = {};
+  for (const t of tokens) {
+    if (t === "--skip-pull")
+      args.skipPull = true;
+    else if (t === "--skip-install")
+      args.skipInstall = true;
+    else if (t === "--skip-build")
+      args.skipBuild = true;
+    else if (t === "--skip-verify")
+      args.skipVerify = true;
+    else if (t === "--dry-run")
+      args.dryRun = true;
+  }
+  return args;
+}
+async function runSync(input, tokens) {
+  const args = parseSyncArgs(tokens);
+  const { repoRoot } = input.context;
+  const plan = [
+    {
+      id: "pull",
+      label: "git pull",
+      cmd: "git",
+      cmdArgs: ["pull"],
+      skip: args.skipPull ?? false
+    },
+    {
+      id: "install",
+      label: "npm install",
+      cmd: "npm",
+      cmdArgs: ["install"],
+      skip: args.skipInstall ?? false
+    },
+    {
+      id: "build",
+      label: "npm run build",
+      cmd: "npm",
+      cmdArgs: ["run", "build"],
+      skip: args.skipBuild ?? false
+    },
+    {
+      id: "verify",
+      label: "npm run verify",
+      cmd: "npm",
+      cmdArgs: ["run", "verify"],
+      skip: args.skipVerify ?? false
+    }
+  ];
+  if (args.dryRun) {
+    const steps2 = plan.map((p) => ({
+      id: p.id,
+      label: p.label,
+      status: p.skip ? "skipped" : "ok"
+    }));
     return {
-      subcommand: "init",
-      status: "needs-input",
-      created: [],
-      missingInputs: missing,
+      subcommand: "sync",
+      status: "dry-run",
+      steps: steps2,
       nextActions: [
-        "Ask the user the prompts in `missingInputs`, then re-run with the answers:",
-        '  /vortex init --name "<name>" --role "<role>" --task "<task>"',
-        "Optional: append `--force` to overwrite an already-initialized instance."
+        "Dry-run only \u2014 no commands executed.",
+        "Re-run without --dry-run to apply."
       ]
     };
   }
-  const today2 = todayIso3();
-  const created = [];
-  await writeFile7(profilePath, renderUserProfile(args.name, args.role, args.task, today2), "utf8");
-  created.push(profilePath);
-  const [year, month] = today2.split("-");
-  const tilDir = join17(dataDir, "til", year, month);
-  await mkdir2(tilDir, { recursive: true });
-  const tilPath = join17(tilDir, `${today2}-vortex-init.md`);
-  await writeFile7(tilPath, renderFirstTil(args.name, args.role, args.task, today2), "utf8");
-  created.push(tilPath);
-  const hubSlug = slugify(args.role);
-  const hubPath = join17(dataDir, "hubs", `_HUB-${hubSlug}.md`);
-  await writeFile7(hubPath, renderFirstHub(args.role, today2), "utf8");
-  created.push(hubPath);
+  const steps = [];
+  for (const p of plan) {
+    if (p.skip) {
+      steps.push({ id: p.id, label: p.label, status: "skipped" });
+      continue;
+    }
+    const result = await runShellCommand(p.cmd, p.cmdArgs, repoRoot);
+    const step = {
+      id: p.id,
+      label: p.label,
+      status: result.exitCode === 0 ? "ok" : "failed",
+      exitCode: result.exitCode,
+      durationMs: result.durationMs,
+      stdoutTail: result.stdoutTail,
+      stderrTail: result.stderrTail
+    };
+    steps.push(step);
+    if (step.status === "failed") {
+      return {
+        subcommand: "sync",
+        status: "failed",
+        steps,
+        failedAt: p.id,
+        nextActions: [
+          `\`${p.label}\` failed with exit code ${result.exitCode}.`,
+          "Review the stdoutTail / stderrTail and fix the underlying issue, then re-run.",
+          "You can skip already-passed earlier steps with --skip-pull / --skip-install / --skip-build / --skip-verify."
+        ]
+      };
+    }
+  }
+  const ranCount = steps.filter((s) => s.status === "ok").length;
   return {
-    subcommand: "init",
+    subcommand: "sync",
     status: "completed",
-    created,
+    steps,
     nextActions: [
-      `Done. Created ${created.length} files.`,
-      "Next 3 things you can try right now:",
-      "  /til <one-line update>       \u2014 append a section to today's TIL",
-      "  /decision <slug> <title>     \u2014 record a decision",
-      "  /session-start               \u2014 daily start-of-session report",
-      `Open ${tilPath} to see your first TIL \u2014 it already names "${args.task}".`
+      `All ${ranCount} step(s) passed. Your framework checkout is up-to-date and verified.`,
+      "Run `/vortex status` for an instance-side snapshot."
     ]
   };
 }
-function parseInitArgs(tokens) {
-  const args = {};
-  for (let i = 0; i < tokens.length; i++) {
-    const t = tokens[i];
-    if (t === "--force") {
-      args.force = true;
+var SYNC_TAIL_LENGTH = 1e3;
+async function runShellCommand(cmd, cmdArgs, cwd) {
+  const start = Date.now();
+  return new Promise((resolve4) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn(cmd, [...cmdArgs], { cwd, shell: true });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("close", (code) => {
+      resolve4({
+        exitCode: code ?? -1,
+        durationMs: Date.now() - start,
+        stdoutTail: tailString(stdout, SYNC_TAIL_LENGTH),
+        stderrTail: tailString(stderr, SYNC_TAIL_LENGTH)
+      });
+    });
+    child.on("error", (err) => {
+      resolve4({
+        exitCode: -1,
+        durationMs: Date.now() - start,
+        stdoutTail: tailString(stdout, SYNC_TAIL_LENGTH),
+        stderrTail: tailString(stderr + "\n[spawn error] " + err.message, SYNC_TAIL_LENGTH)
+      });
+    });
+  });
+}
+function tailString(s, n) {
+  if (s.length <= n)
+    return s;
+  return "..." + s.slice(-n);
+}
+
+// ../plugins/session-rituals/dist/agenda.js
+var DEFAULT_RECENT = 7;
+var DEFAULT_MAX = 8;
+function worklogTitle(entry) {
+  const m2 = entry.body.match(/^#\s+(.+)$/m);
+  if (m2)
+    return m2[1].trim();
+  return entry.keyword || entry.date;
+}
+function extractNextUp(body, max = 8) {
+  const lines = body.split(/\r?\n/);
+  const headingRe = /^(#{1,6})\s+(.*)$/;
+  const cueRe = /(다음\s*작업|다음\s*세션|후속|next\s*up|next|todo|to-do|📋)/i;
+  let collecting = false;
+  let startLevel = 0;
+  const out = [];
+  for (const line of lines) {
+    const h = line.match(headingRe);
+    if (h) {
+      const level = h[1].length;
+      if (collecting && level <= startLevel)
+        break;
+      if (!collecting && cueRe.test(h[2])) {
+        collecting = true;
+        startLevel = level;
+        continue;
+      }
       continue;
     }
-    if (t === "--name" && i + 1 < tokens.length) {
-      args.name = tokens[++i];
+    if (!collecting)
       continue;
-    }
-    if (t === "--role" && i + 1 < tokens.length) {
-      args.role = tokens[++i];
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
       continue;
-    }
-    if (t === "--task" && i + 1 < tokens.length) {
-      args.task = tokens[++i];
+    if (trimmed.startsWith(">"))
       continue;
-    }
+    const cleaned = trimmed.replace(/^[-*]\s+\[[ xX]\]\s+/, "").replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, "").trim();
+    if (cleaned.length === 0)
+      continue;
+    out.push(cleaned);
+    if (out.length >= max)
+      break;
   }
-  return args;
+  return out;
 }
-function tokenize(s) {
+function extractOpenTasks(body) {
   const out = [];
-  let i = 0;
-  while (i < s.length) {
-    while (i < s.length && /\s/.test(s[i]))
-      i++;
-    if (i >= s.length)
+  for (const line of body.split(/\r?\n/)) {
+    const m2 = line.match(/^\s*[-*]\s+\[\s\]\s+(.+\S)\s*$/);
+    if (m2)
+      out.push(m2[1].trim());
+  }
+  return out;
+}
+async function collectAgenda(ctx, opts) {
+  const recentN = opts?.recentWorklogs ?? DEFAULT_RECENT;
+  const maxTasks = opts?.maxTasks ?? DEFAULT_MAX;
+  const maxDecisions = opts?.maxDecisions ?? DEFAULT_MAX;
+  const worklogStore = new WorklogStore(`${ctx.dataDir}/worklog`);
+  const decisionStore = new DecisionStore(joinDecisionRoot(ctx));
+  const allWorklogs = await worklogStore.list();
+  const sortedWorklogs = [...allWorklogs].sort((a, b2) => a.date < b2.date ? 1 : a.date > b2.date ? -1 : 0);
+  const recent = sortedWorklogs.slice(0, recentN);
+  const lastWorklog = sortedWorklogs[0] ? { date: sortedWorklogs[0].date, title: worklogTitle(sortedWorklogs[0]), path: sortedWorklogs[0].path } : null;
+  const openTasks = [];
+  for (const wl of recent) {
+    for (const text of extractOpenTasks(wl.body)) {
+      openTasks.push({ text, fromDate: wl.date });
+      if (openTasks.length >= maxTasks)
+        break;
+    }
+    if (openTasks.length >= maxTasks)
       break;
-    const ch = s[i];
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      i++;
-      let buf = "";
-      while (i < s.length && s[i] !== quote) {
-        buf += s[i++];
-      }
-      if (i < s.length)
-        i++;
-      out.push(buf);
-    } else {
-      let buf = "";
-      while (i < s.length && !/\s/.test(s[i])) {
-        buf += s[i++];
-      }
-      out.push(buf);
+  }
+  const newest = sortedWorklogs[0];
+  const nextUp = newest ? extractNextUp(newest.body, maxTasks) : [];
+  const nextUpFrom = newest && nextUp.length > 0 ? newest.date : null;
+  const allDecisions = await decisionStore.list();
+  const active = allDecisions.filter((d2) => {
+    const s = (d2.frontmatter?.status ?? "active").toLowerCase();
+    return s !== "archived" && s !== "template";
+  });
+  const sortedDecisions = [...active].sort((a, b2) => a.date < b2.date ? 1 : a.date > b2.date ? -1 : 0);
+  const openDecisions = sortedDecisions.slice(0, maxDecisions).map((d2) => ({
+    title: decisionTitle(d2),
+    date: d2.date,
+    slug: d2.slug
+  }));
+  const worklogCount = allWorklogs.length;
+  const decisionCount = allDecisions.length;
+  const isEmpty = worklogCount === 0 && decisionCount === 0;
+  const nothingOpen = !isEmpty && openTasks.length === 0 && openDecisions.length === 0 && nextUp.length === 0;
+  return {
+    lastWorklog,
+    nextUp,
+    nextUpFrom,
+    openTasks,
+    openDecisions,
+    worklogCount,
+    decisionCount,
+    isEmpty,
+    nothingOpen
+  };
+}
+function joinDecisionRoot(ctx) {
+  return `${ctx.dataDir}/decision-log`;
+}
+function decisionTitle(d2) {
+  const m2 = (d2.body ?? "").match(/^#\s+(.+)$/m);
+  if (m2)
+    return m2[1].trim();
+  return d2.slug;
+}
+function renderAgenda(report) {
+  const lines = ["## What should I do today?", ""];
+  if (report.isEmpty) {
+    lines.push("- No worklog or decisions yet \u2014 this looks like a fresh instance.");
+    lines.push("- Start with `/vortex init` (if you haven't), then `/log <one-line update>` as you work.");
+    lines.push("- A worklog entry per working day is the seed; everything else grows from it.");
+    return lines.join("\n") + "\n";
+  }
+  if (report.lastWorklog) {
+    lines.push(`- last active: ${report.lastWorklog.date} \u2014 ${report.lastWorklog.title}`);
+  }
+  if (report.nextUp.length > 0) {
+    lines.push(`- next up (planned, from ${report.nextUpFrom}):`);
+    for (const n of report.nextUp) {
+      lines.push(`  - ${n}`);
     }
   }
-  return out;
+  if (report.openTasks.length > 0) {
+    lines.push(`- open tasks (${report.openTasks.length}):`);
+    for (const t of report.openTasks) {
+      lines.push(`  - [ ] ${t.text}  (${t.fromDate})`);
+    }
+  }
+  if (report.openDecisions.length > 0) {
+    lines.push(`- open decisions (${report.openDecisions.length}):`);
+    for (const d2 of report.openDecisions) {
+      lines.push(`  - ${d2.title}  (${d2.date})`);
+    }
+  }
+  if (report.nothingOpen) {
+    lines.push(`- nothing open in recent worklogs \u2014 you're clear. ${report.worklogCount} worklog(s), ${report.decisionCount} decision(s) on record.`);
+    lines.push("- Leave a `## \uB2E4\uC74C \uC791\uC5C5` (or `## Next`) section in a worklog, or `- [ ] <task>` lines, to have them surface here next time.");
+  }
+  return lines.join("\n") + "\n";
 }
-function renderUserProfile(name, role, task, date) {
-  return `---
-name: user-profile
-description: Operator profile captured by /vortex init.
-type: user
-created: ${date}
-updated: ${date}
----
-
-# User Profile
-
-- **Name/handle**: ${name}
-- **Role**: ${role}
-- **Initial focus**: ${task}
 
-This memory was created by \`/vortex init\` on ${date}. Edit freely as your role evolves.
+// ../plugins/session-rituals/dist/commands/agenda.js
+var agendaCommand = {
+  name: "agenda",
+  description: "What should I do today? Synthesize open tasks (- [ ] in recent worklogs), active decisions, and last activity from existing records.",
+  handler: async (input) => {
+    const opts = {};
+    return collectAgenda(input.context, opts);
+  }
+};
 
-Linked: [[_HUB-${slugify(role)}]] \u2014 primary topic hub.
-`;
+// ../plugins/session-rituals/dist/registry.js
+function createRitualRegistry(options) {
+  const registry = new CommandRegistry();
+  registry.register(sessionStartCommand);
+  registry.register(reindexCommand);
+  registry.register(decisionCommand);
+  registry.register(logCommand);
+  registry.register(vortexCommand);
+  registry.register(agendaCommand);
+  if (options?.curate) {
+    registry.register(curateCommand(options.curate));
+  }
+  if (options?.recall) {
+    registry.register(recallCommand(options.recall));
+  }
+  return registry;
 }
-function renderFirstTil(name, role, task, date) {
-  return `---
-type: til
-status: active
-created: ${date}
-updated: ${date}
-tags: [til, onboarding]
----
-
-# ${date} \u2014 VortEX \uC2DC\uC791
-
-> First TIL, created by \`/vortex init\`. ${name} (${role}). Today's focus: ${task}
-
-## What I'm working on
-
-${task}
-
-## Notes
 
-(append more with \`/til <section-title>\`)
+// ../plugins/session-rituals/dist/cli-dispatch.js
+import { execFileSync } from "child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync2 } from "fs";
+import { hostname } from "os";
+import { join as join25 } from "path";
 
-## Next
+// ../plugins/session-rituals/dist/session-start-report.js
+import { existsSync as existsSync9 } from "fs";
+import { readdir as readdir16, readFile as readFile18 } from "fs/promises";
+import { join as join23 } from "path";
+var COUNTED_DIRS2 = ["_memory", "worklog", "decision-log"];
+var DEFAULT_GAP_WINDOW_DAYS = 30;
+var BOOT_BANNER = String.raw`
+ __   __       _   _____  __
+ \ \ / ___ _ _| |_| __\ \/ /
+  \ V / _ | '_|  _| _| >  <
+   \_/\___|_|  \__|___/_/\_\
+  Vortex absorbs context · EX executes it`;
+async function collectSessionStartReport(ctx, opts) {
+  const now = opts?.now ?? /* @__PURE__ */ new Date();
+  const counts = {};
+  const missing = [];
+  for (const name of COUNTED_DIRS2) {
+    const dir = join23(ctx.dataDir, name);
+    if (!existsSync9(dir)) {
+      missing.push(name);
+      counts[name] = 0;
+      continue;
+    }
+    counts[name] = await countMarkdown3(dir, name === "worklog");
+  }
+  const { recent, dates } = await scanWorklog(ctx.dataDir);
+  const cutoff = isoDate(addDays(now, -(opts?.gapWindowDays ?? DEFAULT_GAP_WINDOW_DAYS)));
+  const recentWorklogDates = dates.filter((d2) => d2 >= cutoff);
+  return {
+    time: now.toISOString(),
+    repoRoot: ctx.repoRoot,
+    dataDir: ctx.dataDir,
+    counts,
+    missing,
+    recentWorklog: recent,
+    recentWorklogDates,
+    environment: opts?.environment ?? null
+  };
+}
+function detectWorklogGaps(commitDays, presentDates) {
+  const present = new Set(presentDates);
+  return [...new Set(commitDays)].filter((d2) => d2 && !present.has(d2)).sort();
+}
+function renderSessionStartReport(report, extras) {
+  const lines = [BOOT_BANNER, ""];
+  const env = report.environment ? ` \xB7 env: ${report.environment}` : "";
+  lines.push(`- time: ${report.time}${env}`);
+  const git = extras?.git;
+  if (git?.ran) {
+    lines.push(git.conflict ? `- git: \u26A0\uFE0F ${git.summary} \u2014 resolve manually (not auto-resolved)` : `- git: ${git.summary}`);
+  }
+  const countStr = COUNTED_DIRS2.map((d2) => `${d2} ${report.counts[d2] ?? 0}`).join(" \xB7 ");
+  const miss = report.missing.length ? ` (missing: ${report.missing.join(", ")})` : "";
+  lines.push(`- data: ${countStr}${miss}`);
+  lines.push(report.recentWorklog ? `- last worklog: ${report.recentWorklog.title} (${report.recentWorklog.path})` : `- last worklog: none yet`);
+  const gaps = extras?.missingWorklogDays ?? [];
+  if (gaps.length) {
+    lines.push(`- \u26A0\uFE0F work without a worklog: ${gaps.join(", ")} \u2014 backfill from that day's commits`);
+  }
+  const cu = extras?.catchUp;
+  if (cu && (cu.ingestedLocal > 0 || cu.indexedPulled > 0 || cu.errors > 0)) {
+    const parts = [];
+    if (cu.ingestedLocal > 0)
+      parts.push(`${cu.ingestedLocal} new`);
+    if (cu.indexedPulled > 0)
+      parts.push(`${cu.indexedPulled} pulled`);
+    const n = cu.ingestedLocal + cu.indexedPulled;
+    let line = `- caught up: archived ${parts.join(" + ")} conversation${n === 1 ? "" : "s"}`;
+    if (cu.errors > 0)
+      line += ` (${cu.errors} error${cu.errors === 1 ? "" : "s"})`;
+    lines.push(line);
+  }
+  return lines.join("\n") + "\n";
+}
+async function countMarkdown3(dir, recursive) {
+  let total = 0;
+  const entries = await readdir16(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isFile()) {
+      if (!e.name.endsWith(".md"))
+        continue;
+      if (e.name === "README.md" || e.name === "_INDEX.md" || e.name === "MEMORY.md")
+        continue;
+      if (e.name.startsWith("_TEMPLATE"))
+        continue;
+      total++;
+    } else if (e.isDirectory() && recursive) {
+      if (e.name.startsWith(".") || e.name.startsWith("_"))
+        continue;
+      total += await countMarkdown3(join23(dir, e.name), recursive);
+    }
+  }
+  return total;
+}
+async function scanWorklog(dataDir) {
+  const root = join23(dataDir, "worklog");
+  if (!existsSync9(root))
+    return { recent: null, dates: [] };
+  let bestRel = null;
+  const dates = /* @__PURE__ */ new Set();
+  async function walk5(absDir, rel) {
+    let entries;
+    try {
+      entries = await readdir16(absDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        await walk5(join23(absDir, e.name), childRel);
+      } else if (e.isFile()) {
+        const m2 = e.name.match(/^(\d{4}-\d{2}-\d{2})-.+\.md$/);
+        if (!m2)
+          continue;
+        dates.add(m2[1]);
+        if (bestRel === null || childRel > bestRel)
+          bestRel = childRel;
+      }
+    }
+  }
+  await walk5(root, "");
+  const recent = bestRel === null ? null : { path: `worklog/${bestRel}`, title: await readTitle(join23(root, bestRel)) };
+  return { recent, dates: [...dates] };
+}
+async function readTitle(absPath) {
+  try {
+    const raw = await readFile18(absPath, "utf8");
+    const m2 = raw.match(/^#\s+(.+)$/m);
+    if (m2)
+      return m2[1].trim();
+  } catch {
+  }
+  const base = absPath.replace(/\\/g, "/").split("/").pop() ?? absPath;
+  return base.replace(/\.md$/, "");
+}
+function addDays(d2, n) {
+  const out = new Date(d2);
+  out.setDate(out.getDate() + n);
+  return out;
+}
+function isoDate(d2) {
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
 
-- [ ] Try \`/decision <slug> <title>\` for your first decision record
-- [ ] Add a memory by editing \`data/_memory/user_profile.md\` or creating new ones
-- [ ] Run \`/session-start\` tomorrow to see your accumulated state
-`;
+// ../plugins/session-rituals/dist/worklog-write.js
+import { mkdir as mkdir6, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname5, join as join24 } from "path";
+async function ensureWorklogEntry(ctx, opts) {
+  const date = isoDate2(opts?.now ?? /* @__PURE__ */ new Date());
+  const keyword = (opts?.keyword ?? "worklog").trim() || "worklog";
+  const store = new WorklogStore(join24(ctx.dataDir, "worklog"));
+  const existing = await store.get(date);
+  if (existing) {
+    return { path: existing.path, date: existing.date, keyword: existing.keyword, created: false };
+  }
+  const path = store.pathFor(date, keyword);
+  const title = opts?.title ?? `${date} worklog`;
+  await mkdir6(dirname5(path), { recursive: true });
+  await writeFile11(path, renderWorklogFile(date, title, opts?.body ?? ""), "utf8");
+  return { path, date, keyword, created: true };
 }
-function renderFirstHub(role, date) {
+function renderWorklogFile(date, title, body) {
+  const trimmed = body.trimEnd();
   return `---
-type: hub
-status: active
-privacy: internal
+type: worklog
 created: ${date}
 updated: ${date}
-tags: [hub, ${slugify(role)}]
+tags: [worklog]
 ---
 
-# ${role} Hub
-
-> Topic hub for everything related to ${role}. Auto-created by \`/vortex init\`. Edit freely.
-
-## Active TILs
-
-- (link your ${role}-related TILs here as you accumulate them)
-
-## Decisions
-
-- (link Decision Log entries here)
+# ${title}
+` + (trimmed ? `
+${trimmed}
+` : ``);
+}
+function isoDate2(d2) {
+  const y2 = d2.getFullYear();
+  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
+  const day = String(d2.getDate()).padStart(2, "0");
+  return `${y2}-${m2}-${day}`;
+}
 
-## Memories
+// ../plugins/session-rituals/dist/cli-dispatch.js
+var VORTEX_SUBCOMMANDS = ["init", "status", "import", "doctor", "sync"];
+async function buildRegistry() {
+  try {
+    const { vector } = await import("@vortex-os/memory-extended");
+    return createRitualRegistry({ recall: { embed: vector.createLocalEmbedder() } });
+  } catch {
+    return createRitualRegistry();
+  }
+}
+function resolveRepoRoot() {
+  return process.env.VORTEX_REPO_ROOT?.trim() || process.cwd();
+}
+function requote(token) {
+  if (!/\s/.test(token))
+    return token;
+  if (token.includes('"') && !token.includes("'"))
+    return `'${token}'`;
+  return `"${token.replace(/"/g, "")}"`;
+}
+async function runVortexCli(argv, io) {
+  const out = io?.stdout ?? ((s) => process.stdout.write(s));
+  const err = io?.stderr ?? ((s) => process.stderr.write(s));
+  const repoRoot = resolveRepoRoot();
+  try {
+    if (argv[0] === "session-start") {
+      await runSessionStart(repoRoot, out);
+      return 0;
+    }
+    if (argv[0] === "session-end") {
+      await runSessionEnd(repoRoot, out);
+      return 0;
+    }
+    const registry = await buildRegistry();
+    if (argv.length === 0 || argv[0] === "--list" || argv[0] === "--help") {
+      const names = registry.list().map((c) => `  ${c.name}  \u2014  ${c.description}`).join("\n");
+      err(`vortex \u2014 headless ritual runner
 
-- (link \`_memory/*.md\` entries here)
+Commands:
+${names}
+  session-start  \u2014  emit the start-of-session boot report (git pull + data counts + catch-up)
+  session-end    \u2014  worklog safety net (create today's worklog if work happened and none exists)
 
-## External references
+Instance shortcuts (also available as \`/vortex <sub>\`):
+  init   \u2014  first-time setup: routers + data/ + hooks + slash-commands
+  status \u2014  instance state report
+  import \u2014  bring an existing notes folder into data/
+  doctor \u2014  health diagnosis
 
-- (links, dashboards, repos, etc.)
-`;
+Usage: vortex <command> [args...]
+`);
+      return 0;
+    }
+    const name = argv[0];
+    const isVortexSub = VORTEX_SUBCOMMANDS.includes(name);
+    const body = (isVortexSub ? argv : argv.slice(1)).map(requote).join(" ");
+    const slash = isVortexSub ? `/vortex ${body}` : `/${name} ${body}`;
+    const context = makeContext(repoRoot);
+    const result = await runSlash(slash.trim(), { registry, context });
+    out(JSON.stringify(result, null, 2) + "\n");
+    return 0;
+  } catch (e) {
+    if (e instanceof CommandNotFoundError) {
+      err(`[vortex] unknown command: ${e.message}
+Run \`vortex --list\` to see available commands.
+`);
+    } else {
+      err(`[vortex] error: ${e?.message ?? e}
+`);
+    }
+    return 1;
+  }
 }
-function slugify(s) {
-  return s.toLowerCase().replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-+|-+$/g, "");
+async function runSessionStart(repoRoot, out) {
+  const ctx = makeContext(repoRoot);
+  const config = loadVortexConfig(ctx);
+  if (!config.autoRecord.sessionStart)
+    return;
+  const environment = resolveSessionEnvironment(ctx, config);
+  let git = null;
+  try {
+    const remotes = gitOut(repoRoot, ["remote"]).trim();
+    if (remotes) {
+      try {
+        const pulled = gitOut(repoRoot, ["pull", "--ff-only"]);
+        const lastLine = pulled.trim().split(/\r?\n/).pop() || "up to date";
+        git = { ran: true, summary: lastLine, conflict: false };
+      } catch {
+        git = {
+          ran: true,
+          summary: "fast-forward pull failed (diverged or dirty tree)",
+          conflict: true
+        };
+      }
+    }
+  } catch {
+  }
+  const report = await collectSessionStartReport(ctx, { environment });
+  let missingWorklogDays = [];
+  try {
+    const log = gitOut(repoRoot, ["log", "--since=7 days ago", "--pretty=%cd", "--date=short"]);
+    const commitDays = log.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+    missingWorklogDays = detectWorklogGaps(commitDays, report.recentWorklogDates);
+  } catch {
+  }
+  let catchUp = null;
+  if (config.autoRecord.archive) {
+    try {
+      const { catchUpSessions: catchUpSessions2 } = await import("./catch-up-ZQN7HMMN.js");
+      catchUp = await catchUpSessions2(ctx);
+    } catch {
+    }
+  }
+  out(renderSessionStartReport(report, {
+    git,
+    missingWorklogDays,
+    catchUp: catchUp ?? void 0
+  }));
 }
-function todayIso3() {
-  const d2 = /* @__PURE__ */ new Date();
-  const y2 = d2.getFullYear();
-  const m2 = String(d2.getMonth() + 1).padStart(2, "0");
-  const day = String(d2.getDate()).padStart(2, "0");
-  return `${y2}-${m2}-${day}`;
+async function runSessionEnd(repoRoot, out) {
+  const ctx = makeContext(repoRoot);
+  const config = loadVortexConfig(ctx);
+  if (config.autoRecord.worklog && hadActivityToday(repoRoot)) {
+    const res = await ensureWorklogEntry(ctx, {
+      body: "_Auto-created at session end (work detected but no worklog written). Enrich with the session's work, or remove if there is nothing to log._"
+    });
+    if (res.created)
+      out(`VortEX: created worklog ${res.path}
+`);
+  }
+}
+function gitOut(cwd, gitArgs) {
+  return execFileSync("git", [...gitArgs], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+}
+function hadActivityToday(repoRoot) {
+  try {
+    const dirty = gitOut(repoRoot, ["status", "--porcelain"]).trim();
+    if (dirty)
+      return true;
+    const since = /* @__PURE__ */ new Date();
+    since.setHours(0, 0, 0, 0);
+    const commits = gitOut(repoRoot, ["log", "--oneline", `--since=${since.toISOString()}`]).trim();
+    return commits.length > 0;
+  } catch {
+    return false;
+  }
+}
+function resolveSessionEnvironment(ctx, config) {
+  let environment = resolveEnvironment(config, {
+    hostname: hostname(),
+    env: process.env,
+    pathExists: existsSync10
+  });
+  if (!environment)
+    environment = process.env.VORTEX_ENV?.trim() || null;
+  if (!environment) {
+    const envFile = join25(ctx.repoRoot, ".agent", "environment");
+    if (existsSync10(envFile)) {
+      environment = readFileSync2(envFile, "utf8").split(/\r?\n/)[0]?.trim() || null;
+    }
+  }
+  return environment;
 }
 
-// ../plugins/session-rituals/dist/registry.js
-function createRitualRegistry() {
-  const registry = new CommandRegistry();
-  registry.register(sessionStartCommand);
-  registry.register(reindexCommand);
-  registry.register(decisionCommand);
-  registry.register(tilCommand);
-  registry.register(vortexCommand);
-  return registry;
+// ../plugins/session-rituals/dist/ambient-recall.js
+import { join as join26 } from "path";
+function defaultDbPath2(ctx) {
+  return join26(ctx.dataDir, "_indexes", "memory.sqlite");
+}
+function createAmbientRecaller(ctx, options) {
+  const resolveDb = options.dbPath ?? defaultDbPath2;
+  const dbPath = resolveDb(ctx);
+  return new AmbientRecaller({
+    ...options.minScore !== void 0 ? { minScore: options.minScore } : {},
+    ...options.maxSuggestions !== void 0 ? { maxSuggestions: options.maxSuggestions } : {},
+    ...options.minQueryChars !== void 0 ? { minQueryChars: options.minQueryChars } : {},
+    recall: async (query, opts) => {
+      const { sqlite, vector, recall: recallEngine } = await import("@vortex-os/memory-extended");
+      const sqlStore = new sqlite.MemorySqliteStore(dbPath);
+      const vecStore = new vector.MemoryVectorStore({ db: dbPath });
+      const chunkStore = new vector.SessionChunkStore(dbPath);
+      try {
+        const result = await recallEngine.recall({
+          query,
+          ...opts?.k !== void 0 ? { k: opts.k } : {},
+          ...options.source !== void 0 ? { source: options.source } : {}
+        }, { sqlite: sqlStore, vector: vecStore, embed: options.embed, sessionChunks: chunkStore });
+        return { hits: result.hits };
+      } finally {
+        chunkStore.close();
+        vecStore.close();
+        sqlStore.close();
+      }
+    }
+  });
 }
 export {
   dist_exports5 as aiCodingPitfalls,
@@ -3271,11 +6411,12 @@ export {
   dist_exports10 as indexGenerator,
   dist_exports12 as linkRewriter,
   dist_exports3 as memorySystem,
+  dist_exports13 as proactiveCurator,
   dist_exports7 as reportGenerator,
   dist_exports11 as runbooks,
-  dist_exports13 as sessionRituals,
+  dist_exports14 as sessionRituals,
   dist_exports2 as slashCommands,
-  dist_exports8 as til,
-  dist_exports6 as toolRules
+  dist_exports6 as toolRules,
+  dist_exports8 as worklog
 };
 //# sourceMappingURL=index.js.map