@unpolarize/knowledge-planning 0.1.0 → 0.2.0

package/dist/chunk-6GL2IYUE.js

@@ -0,0 +1,2020 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/schema/entities.ts
+import { z } from "zod";
+var SCHEMA_VERSION = 1;
+var ns = (t) => `knowledge-planning/${t}@${SCHEMA_VERSION}`;
+var OBJECT_TYPES = [
+  "domain",
+  "project",
+  "catalog_entry",
+  "idea",
+  "plan",
+  "task",
+  "daily_plan",
+  "reflection",
+  "insight",
+  "thought"
+];
+var IDEA_STATUS = ["capture", "refine", "accepted", "plan", "parked", "done"];
+var PLAN_STATUS = ["plan", "prototype", "implement", "validate", "done", "parked"];
+var TASK_STATUS = ["inbox", "today", "in_progress", "done", "deferred", "outdated"];
+var SESSION_PHASE = ["backlog", "planning", "implementing", "validating", "complete"];
+var INSIGHT_STATUS = ["new", "accepted", "parked"];
+var THOUGHT_STATUS = ["new", "kept", "converted", "archived"];
+var KnowledgeRefSchema = z.object({
+  path: z.string().min(1),
+  reason: z.string().optional(),
+  status: z.enum(["open", "resolved"]).default("open"),
+  title: z.string().optional()
+}).passthrough();
+var baseShape = {
+  schema: z.string().optional(),
+  id: z.string().min(1),
+  title: z.string().optional(),
+  status: z.string().optional(),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+  domain: z.string().optional(),
+  project: z.string().optional(),
+  priority: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  cites: z.array(z.string()).default([]),
+  blocked_by: z.array(KnowledgeRefSchema).default([]),
+  depends_on: z.array(z.string()).default([]),
+  related: z.array(z.string()).default([]),
+  linked_sessions: z.array(z.string()).default([])
+};
+var DomainSchema = z.object({ ...baseShape, type: z.literal("domain"), name: z.string().optional() }).passthrough();
+var ProjectSchema = z.object({
+  ...baseShape,
+  type: z.literal("project"),
+  catalog_slug: z.string().optional(),
+  kb_paths: z.array(z.string()).default([]),
+  repos: z.array(z.string()).default([]),
+  status: z.string().default("active")
+}).passthrough();
+var CatalogEntrySchema = z.object({
+  ...baseShape,
+  type: z.literal("catalog_entry"),
+  catalog_slug: z.string().optional(),
+  kb_paths: z.array(z.string()).default([]),
+  status: z.string().default("active")
+}).passthrough();
+var IdeaSchema = z.object({
+  ...baseShape,
+  type: z.literal("idea"),
+  status: z.enum(IDEA_STATUS).default("capture"),
+  promoted_to: z.string().optional()
+}).passthrough();
+var PlanSchema = z.object({
+  ...baseShape,
+  type: z.literal("plan"),
+  status: z.enum(PLAN_STATUS).default("plan"),
+  kind: z.enum(["dev", "life"]).default("dev"),
+  phase: z.enum(SESSION_PHASE).optional(),
+  promoted_from: z.string().optional()
+}).passthrough();
+var TaskSchema = z.object({
+  ...baseShape,
+  type: z.literal("task"),
+  status: z.enum(TASK_STATUS).default("inbox"),
+  plan: z.string().optional(),
+  daily: z.string().optional(),
+  scheduled_for: z.string().optional(),
+  // Due date (YYYY-MM-DD). due === today ⇒ must-have for the day; due < today ⇒ overdue.
+  due: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  dispatch_task_id: z.string().optional()
+}).passthrough();
+var DailyPlanSchema = z.object({
+  ...baseShape,
+  type: z.literal("daily_plan"),
+  date: z.string().min(1),
+  domain_focus: z.array(z.string()).default([]),
+  carry_over_from: z.string().optional()
+}).passthrough();
+var ReflectionSchema = z.object({
+  ...baseShape,
+  type: z.literal("reflection"),
+  date: z.string().min(1),
+  daily_plan: z.string().optional(),
+  domains: z.array(z.string()).default([])
+}).passthrough();
+var InsightSchema = z.object({
+  ...baseShape,
+  type: z.literal("insight"),
+  source: z.string().min(1),
+  source_ref: z.string().optional(),
+  generated_at: z.string().optional(),
+  confidence: z.string().optional(),
+  suggested_tasks: z.array(z.string()).default([]),
+  status: z.enum(INSIGHT_STATUS).default("new")
+}).passthrough();
+var ThoughtSchema = z.object({
+  ...baseShape,
+  type: z.literal("thought"),
+  status: z.enum(THOUGHT_STATUS).default("new"),
+  // provenance — where the prose came from and when
+  source: z.string().optional(),
+  // provenance, e.g. 'gdoc:<doc-slug>'
+  source_url: z.string().optional(),
+  surfaced_on: z.string().optional(),
+  // YYYY-MM-DD the ingest saw it
+  context: z.string().optional(),
+  // date header / section the prose sat under
+  converted_to: z.string().optional()
+  // idea id after conversion
+}).passthrough();
+var SCHEMA_BY_TYPE = {
+  domain: DomainSchema,
+  project: ProjectSchema,
+  catalog_entry: CatalogEntrySchema,
+  idea: IdeaSchema,
+  plan: PlanSchema,
+  task: TaskSchema,
+  daily_plan: DailyPlanSchema,
+  reflection: ReflectionSchema,
+  insight: InsightSchema,
+  thought: ThoughtSchema
+};
+var ObjectSchema = z.discriminatedUnion("type", [
+  DomainSchema,
+  ProjectSchema,
+  CatalogEntrySchema,
+  IdeaSchema,
+  PlanSchema,
+  TaskSchema,
+  DailyPlanSchema,
+  ReflectionSchema,
+  InsightSchema,
+  ThoughtSchema
+]);
+var EDGE_KINDS = [
+  "depends_on",
+  "blocks",
+  "blocked_by",
+  "implements",
+  "cites",
+  "translates_to",
+  "promoted_to",
+  "parent_of",
+  "related",
+  "evidence",
+  "surfaced_on",
+  "scheduled_for"
+];
+var EdgeSchema = z.object({
+  kind: z.enum(EDGE_KINDS),
+  from: z.string().min(1),
+  to: z.string().min(1),
+  reason: z.string().optional(),
+  status: z.enum(["open", "resolved"]).optional(),
+  created_at: z.string().optional()
+}).passthrough();
+function parseObject(data) {
+  return ObjectSchema.parse(data);
+}
+function safeParseObject(data) {
+  return ObjectSchema.safeParse(data);
+}
+
+// src/schema/frontmatter.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseMarkdown(content) {
+  const m = content.match(FRONTMATTER_RE);
+  if (!m) return { data: {}, body: content };
+  const parsed = parseYaml(m[1]) ?? {};
+  const data = typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  return { data, body: content.slice(m[0].length) };
+}
+function clean(value) {
+  if (Array.isArray(value)) return value.map(clean).filter((v) => v !== void 0 && v !== null);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const cv = clean(v);
+      if (cv === void 0 || cv === null) continue;
+      if (Array.isArray(cv) && cv.length === 0) continue;
+      out[k] = cv;
+    }
+    return out;
+  }
+  return value;
+}
+function serializeMarkdown(data, body = "") {
+  const cleaned = clean(data);
+  const fm = stringifyYaml(cleaned, { lineWidth: 0 }).trimEnd();
+  const block = `---
+${fm}
+---
+`;
+  const trimmed = body.replace(/^\n+/, "");
+  if (!trimmed.trim()) return block;
+  return `${block}
+${trimmed.replace(/\n*$/, "\n")}`;
+}
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  domains: [],
+  kb_root: process.env.KP_KB_ROOT ?? process.cwd(),
+  sessions_root: process.env.CODE_SESSIONS_STORE ?? "",
+  project_rules: [],
+  project_id_rules: []
+};
+
+// src/store/store.ts
+import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync, appendFileSync, rmSync } from "fs";
+import { join, dirname, relative } from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".index", "src", "test", "dist", ".vscode"]);
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["project"]);
+var Store = class {
+  root;
+  docs = null;
+  warnings = [];
+  constructor(root) {
+    this.root = root;
+  }
+  get configPath() {
+    return join(this.root, "config.json");
+  }
+  get edgesPath() {
+    return join(this.root, "edges.jsonl");
+  }
+  config() {
+    if (!existsSync(this.configPath)) return { ...DEFAULT_CONFIG };
+    try {
+      return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(this.configPath, "utf8")) };
+    } catch {
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+  /** Force a re-scan on next access. */
+  invalidate() {
+    this.docs = null;
+  }
+  ensureLoaded() {
+    if (this.docs) return this.docs;
+    const docs = /* @__PURE__ */ new Map();
+    this.warnings = [];
+    for (const abs of walkMarkdown(this.root)) {
+      let raw;
+      try {
+        raw = readFileSync(abs, "utf8");
+      } catch {
+        continue;
+      }
+      const { data, body } = parseMarkdown(raw);
+      const type = data.type;
+      const id = data.id;
+      if (!type || !id || !(type in SCHEMA_BY_TYPE)) continue;
+      const schema = SCHEMA_BY_TYPE[type];
+      const res = schema.safeParse(data);
+      if (!res.success) {
+        this.warnings.push(`${relative(this.root, abs)}: ${res.error.issues[0]?.message ?? "invalid"}`);
+        continue;
+      }
+      docs.set(id, {
+        id,
+        type,
+        path: abs,
+        relpath: relative(this.root, abs),
+        object: res.data,
+        data,
+        body
+      });
+    }
+    this.docs = docs;
+    return docs;
+  }
+  getWarnings() {
+    this.ensureLoaded();
+    return this.warnings;
+  }
+  all() {
+    return [...this.ensureLoaded().values()];
+  }
+  get(id) {
+    return this.ensureLoaded().get(id);
+  }
+  byType(type) {
+    return this.all().filter((d) => d.type === type);
+  }
+  /** Default on-disk path for a new object id. Projects are folders (`<id>/index.md`). */
+  pathForId(id, type) {
+    if (CONTAINER_TYPES.has(type)) return join(this.root, id, "index.md");
+    return join(this.root, `${id}.md`);
+  }
+  /**
+   * Create or overwrite an object. Frontmatter is validated; body defaults to the
+   * existing body when omitted for an existing object.
+   */
+  write(input, body) {
+    const { id, type } = input;
+    if (!(type in SCHEMA_BY_TYPE)) throw new Error(`unknown type: ${type}`);
+    const existing = this.get(id);
+    const data = { schema: ns(type), ...input };
+    const schema = SCHEMA_BY_TYPE[type];
+    const parsed = schema.parse(data);
+    const path2 = existing?.path ?? this.pathForId(id, type);
+    const finalBody = body ?? existing?.body ?? "";
+    mkdirSync(dirname(path2), { recursive: true });
+    writeFileSync(path2, serializeMarkdown(data, finalBody), "utf8");
+    const doc = {
+      id,
+      type,
+      path: path2,
+      relpath: relative(this.root, path2),
+      object: parsed,
+      data,
+      body: finalBody
+    };
+    this.ensureLoaded().set(id, doc);
+    return doc;
+  }
+  /** Load an object, mutate its frontmatter via `mutator`, and write it back. */
+  patch(id, mutator) {
+    const existing = this.get(id);
+    if (!existing) throw new Error(`object not found: ${id}`);
+    const data = { ...existing.data };
+    mutator(data);
+    return this.write(data, existing.body);
+  }
+  /** Delete an object: remove its file (folder for container types), drop it from
+   * the loaded map, and prune any edges.jsonl rows that reference it. */
+  delete(id) {
+    const existing = this.get(id);
+    if (!existing) return false;
+    if (CONTAINER_TYPES.has(existing.type)) {
+      rmSync(dirname(existing.path), { recursive: true, force: true });
+    } else {
+      rmSync(existing.path, { force: true });
+    }
+    this.ensureLoaded().delete(id);
+    if (existsSync(this.edgesPath)) {
+      const kept = this.fileEdges().filter((e) => e.from !== id && e.to !== id);
+      writeFileSync(this.edgesPath, kept.map((e) => JSON.stringify(e)).join("\n") + (kept.length ? "\n" : ""), "utf8");
+    }
+    return true;
+  }
+  // --- Edges ---------------------------------------------------------------
+  appendEdge(edge) {
+    const e = EdgeSchema.parse(edge);
+    appendFileSync(this.edgesPath, JSON.stringify(e) + "\n", "utf8");
+  }
+  /** Explicit edges from edges.jsonl (append-only log). */
+  fileEdges() {
+    if (!existsSync(this.edgesPath)) return [];
+    const out = [];
+    for (const line of readFileSync(this.edgesPath, "utf8").split("\n")) {
+      const t = line.trim();
+      if (!t) continue;
+      try {
+        out.push(EdgeSchema.parse(JSON.parse(t)));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /** Edges derived from object frontmatter (the rebuildable source of truth). */
+  frontmatterEdges() {
+    const edges = [];
+    for (const d of this.all()) {
+      const o = d.object;
+      for (const ref of o.blocked_by ?? [])
+        edges.push({ kind: "blocked_by", from: o.id, to: ref.path, reason: ref.reason, status: ref.status });
+      for (const c of o.cites ?? []) edges.push({ kind: "cites", from: o.id, to: c });
+      for (const dep of o.depends_on ?? []) edges.push({ kind: "depends_on", from: o.id, to: dep });
+      for (const r of o.related ?? []) edges.push({ kind: "related", from: o.id, to: r });
+      for (const s of o.linked_sessions ?? []) edges.push({ kind: "evidence", from: `session:${s}`, to: o.id });
+      if (o.type === "idea" && o.promoted_to) edges.push({ kind: "promoted_to", from: o.id, to: o.promoted_to });
+      if (o.type === "task" && o.plan) edges.push({ kind: "parent_of", from: o.plan, to: o.id });
+      if (o.type === "task" && o.scheduled_for) edges.push({ kind: "scheduled_for", from: o.id, to: o.scheduled_for });
+      if (o.type === "insight") for (const t of o.suggested_tasks ?? []) edges.push({ kind: "surfaced_on", from: o.id, to: t });
+      if (o.project) edges.push({ kind: "parent_of", from: o.project, to: o.id });
+    }
+    return edges;
+  }
+  /** Union of frontmatter-derived and explicit edges. */
+  allEdges() {
+    return [...this.frontmatterEdges(), ...this.fileEdges()];
+  }
+};
+function walkMarkdown(root) {
+  const out = [];
+  if (!existsSync(root)) return out;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (IGNORE_DIRS.has(e.name) || e.name.startsWith(".")) continue;
+        walk(join(dir, e.name));
+      } else if (e.isFile() && e.name.endsWith(".md")) {
+        out.push(join(dir, e.name));
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+
+// src/kb-bridge/kb-bridge.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { isAbsolute, join as join2 } from "path";
+function resolveKnowledgeRef(refPath, kbRoot) {
+  return isAbsolute(refPath) ? refPath : join2(kbRoot, refPath);
+}
+function readTitle(absPath) {
+  if (!existsSync2(absPath)) return void 0;
+  const { data, body } = parseMarkdown(readFileSync2(absPath, "utf8"));
+  if (typeof data.title === "string") return data.title;
+  if (Array.isArray(data.aliases) && typeof data.aliases[0] === "string") return data.aliases[0];
+  const m = body.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : void 0;
+}
+function hasDecision(absPath) {
+  if (!existsSync2(absPath)) return false;
+  const { data, body } = parseMarkdown(readFileSync2(absPath, "utf8"));
+  if (data.decision != null && String(data.decision).trim() !== "") return true;
+  return /^#{1,6}\s+decision\b/im.test(body);
+}
+function inspectKnowledgeRef(ownerId, ref, kbRoot) {
+  const abs = resolveKnowledgeRef(ref.path, kbRoot);
+  const exists = existsSync2(abs);
+  const decided = exists && hasDecision(abs);
+  const status = ref.status ?? "open";
+  return {
+    id: ownerId,
+    path: ref.path,
+    abs,
+    exists,
+    decided,
+    status,
+    reason: ref.reason,
+    title: exists ? readTitle(abs) : void 0,
+    resolvable: decided && status !== "resolved"
+  };
+}
+
+// src/index/db.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var getBuiltinModule = globalThis.process.getBuiltinModule;
+var { DatabaseSync } = getBuiltinModule("node:sqlite");
+var PlanningIndex = class {
+  db;
+  fts;
+  store;
+  constructor(store, dbPath = ":memory:") {
+    this.store = store;
+    if (dbPath !== ":memory:") mkdirSync2(dirname2(dbPath), { recursive: true });
+    this.db = new DatabaseSync(dbPath);
+    this.fts = this.detectFts();
+    this.build();
+  }
+  detectFts() {
+    try {
+      this.db.exec("CREATE VIRTUAL TABLE __fts_probe USING fts5(x); DROP TABLE __fts_probe;");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  build() {
+    this.db.exec(`
+      DROP TABLE IF EXISTS objects;
+      DROP TABLE IF EXISTS edges;
+      DROP TABLE IF EXISTS objects_fts;
+      CREATE TABLE objects (
+        id TEXT PRIMARY KEY, type TEXT, title TEXT, status TEXT,
+        domain TEXT, project TEXT, path TEXT, updated TEXT,
+        priority TEXT, due TEXT, created TEXT, surfaced_on TEXT, context TEXT,
+        linked_sessions TEXT
+      );
+      CREATE TABLE edges (kind TEXT, from_id TEXT, to_id TEXT, reason TEXT, status TEXT);
+      CREATE INDEX idx_obj_type ON objects(type);
+      CREATE INDEX idx_obj_status ON objects(status);
+      CREATE INDEX idx_edge_kind ON edges(kind);
+    `);
+    if (this.fts) this.db.exec("CREATE VIRTUAL TABLE objects_fts USING fts5(id UNINDEXED, title, body);");
+    const insObj = this.db.prepare(
+      "INSERT OR REPLACE INTO objects (id,type,title,status,domain,project,path,updated,priority,due,created,surfaced_on,context,linked_sessions) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+    );
+    const insFts = this.fts ? this.db.prepare("INSERT INTO objects_fts (id,title,body) VALUES (?,?,?)") : null;
+    for (const d of this.store.all()) {
+      const o = d.object;
+      insObj.run(
+        d.id,
+        d.type,
+        o.title ?? null,
+        o.status ?? null,
+        o.domain ?? null,
+        o.project ?? null,
+        d.relpath,
+        o.updated ?? null,
+        o.priority ?? null,
+        o.due ?? null,
+        o.created ?? null,
+        o.surfaced_on ?? null,
+        o.context ?? null,
+        Array.isArray(o.linked_sessions) && o.linked_sessions.length ? JSON.stringify(o.linked_sessions) : null
+      );
+      insFts?.run(d.id, o.title ?? "", d.body ?? "");
+    }
+    const insEdge = this.db.prepare("INSERT INTO edges (kind,from_id,to_id,reason,status) VALUES (?,?,?,?,?)");
+    for (const e of this.store.allEdges()) insEdge.run(e.kind, e.from, e.to, e.reason ?? null, e.status ?? null);
+  }
+  close() {
+    this.db.close();
+  }
+  // --- Queries -------------------------------------------------------------
+  all() {
+    return this.db.prepare("SELECT * FROM objects ORDER BY type, id").all();
+  }
+  byType(type) {
+    return this.db.prepare("SELECT * FROM objects WHERE type = ? ORDER BY id").all(type);
+  }
+  listByStatus(status) {
+    return this.db.prepare("SELECT * FROM objects WHERE status = ? ORDER BY type, id").all(status);
+  }
+  counts() {
+    const rows = this.db.prepare("SELECT type, COUNT(*) n FROM objects GROUP BY type").all();
+    return Object.fromEntries(rows.map((r) => [r.type, r.n]));
+  }
+  /** All `blocked_by` knowledge edges, inspected against the KB for decision status. */
+  blockedByKnowledge(kbRoot) {
+    const out = [];
+    for (const d of this.store.all()) {
+      for (const ref of d.object.blocked_by ?? []) out.push(inspectKnowledgeRef(d.id, ref, kbRoot));
+    }
+    return out;
+  }
+  /** Tasks linked to a day, grouped by lane, plus the daily plan body. */
+  dailyBoard(date) {
+    const dailyId = `daily/${date}`;
+    const daily = this.store.get(dailyId);
+    const tasks = this.store.byType("task").filter((t) => {
+      const o = t.object;
+      return o.daily === dailyId || o.scheduled_for === dailyId;
+    }).map((t) => this.rowOf(t.id)).filter((r) => !!r);
+    const lanes = {};
+    for (const lane of TASK_STATUS) lanes[lane] = [];
+    for (const t of tasks) (lanes[t.status ?? "inbox"] ??= []).push(t);
+    return {
+      date,
+      daily_id: daily ? dailyId : null,
+      body: daily?.body ?? "",
+      lanes,
+      due_today: this.dueTasks(date, date),
+      overdue: this.dueTasks(null, date, true)
+    };
+  }
+  /** Open (not done/outdated) tasks with a due date in [from, to]; strict=true means due < to. */
+  dueTasks(from, to, strict = false) {
+    const cmp = strict ? "due < ?" : from ? "due >= ? AND due <= ?" : "due <= ?";
+    const params = strict ? [to] : from ? [from, to] : [to];
+    return this.db.prepare(
+      `SELECT * FROM objects WHERE type='task' AND due IS NOT NULL AND status NOT IN ('done','outdated') AND ${cmp} ORDER BY due, priority`
+    ).all(...params);
+  }
+  /** Tasks with due dates in a window, sorted by due then priority — the calendar view. */
+  calendar(from, to) {
+    return this.db.prepare(
+      "SELECT * FROM objects WHERE type='task' AND due IS NOT NULL AND due >= ? AND due <= ? ORDER BY due, priority, id"
+    ).all(from, to);
+  }
+  rowOf(id) {
+    return this.db.prepare("SELECT * FROM objects WHERE id = ?").get(id);
+  }
+  search(q) {
+    if (this.fts) {
+      try {
+        const ids = this.db.prepare("SELECT id FROM objects_fts WHERE objects_fts MATCH ? LIMIT 50").all(q);
+        if (ids.length === 0) return [];
+        const placeholders = ids.map(() => "?").join(",");
+        return this.db.prepare(`SELECT * FROM objects WHERE id IN (${placeholders})`).all(...ids.map((r) => r.id));
+      } catch {
+      }
+    }
+    const like = `%${q}%`;
+    return this.db.prepare("SELECT * FROM objects WHERE title LIKE ? OR id LIKE ? ORDER BY type, id LIMIT 50").all(like, like);
+  }
+};
+function persistIndex(store, dbPath) {
+  const idx = new PlanningIndex(store, dbPath);
+  const objects = store.all().length;
+  const edges = store.allEdges().length;
+  idx.close();
+  return { objects, edges };
+}
+
+// src/graph/graph.ts
+import { existsSync as existsSync3 } from "fs";
+function buildGraph(store, kbRoot) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const add = (n) => {
+    if (!nodes.has(n.id)) nodes.set(n.id, n);
+  };
+  for (const d of store.all()) {
+    const o = d.object;
+    add({
+      id: d.id,
+      label: o.title ?? d.id,
+      type: d.type,
+      group: o.domain ?? o.project ?? d.type,
+      status: o.status ?? void 0
+    });
+  }
+  for (const e of store.allEdges()) {
+    if (e.kind === "blocked_by" || e.kind === "cites" || e.kind === "implements") {
+      const abs = resolveKnowledgeRef(e.to, kbRoot);
+      const exists = existsSync3(abs);
+      add({
+        id: e.to,
+        label: (exists ? readTitle(abs) : void 0) ?? e.to.split("/").pop() ?? e.to,
+        type: "knowledge",
+        group: "knowledge",
+        blocked: e.kind === "blocked_by" && e.status !== "resolved"
+      });
+    }
+    if (e.kind === "evidence" && e.from.startsWith("session:")) {
+      add({ id: e.from, label: e.from.replace("session:", "").slice(0, 8), type: "session", group: "sessions" });
+    }
+    edges.push({ from: e.from, to: e.to, kind: e.kind, status: e.status });
+  }
+  return { nodes: [...nodes.values()], edges };
+}
+
+// src/migrate/gdoc.ts
+var DATE_HEADER = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat),?\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}(,\s+\d{4})?$/i;
+function nextContext(prev, headingText) {
+  const t = headingText.trim();
+  if (DATE_HEADER.test(t)) return t;
+  return prev ? `${prev} \u203A ${t}` : t;
+}
+function extractBullets(text) {
+  const out = [];
+  let context;
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (DATE_HEADER.test(t)) {
+      context = t;
+      continue;
+    }
+    const h = t.match(/^#{1,6}\s+(.+)$/);
+    if (h) {
+      context = nextContext(context, h[1]);
+      continue;
+    }
+    const m = line.match(/^(\s*)[-*+]\s+(\[([ xX])\]\s+)?(.+?)\s*$/);
+    if (!m) continue;
+    const indent = m[1].replace(/\t/g, "  ").length;
+    const checked = m[3] !== void 0 ? /[xX]/.test(m[3]) : void 0;
+    out.push({ text: m[4].trim(), checked, depth: Math.floor(indent / 2), context });
+  }
+  return out;
+}
+function extractProse(text, minLen = 60) {
+  const out = [];
+  let context;
+  let buf = [];
+  const flush = () => {
+    const t = buf.join(" ").replace(/\s+/g, " ").trim();
+    buf = [];
+    if (t.length >= minLen && !/^https?:\/\/\S+$/.test(t)) out.push({ text: t, context });
+  };
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (!t) {
+      flush();
+      continue;
+    }
+    if (DATE_HEADER.test(t)) {
+      flush();
+      context = t;
+      continue;
+    }
+    const h = t.match(/^#{1,6}\s+(.+)$/);
+    if (h) {
+      flush();
+      context = nextContext(context, h[1]);
+      continue;
+    }
+    if (/^(\s*)[-*+]\s+/.test(line) || /^\d+\.\s+/.test(t)) {
+      flush();
+      continue;
+    }
+    buf.push(t);
+  }
+  flush();
+  return out;
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[`*_~]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "item";
+}
+function toSeeds(bullets, opts = {}) {
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const b of bullets) {
+    if (!b.text || b.text.length < 3) continue;
+    const isTask = b.checked !== void 0;
+    const base = `${isTask ? "tasks" : "ideas"}/${slugify(b.text)}`;
+    let id = base;
+    let n = 2;
+    while (seen.has(id)) id = `${base}-${n++}`;
+    seen.add(id);
+    seeds.push({
+      id,
+      type: isTask ? "task" : "idea",
+      title: b.text,
+      status: isTask ? b.checked ? "done" : "inbox" : "capture",
+      domain: opts.domain,
+      source: opts.source,
+      context: b.context
+    });
+  }
+  return seeds;
+}
+
+// src/cli/sessions.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function findSessionEnvelope(sessionsRoot, uuid) {
+  const hostsDir = join3(sessionsRoot, "hosts");
+  if (!existsSync4(hostsDir)) return void 0;
+  for (const host of safeDirs(hostsDir)) {
+    const hostDir = join3(hostsDir, host);
+    for (const month of safeDirs(hostDir)) {
+      const candidate = join3(hostDir, month, uuid, "session.json");
+      if (existsSync4(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+function safeDirs(dir) {
+  try {
+    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function addPlanningRef(envelopePath, planningId) {
+  const env = JSON.parse(readFileSync3(envelopePath, "utf8"));
+  const refs = new Set(env.planning_refs ?? []);
+  if (refs.has(planningId)) return false;
+  refs.add(planningId);
+  env.planning_refs = [...refs];
+  writeFileSync2(envelopePath, JSON.stringify(env, null, 2) + "\n", "utf8");
+  return true;
+}
+
+// src/sessions/reader.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function sessionsGitRoot() {
+  return process.env.CODE_SESSIONS_STORE || path.join(os.homedir(), ".sessions");
+}
+function nativeClaudeRoot() {
+  return process.env.CODE_SESSIONS_NATIVE_ROOT || path.join(os.homedir(), ".claude", "projects");
+}
+var localDay = (iso, fallbackMs) => {
+  const d = iso ? new Date(iso) : fallbackMs ? new Date(fallbackMs) : void 0;
+  if (!d || isNaN(d.getTime())) return "";
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${dd}`;
+};
+function cleanTitle(raw) {
+  return raw.replace(/<command-[^>]*>[\s\S]*?<\/command-[^>]*>/g, " ").replace(/<local-command-[^>]*>[\s\S]*?(<\/local-command-[^>]*>|$)/g, " ").replace(/<system-reminder>[\s\S]*?(<\/system-reminder>|$)/g, " ").replace(/<[^>\n]{1,40}>/g, " ").replace(/\s+/g, " ").trim().slice(0, 140);
+}
+function readGitStoreSessions(root = sessionsGitRoot()) {
+  const out = [];
+  const hostsDir = path.join(root, "hosts");
+  let hosts = [];
+  try {
+    hosts = fs.readdirSync(hostsDir);
+  } catch {
+    return out;
+  }
+  for (const host of hosts) {
+    let months = [];
+    try {
+      months = fs.readdirSync(path.join(hostsDir, host));
+    } catch {
+      continue;
+    }
+    for (const month of months) {
+      const monthDir = path.join(hostsDir, host, month);
+      let ids = [];
+      try {
+        ids = fs.readdirSync(monthDir);
+      } catch {
+        continue;
+      }
+      for (const id of ids) {
+        const f = path.join(monthDir, id, "session.json");
+        try {
+          const d = JSON.parse(fs.readFileSync(f, "utf8"));
+          const started = d.started_at;
+          const ended = d.ended_at;
+          const labels = d.labels ?? [];
+          const excerpt = labels.find((l) => !l.startsWith("intent:"));
+          const projectPath = d.project_path || void 0;
+          out.push({
+            id: d.session_id || id,
+            day: localDay(started),
+            started_at: started,
+            ended_at: ended,
+            minutes: started && ended ? Math.max(0, Math.round((+new Date(ended) - +new Date(started)) / 6e4)) : void 0,
+            agent: d.agent || "unknown",
+            host: d.host,
+            project_path: projectPath,
+            project_name: projectPath ? path.basename(projectPath) : void 0,
+            title: excerpt ? cleanTitle(excerpt) : void 0,
+            turns: d.turn_count,
+            source: "git"
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function decodeNativeDir(name) {
+  return name.replace(/^-/, "/").replace(/-/g, "/");
+}
+function readNativeClaudeSessions(root = nativeClaudeRoot(), headBytes = 32 * 1024) {
+  const out = [];
+  let dirs = [];
+  try {
+    dirs = fs.readdirSync(root);
+  } catch {
+    return out;
+  }
+  for (const dir of dirs) {
+    const abs = path.join(root, dir);
+    let files = [];
+    try {
+      if (!fs.statSync(abs).isDirectory()) continue;
+      files = fs.readdirSync(abs).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const fp = path.join(abs, file);
+      try {
+        const stat = fs.statSync(fp);
+        if (stat.size === 0) continue;
+        const fd = fs.openSync(fp, "r");
+        const buf = Buffer.alloc(Math.min(headBytes, stat.size));
+        fs.readSync(fd, buf, 0, buf.length, 0);
+        fs.closeSync(fd);
+        const headLines = buf.toString("utf8").split("\n");
+        let title;
+        let firstTs;
+        for (const line of headLines) {
+          if (!line.trim()) continue;
+          let obj;
+          try {
+            obj = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (!firstTs && typeof obj.timestamp === "string") firstTs = obj.timestamp;
+          if (!title && obj.type === "summary" && typeof obj.summary === "string") {
+            title = cleanTitle(obj.summary);
+          }
+          if (!title && obj.type === "user") {
+            const msg = obj.message;
+            const content = msg?.content;
+            let text = "";
+            if (typeof content === "string") text = content;
+            else if (Array.isArray(content)) {
+              const t = content.find((c) => c.type === "text");
+              text = t?.text ?? "";
+            }
+            const cleaned = cleanTitle(text);
+            if (cleaned) title = cleaned;
+          }
+          if (title && firstTs) break;
+        }
+        const projectPath = decodeNativeDir(dir);
+        out.push({
+          id: path.basename(file, ".jsonl"),
+          day: localDay(firstTs, stat.mtimeMs),
+          started_at: firstTs,
+          ended_at: new Date(stat.mtimeMs).toISOString(),
+          minutes: firstTs ? Math.max(0, Math.round((stat.mtimeMs - +new Date(firstTs)) / 6e4)) : void 0,
+          agent: "claude-code",
+          project_path: projectPath,
+          project_name: path.basename(projectPath),
+          title,
+          source: "native"
+        });
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function readAllSessions() {
+  const byId = /* @__PURE__ */ new Map();
+  for (const s of readGitStoreSessions()) byId.set(s.id, s);
+  for (const s of readNativeClaudeSessions()) {
+    const prev = byId.get(s.id);
+    if (prev) {
+      byId.set(s.id, {
+        ...prev,
+        ...s,
+        title: s.title || prev.title,
+        host: prev.host,
+        turns: prev.turns ?? s.turns,
+        source: "both"
+      });
+    } else {
+      byId.set(s.id, s);
+    }
+  }
+  return [...byId.values()].filter((s) => s.day).sort((a, b) => (a.started_at ?? "").localeCompare(b.started_at ?? ""));
+}
+function sessionsByDay(sessions, from, to) {
+  const days = {};
+  for (const s of sessions) {
+    if (s.day < from || s.day > to) continue;
+    (days[s.day] ??= []).push(s);
+  }
+  return days;
+}
+
+// src/cli/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  CLOSING_STATUSES: () => CLOSING_STATUSES,
+  DEFAULT_GROUPS: () => DEFAULT_GROUPS,
+  buildLookback: () => buildLookback,
+  buildTopics: () => buildTopics,
+  cmdBlocked: () => cmdBlocked,
+  cmdCalendar: () => cmdCalendar,
+  cmdCapture: () => cmdCapture,
+  cmdCreate: () => cmdCreate,
+  cmdDaily: () => cmdDaily,
+  cmdDelete: () => cmdDelete,
+  cmdDeriveProjects: () => cmdDeriveProjects,
+  cmdDeriveSessions: () => cmdDeriveSessions,
+  cmdDoctor: () => cmdDoctor,
+  cmdEdit: () => cmdEdit,
+  cmdEditObject: () => cmdEditObject,
+  cmdExport: () => cmdExport,
+  cmdGraph: () => cmdGraph,
+  cmdIngestGdoc: () => cmdIngestGdoc,
+  cmdIngestThoughts: () => cmdIngestThoughts,
+  cmdInsightIngest: () => cmdInsightIngest,
+  cmdLabelSessions: () => cmdLabelSessions,
+  cmdLinkSession: () => cmdLinkSession,
+  cmdList: () => cmdList,
+  cmdLookback: () => cmdLookback,
+  cmdPromote: () => cmdPromote,
+  cmdRecategorize: () => cmdRecategorize,
+  cmdReindex: () => cmdReindex,
+  cmdResearch: () => cmdResearch,
+  cmdSetDue: () => cmdSetDue,
+  cmdSetPriority: () => cmdSetPriority,
+  cmdSetProject: () => cmdSetProject,
+  cmdSetStatus: () => cmdSetStatus,
+  cmdShow: () => cmdShow,
+  domainGroups: () => domainGroups,
+  inferProjectFromText: () => inferProjectFromText,
+  projectDomainMap: () => projectDomainMap,
+  projectIdFromPath: () => projectIdFromPath,
+  resolveProjectId: () => resolveProjectId,
+  today: () => today
+});
+import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+function cmdList(store, opts) {
+  let rows = store.all();
+  if (opts.type) rows = rows.filter((d) => d.type === opts.type);
+  if (opts.status) rows = rows.filter((d) => d.object.status === opts.status);
+  if (opts.project) {
+    const want = resolveProjectId(store, opts.project);
+    if (!want) return `(unknown project filter: ${opts.project})`;
+    rows = rows.filter((d) => d.object.project === want);
+  }
+  if (rows.length === 0) return "(no matching objects)";
+  return rows.sort((a, b) => a.type.localeCompare(b.type) || a.id.localeCompare(b.id)).map((d) => {
+    const o = d.object;
+    const proj = o.project ? o.project.replace(/^projects\//, "") : null;
+    const extras = [o.priority, o.due ? `due:${o.due}` : null, proj ? `proj:${proj}` : null].filter(Boolean).join(" ");
+    return `${pad(d.type, 12)} ${pad(o.status ?? "-", 10)} ${pad(extras, 18)} ${d.id}${o.title ? `  \u2014 ${o.title}` : ""}`;
+  }).join("\n");
+}
+function cmdDaily(store, idx, date, carryOver) {
+  const board = idx.dailyBoard(date);
+  const lines = [`# Daily \u2014 ${date}`];
+  if (!board.daily_id) lines.push(`(no daily plan file at daily/${date}; run /planning-daily or 'kp capture')`);
+  if (board.body.trim()) lines.push("", board.body.trim());
+  if (board.overdue.length) {
+    lines.push("", "## \u26A0 Overdue");
+    for (const r of board.overdue) lines.push(`    - ${r.title ?? r.id}  (due ${r.due}${r.priority ? `, ${r.priority}` : ""})  (${r.id})`);
+  }
+  if (board.due_today.length) {
+    lines.push("", "## Due today (must-have)");
+    for (const r of board.due_today) lines.push(`    - ${r.title ?? r.id}${r.priority ? `  [${r.priority}]` : ""}  (${r.id})`);
+  }
+  lines.push("", "## Tasks by lane");
+  for (const [lane, rows] of Object.entries(board.lanes)) {
+    if (rows.length === 0) continue;
+    lines.push(`  ${lane}:`);
+    for (const r of rows) lines.push(`    - [${r.status === "done" ? "x" : " "}] ${r.title ?? r.id}  (${r.id})`);
+  }
+  if (carryOver) {
+    const prev = previousDay(date);
+    const prevBoard = idx.dailyBoard(prev);
+    const unfinished = [...prevBoard.lanes.today, ...prevBoard.lanes.in_progress, ...prevBoard.lanes.inbox];
+    if (unfinished.length) {
+      lines.push("", `## Carry-over from ${prev}`);
+      for (const r of unfinished) lines.push(`    - ${r.title ?? r.id}  (${r.id})`);
+    }
+  }
+  return lines.join("\n");
+}
+function cmdBlocked(idx, kbRoot) {
+  const blocked = idx.blockedByKnowledge(kbRoot).filter((b) => b.status !== "resolved");
+  if (blocked.length === 0) return "(nothing blocked by knowledge)";
+  return blocked.map((b) => {
+    const flag = !b.exists ? "MISSING" : b.resolvable ? "RESOLVABLE (decision recorded)" : "open";
+    return `${flag.padEnd(30)} ${b.id}
+    \u2192 ${b.path}${b.reason ? `
+    reason: ${b.reason}` : ""}`;
+  }).join("\n");
+}
+function cmdGraph(store, kbRoot, json) {
+  const g = buildGraph(store, kbRoot);
+  if (json) return JSON.stringify(g, null, 2);
+  return `graph: ${g.nodes.length} nodes, ${g.edges.length} edges
+  by type: ${countBy(g.nodes.map((n) => n.type))}`;
+}
+function cmdReindex(store, root) {
+  const res = persistIndex(store, join5(root, ".index/planning.db"));
+  const warnings = store.getWarnings();
+  return `reindexed \u2192 ${join5(root, ".index/planning.db")}
+  ${res.objects} objects, ${res.edges} edges${warnings.length ? `
+  ${warnings.length} warning(s):
+    ${warnings.join("\n    ")}` : ""}`;
+}
+function cmdCapture(store, text, domain) {
+  const id = uniqueId(store, `ideas/${slugify(text)}`);
+  store.write({ id, type: "idea", title: text, status: "capture", domain, created: today() });
+  return { id };
+}
+function cmdPromote(store, ideaId, toId) {
+  const idea = store.get(ideaId);
+  if (!idea || idea.type !== "idea") throw new Error(`not an idea: ${ideaId}`);
+  const o = idea.object;
+  const planId = toId ?? uniqueId(store, `plans/${ideaId.split("/").pop()}`);
+  const isLife = o.domain && o.domain !== "tech";
+  store.write(
+    {
+      id: planId,
+      type: "plan",
+      title: o.title ?? planId,
+      status: "plan",
+      kind: isLife ? "life" : "dev",
+      domain: o.domain,
+      project: o.project,
+      promoted_from: ideaId,
+      blocked_by: o.blocked_by ?? [],
+      cites: o.cites ?? [],
+      created: today()
+    },
+    `# ${o.title ?? planId}
+
+## Goal
+
+_(promoted from [[${ideaId}]])_
+
+## Steps
+
+- [ ] \u2026
+`
+  );
+  store.patch(ideaId, (d) => {
+    d.status = "done";
+    d.promoted_to = planId;
+  });
+  store.appendEdge({ kind: "promoted_to", from: ideaId, to: planId, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  return { ideaId, planId };
+}
+function cmdLinkSession(store, sessionsRoot, objectId, uuid) {
+  const obj = store.get(objectId);
+  if (!obj) throw new Error(`object not found: ${objectId}`);
+  store.patch(objectId, (d) => {
+    const refs = new Set(d.linked_sessions ?? []);
+    refs.add(uuid);
+    d.linked_sessions = [...refs];
+  });
+  store.appendEdge({ kind: "evidence", from: `session:${uuid}`, to: objectId, created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  const envelopePath = findSessionEnvelope(sessionsRoot, uuid);
+  let envelopeUpdated = false;
+  if (envelopePath) envelopeUpdated = addPlanningRef(envelopePath, objectId);
+  return { objectId, uuid, envelopeUpdated, envelopePath };
+}
+function cmdInsightIngest(store, text, source, sourceRef) {
+  const bullets = extractBullets(text).filter((b) => b.text.length > 3);
+  const date = today();
+  const id = uniqueId(store, `insights/${date}-${slugify(source)}`);
+  const suggested = bullets.map((b) => b.text);
+  store.write(
+    {
+      id,
+      type: "insight",
+      title: `${source} \u2014 ${date}`,
+      source,
+      source_ref: sourceRef,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "new"
+    },
+    `# ${source} \u2014 ${date}
+
+## Suggested
+
+${suggested.map((s) => `- [ ] ${s}`).join("\n")}
+`
+  );
+  return { id, suggested: suggested.length };
+}
+function cmdShow(store, kbRoot, id) {
+  const doc = store.get(id);
+  if (!doc) throw new Error(`object not found: ${id}`);
+  const o = doc.object;
+  const all = store.all();
+  const ref = (oid) => {
+    const d = store.get(oid);
+    return d ? { id: d.id, type: d.type, title: d.object.title ?? d.id, status: d.object.status } : { id: oid, missing: true };
+  };
+  const cites = (o.cites ?? []).map((p) => {
+    const abs = resolveKnowledgeRef(p, kbRoot);
+    return { path: p, exists: existsSync5(abs), title: existsSync5(abs) ? readTitle(abs) : void 0 };
+  });
+  const blocked_by = (doc.object.blocked_by ?? []).map((r) => inspectKnowledgeRef(id, r, kbRoot));
+  const children = all.filter((d) => {
+    const c = d.object;
+    return d.id !== id && (c.project === id || c.plan === id || c.daily === id);
+  }).map((d) => ref(d.id));
+  const parentId = o.plan || o.project || void 0;
+  return {
+    id: doc.id,
+    type: doc.type,
+    relpath: doc.relpath,
+    path: doc.path,
+    frontmatter: o,
+    title: o.title ?? doc.id,
+    status: o.status,
+    domain: o.domain,
+    body: doc.body,
+    cites,
+    blocked_by,
+    depends_on: (o.depends_on ?? []).map(ref),
+    related: (o.related ?? []).map(ref),
+    linked_sessions: o.linked_sessions ?? [],
+    parent: parentId ? ref(parentId) : null,
+    children,
+    promoted_to: o.promoted_to ? ref(o.promoted_to) : null,
+    promoted_from: o.promoted_from ? ref(o.promoted_from) : null
+  };
+}
+function cmdExport(store, idx, config, date) {
+  return {
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    root: store.root,
+    kb_root: config.kb_root,
+    sessions_root: config.sessions_root,
+    counts: idx.counts(),
+    objects: idx.all(),
+    inbox: idx.listByStatus("capture"),
+    board: idx.dailyBoard(date),
+    blocked: idx.blockedByKnowledge(config.kb_root).filter((b) => b.status !== "resolved"),
+    graph: buildGraph(store, config.kb_root)
+  };
+}
+function cmdCalendar(idx, from, to) {
+  const rows = idx.calendar(from, to);
+  if (rows.length === 0) return `(no tasks due between ${from} and ${to})`;
+  const lines = [`# Calendar ${from} \u2192 ${to}`];
+  let day = "";
+  const now = today();
+  for (const r of rows) {
+    if (r.due !== day) {
+      day = r.due;
+      const marker = day < now ? " \u26A0 overdue" : day === now ? " \u2190 today" : "";
+      lines.push("", `## ${day}${marker}`);
+    }
+    const doneMark = r.status === "done" ? "x" : r.status === "outdated" ? "~" : " ";
+    lines.push(`  - [${doneMark}] ${r.title ?? r.id}${r.priority ? `  [${r.priority}]` : ""}  (${r.status}) (${r.id})`);
+  }
+  return lines.join("\n");
+}
+function cmdSetDue(store, id, due) {
+  if (!store.get(id)) throw new Error(`object not found: ${id}`);
+  if (due !== "-" && !/^\d{4}-\d{2}-\d{2}$/.test(due)) throw new Error(`due must be YYYY-MM-DD or '-' to clear: ${due}`);
+  store.patch(id, (d) => {
+    if (due === "-") delete d.due;
+    else d.due = due;
+    d.updated = today();
+  });
+}
+function cmdSetPriority(store, id, priority) {
+  if (!store.get(id)) throw new Error(`object not found: ${id}`);
+  if (priority !== "-" && !/^p[0-3]$/.test(priority)) throw new Error(`priority must be p0..p3 or '-' to clear: ${priority}`);
+  store.patch(id, (d) => {
+    if (priority === "-") delete d.priority;
+    else d.priority = priority;
+    d.updated = today();
+  });
+}
+function cmdSetStatus(store, id, status, note) {
+  if (!store.get(id)) throw new Error(`object not found: ${id}`);
+  store.patch(id, (d) => {
+    d.status = status;
+    d.updated = today();
+  });
+  const text = note?.trim();
+  if (text) {
+    const doc = store.get(id);
+    const base = (doc.body ?? "").replace(/\s+$/, "");
+    const body = `${base ? base + "\n\n" : ""}## Resolution (${status} \u2014 ${today()})
+
+${text}
+`;
+    store.write(doc.data, body);
+  }
+}
+var CLOSING_STATUSES = ["done", "deferred", "outdated", "parked", "archived"];
+function resolveProjectId(store, ref) {
+  if (ref === void 0 || ref === null || ref === "" || ref === "-") return null;
+  const raw = ref.trim();
+  if (!raw) return null;
+  if (store.get(raw)?.type === "project") return raw;
+  const asId = raw.startsWith("projects/") ? raw : `projects/${raw}`;
+  if (store.get(asId)?.type === "project") return asId;
+  const needle = raw.toLowerCase().replace(/^projects\//, "");
+  for (const d of store.byType("project")) {
+    const o = d.object;
+    const slug = (o.catalog_slug ?? d.id.replace(/^projects\//, "")).toLowerCase();
+    if (slug === needle || d.id.replace(/^projects\//, "").toLowerCase() === needle) return d.id;
+    const aliases = (o.aliases ?? []).map((a) => String(a).toLowerCase());
+    if (aliases.includes(needle) || aliases.includes(raw.toLowerCase())) return d.id;
+    if ((o.title ?? "").toLowerCase() === needle) return d.id;
+  }
+  throw new Error(`unknown project: ${ref} (use projects/<slug>, catalog slug, or alias like CS/CSV/CB/KP)`);
+}
+function cmdSetProject(store, id, project) {
+  if (!store.get(id)) throw new Error(`object not found: ${id}`);
+  const resolved = project === "-" || project === "" ? null : resolveProjectId(store, project);
+  store.patch(id, (d) => {
+    if (!resolved) delete d.project;
+    else d.project = resolved;
+    d.updated = today();
+  });
+}
+function cmdEdit(store, id, edits) {
+  const existing = store.get(id);
+  if (!existing) throw new Error(`object not found: ${id}`);
+  const data = { ...existing.data };
+  if (edits.title !== void 0) data.title = edits.title;
+  if (edits.status !== void 0) data.status = edits.status;
+  if (edits.domain !== void 0) data.domain = edits.domain;
+  if (edits.lane !== void 0) data.lane = edits.lane;
+  if (edits.project !== void 0) {
+    const resolved = resolveProjectId(store, edits.project);
+    if (!resolved) delete data.project;
+    else data.project = resolved;
+  }
+  data.updated = today();
+  store.write(data, edits.body ?? existing.body);
+}
+var TYPE_DEFAULT_STATUS = { idea: "capture", task: "inbox", plan: "plan", project: "active", thought: "new" };
+function cmdRecategorize(store, id, opts) {
+  const existing = store.get(id);
+  if (!existing) throw new Error(`object not found: ${id}`);
+  if (!opts.toType || opts.toType === existing.type) {
+    store.patch(id, (d) => {
+      if (opts.domain !== void 0) d.domain = opts.domain;
+      if (opts.lane !== void 0) d.lane = opts.lane;
+      d.updated = today();
+    });
+    return { newId: id };
+  }
+  const slug = id.split("/").slice(1).join("/");
+  const newId = `${opts.toType}s/${slug}`;
+  const data = { ...existing.data };
+  delete data.schema;
+  data.id = newId;
+  data.type = opts.toType;
+  data.status = TYPE_DEFAULT_STATUS[opts.toType] ?? "inbox";
+  data.recategorized_from = id;
+  if (opts.domain !== void 0) data.domain = opts.domain;
+  if (opts.lane !== void 0) data.lane = opts.lane;
+  data.updated = today();
+  store.write(data, existing.body);
+  store.delete(id);
+  rewriteRefs(store, id, newId);
+  return { newId };
+}
+function rewriteRefs(store, fromId, toId) {
+  for (const doc of store.all()) {
+    let changed = false;
+    const d = { ...doc.data };
+    if (d.parent === fromId) {
+      d.parent = toId;
+      changed = true;
+    }
+    for (const key of ["cites", "blocked_by"]) {
+      const arr = d[key];
+      if (Array.isArray(arr)) {
+        const next = arr.map((r) => typeof r === "string" && r === fromId ? toId : r);
+        if (JSON.stringify(next) !== JSON.stringify(arr)) {
+          d[key] = next;
+          changed = true;
+        }
+      }
+    }
+    if (changed) store.write(d, doc.body);
+  }
+  for (const e of store.fileEdges()) {
+    if (e.from === fromId || e.to === fromId) {
+      store.appendEdge({ ...e, from: e.from === fromId ? toId : e.from, to: e.to === fromId ? toId : e.to });
+    }
+  }
+}
+function cmdDelete(store, id) {
+  if (!store.get(id)) throw new Error(`object not found: ${id}`);
+  return store.delete(id);
+}
+function cmdResearch(store, kbRoot, id) {
+  const doc = store.get(id);
+  if (!doc) throw new Error(`object not found: ${id}`);
+  const o = doc.object;
+  const refs = [
+    ...o.cites ?? [],
+    ...o.kb_paths ?? []
+  ];
+  return [
+    `Research this planning item against the knowledge base, then connect it.`,
+    ``,
+    `Item: ${o.title} (${id}, type ${doc.type}, domain ${o.domain ?? "\u2014"})`,
+    doc.body.trim() ? `
+${doc.body.trim()}
+` : "",
+    `Knowledge base root: ${kbRoot}`,
+    refs.length ? `Already-linked knowledge: ${refs.join(", ")}` : "",
+    ``,
+    `Run the **planning-research** skill: search the KB for related docs and prior art,`,
+    `add cites to the relevant ones, append a research summary to this item, flag any`,
+    `blocked_by open questions, suggest a refinement (or promote-to-task), and finally`,
+    `link this session to the item: \`kp link-session ${id} <this-session-uuid>\`.`
+  ].filter((l) => l !== "").join("\n");
+}
+function cmdIngestGdoc(store, text, opts = {}) {
+  const minLen = opts.minLen ?? 12;
+  const max = opts.max ?? 25;
+  const source = opts.source ?? "gdoc";
+  if (opts.prevText == null) {
+    return { created: [], skipped: 0, newBullets: 0, baselined: true, capped: 0 };
+  }
+  const prevSet = new Set(extractBullets(opts.prevText).map((b) => b.text));
+  const fresh = extractBullets(text).filter((b) => b.text.length >= minLen && b.depth <= 2 && !prevSet.has(b.text));
+  const CLUSTER_MIN = 5;
+  const isTodoCtx = (b) => /\btodo\b/i.test(b.context ?? "");
+  const taskish = fresh.filter((b) => b.checked !== void 0 || isTodoCtx(b));
+  const plain = fresh.filter((b) => b.checked === void 0 && !isTodoCtx(b));
+  const byCtx = /* @__PURE__ */ new Map();
+  for (const b of plain) {
+    const k = b.context ?? "";
+    if (!byCtx.has(k)) byCtx.set(k, []);
+    byCtx.get(k).push(b);
+  }
+  const loose = [];
+  const clusters = [];
+  for (const [ctx, bs] of byCtx) {
+    if (ctx && bs.length >= CLUSTER_MIN) clusters.push({ context: ctx, bullets: bs });
+    else loose.push(...bs);
+  }
+  const seedInput = [...taskish.map((b) => ({ ...b, checked: b.checked ?? false })), ...loose];
+  const seeds = toSeeds(seedInput.slice(0, max), { domain: opts.domain, source });
+  const created = [];
+  let skipped = 0;
+  for (const seed of seeds) {
+    if (store.get(seed.id)) {
+      skipped++;
+      continue;
+    }
+    store.write(
+      {
+        id: seed.id,
+        type: seed.type,
+        title: seed.title,
+        status: seed.status,
+        domain: seed.domain,
+        source: seed.source,
+        source_url: opts.sourceUrl,
+        context: seed.context,
+        surfaced_on: today(),
+        created: today()
+      },
+      seed.title
+    );
+    created.push(seed.id);
+  }
+  const clips = [];
+  for (const c of clusters) {
+    const body = c.bullets.map((b) => `- ${b.text}`).join("\n");
+    const bodyKey = body.replace(/\s+/g, " ").trim();
+    const dup = store.all().some((d) => d.type === "thought" && d.body.replace(/\s+/g, " ").trim() === bodyKey);
+    if (dup) {
+      skipped++;
+      continue;
+    }
+    const id = uniqueId(store, `thoughts/${slugify(c.context)}-notes`);
+    store.write(
+      {
+        id,
+        type: "thought",
+        title: `${c.context} \u2014 pasted notes (${c.bullets.length})`,
+        status: "new",
+        kind: "clip",
+        source,
+        source_url: opts.sourceUrl,
+        context: c.context,
+        surfaced_on: today(),
+        created: today()
+      },
+      body
+    );
+    created.push(id);
+    clips.push({ context: c.context, count: c.bullets.length });
+  }
+  return {
+    created,
+    skipped,
+    newBullets: fresh.length,
+    baselined: false,
+    capped: Math.max(0, seedInput.length - Math.min(seedInput.length, max)),
+    clips
+  };
+}
+function cmdIngestThoughts(store, text, opts = {}) {
+  const minLen = opts.minLen ?? 60;
+  const max = opts.max ?? 20;
+  const source = opts.source ?? "gdoc";
+  if (opts.prevText == null) {
+    return { created: [], skipped: 0, newBlocks: 0, baselined: true, capped: 0 };
+  }
+  const prevSet = new Set(extractProse(opts.prevText, minLen).map((b) => b.text));
+  const existingBodies = new Set(
+    store.all().filter((d) => d.type === "thought").map((d) => d.body.replace(/\s+/g, " ").trim())
+  );
+  const fresh = extractProse(text, minLen).filter((b) => !prevSet.has(b.text) && !existingBodies.has(b.text));
+  const take = fresh.slice(0, max);
+  const created = [];
+  let skipped = 0;
+  for (const block of take) {
+    const id = uniqueId(store, `thoughts/${slugify(block.text)}`);
+    if (store.get(id)) {
+      skipped++;
+      continue;
+    }
+    const title = block.text.length > 90 ? block.text.slice(0, 87).trimEnd() + "\u2026" : block.text;
+    store.write(
+      {
+        id,
+        type: "thought",
+        title,
+        status: "new",
+        source,
+        source_url: opts.sourceUrl,
+        context: block.context,
+        surfaced_on: today(),
+        created: today()
+      },
+      block.text
+    );
+    created.push(id);
+  }
+  return { created, skipped, newBlocks: fresh.length, baselined: false, capped: Math.max(0, fresh.length - take.length) };
+}
+function cmdDoctor(store, idx, config) {
+  const counts = idx.counts();
+  const blocked = idx.blockedByKnowledge(config.kb_root).filter((b) => b.status !== "resolved");
+  const warnings = store.getWarnings();
+  return [
+    `store root: ${store.root}`,
+    `kb_root:    ${config.kb_root}`,
+    `sessions:   ${config.sessions_root}`,
+    `objects:    ${Object.entries(counts).map(([k, v]) => `${k}=${v}`).join(" ") || "(none)"}`,
+    `fts5:       ${idx.fts ? "yes" : "no (LIKE fallback)"}`,
+    `blocked:    ${blocked.length} (${blocked.filter((b) => b.resolvable).length} resolvable, ${blocked.filter((b) => !b.exists).length} missing)`,
+    `warnings:   ${warnings.length}${warnings.length ? "\n  " + warnings.join("\n  ") : ""}`
+  ].join("\n");
+}
+function pad(s, n) {
+  return (s ?? "").padEnd(n).slice(0, n);
+}
+function countBy(items) {
+  const m = {};
+  for (const i of items) m[i] = (m[i] ?? 0) + 1;
+  return Object.entries(m).map(([k, v]) => `${k}=${v}`).join(" ");
+}
+function uniqueId(store, base) {
+  if (!store.get(base)) return base;
+  let n = 2;
+  while (store.get(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+function previousDay(date) {
+  const d = /* @__PURE__ */ new Date(date + "T00:00:00Z");
+  d.setUTCDate(d.getUTCDate() - 1);
+  return d.toISOString().slice(0, 10);
+}
+var DEFAULT_GROUPS = {
+  work: ["career", "tech"],
+  life: ["kids", "relationship", "finances", "relocation"]
+};
+function domainGroups(config) {
+  const custom = config.groups;
+  return custom && Object.keys(custom).length ? custom : DEFAULT_GROUPS;
+}
+function groupOfDomain(groups, domain) {
+  if (!domain) return "other";
+  for (const [g, domains] of Object.entries(groups)) if (domains.includes(domain)) return g;
+  return "other";
+}
+function projectDomainMap(store) {
+  const map = {};
+  for (const d of store.byType("project")) {
+    const o = d.object;
+    const domain = o.domain ?? "tech";
+    const base = d.id.split("/").pop();
+    if (base) map[base] = domain;
+    for (const repo of o.repos ?? []) {
+      const name = repo.split("/").pop()?.replace(/\.git$/, "");
+      if (name) map[name] = domain;
+    }
+  }
+  return map;
+}
+function buildTopics(store, config) {
+  const groups = domainGroups(config);
+  const projDomain = projectDomainMap(store);
+  const sessions = readAllSessions();
+  const recentCutoff = (() => {
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() - 30);
+    return d.toISOString().slice(0, 10);
+  })();
+  const domains = {};
+  const ensure = (domain) => {
+    const g = groupOfDomain(groups, domain);
+    return domains[domain] ??= { group: g, tasks: [], ideas: [], sessions: [] };
+  };
+  for (const d of store.byType("task")) {
+    const o = d.object;
+    if (o.status === "done" || o.status === "outdated") continue;
+    ensure(o.domain ?? "other").tasks.push({ id: d.id, title: o.title, status: o.status, priority: o.priority, due: o.due });
+  }
+  for (const d of store.byType("idea")) {
+    const o = d.object;
+    if (o.status === "done" || o.status === "parked") continue;
+    ensure(o.domain ?? "other").ideas.push({ id: d.id, title: o.title, status: o.status });
+  }
+  for (const s of sessions) {
+    if (s.day < recentCutoff) continue;
+    const domain = s.project_name && projDomain[s.project_name] || void 0;
+    ensure(domain ?? "unmapped").sessions.push(s);
+  }
+  for (const d of Object.values(domains)) d.sessions = d.sessions.slice(-12).reverse();
+  const grouped = {};
+  for (const [domain, data] of Object.entries(domains)) {
+    (grouped[data.group] ??= {})[domain] = data;
+  }
+  return { groups: grouped, group_config: groups };
+}
+function buildLookback(store, date) {
+  const sessions = sessionsByDay(readAllSessions(), date, date)[date] ?? [];
+  const worked = [];
+  const created = [];
+  const touched = [];
+  const due = [];
+  const NOISY_STATUS = /* @__PURE__ */ new Set(["parked", "archived", "outdated"]);
+  for (const d of store.all()) {
+    const o = d.object;
+    const item = { id: d.id, type: d.type, title: o.title, status: o.status, priority: o.priority };
+    const noisy = NOISY_STATUS.has(o.status ?? "");
+    let hit = false;
+    if (o.updated === date && !noisy && d.type !== "thought") {
+      worked.push(item);
+      hit = true;
+    }
+    if ((o.created === date || o.surfaced_on === date) && !noisy) {
+      created.push(item);
+      hit = true;
+    }
+    if (hit) touched.push(item);
+    if (o.due === date) due.push({ ...item });
+  }
+  const daily = store.get(`daily/${date}`);
+  return {
+    date,
+    sessions,
+    tasks_worked: worked,
+    tasks_created: created,
+    tasks_touched: touched,
+    tasks_due: due,
+    daily_plan: daily ? { id: daily.id, body: daily.body ?? "" } : null
+  };
+}
+function cmdLookback(store, date) {
+  const lb = buildLookback(store, date);
+  const lines = [`# Lookback \u2014 ${date}`];
+  if (lb.daily_plan?.body?.trim()) lines.push("", "## Plan of the day", lb.daily_plan.body.trim().split("\n").slice(0, 12).join("\n"));
+  lines.push("", `## Sessions (${lb.sessions.length})`);
+  if (!lb.sessions.length) lines.push("  (none captured)");
+  for (const s of lb.sessions) {
+    const t = s.started_at ? new Date(s.started_at).toTimeString().slice(0, 5) : "--:--";
+    lines.push(`  ${t}  [${s.project_name ?? "?"}] ${s.title ?? "(untitled)"}${s.minutes ? `  (${s.minutes}m)` : ""}`);
+  }
+  if (lb.tasks_due.length) {
+    lines.push("", "## Was due");
+    for (const t of lb.tasks_due) lines.push(`  - ${t.title ?? t.id}  (${t.status})`);
+  }
+  if (lb.tasks_worked.length) {
+    lines.push("", "## Worked on (updated)");
+    for (const t of lb.tasks_worked) lines.push(`  - ${t.title ?? t.id}  (${t.status})`);
+  }
+  return lines.join("\n");
+}
+var STOPWORDS = new Set("the a an and or of to in on for with from is are was were be this that it as at by i my we our you your do done did not no yes if then else new next now need needs use using used into over under fix fixed add added run running make let get got set see look review update updated create created check test tests please help want".split(" "));
+function titleKeywords(titles, top = 5) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const t of titles) {
+    for (const w of t.toLowerCase().split(/[^a-z0-9./-]+/)) {
+      if (w.length < 3 || STOPWORDS.has(w)) continue;
+      freq.set(w, (freq.get(w) ?? 0) + 1);
+    }
+  }
+  return [...freq.entries()].filter(([, n]) => n > 1).sort((a, b) => b[1] - a[1]).slice(0, top).map(([w]) => w);
+}
+function cmdDeriveSessions(store, config) {
+  const sessions = readAllSessions();
+  const projDomain = projectDomainMap(store);
+  const groups = domainGroups(config);
+  const byProject = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const key = s.project_name ?? "(unknown)";
+    (byProject.get(key) ?? byProject.set(key, []).get(key)).push(s);
+  }
+  const date = today();
+  const id = `insights/${date}-sessions-derived`;
+  const lines = [
+    `# Sessions-derived topics \u2014 ${date}`,
+    "",
+    `Re-analysis of ${sessions.length} captured sessions (git store + native Claude transcripts),`,
+    "clustered by project with per-cluster keywords and samples. Suggestions are advisory \u2014",
+    "promote to tasks/ideas with `kp capture` / the dashboard, nothing was auto-created.",
+    ""
+  ];
+  const clusters = [...byProject.entries()].sort((a, b) => b[1].length - a[1].length);
+  for (const [project, list] of clusters) {
+    const days = list.map((s) => s.day).sort();
+    const domain = projDomain[project];
+    const group = groupOfDomain(groups, domain);
+    const titles = list.map((s) => s.title ?? "").filter(Boolean);
+    const kws = titleKeywords(titles);
+    lines.push(`## ${project} \u2014 ${list.length} session(s), ${days[0]} \u2192 ${days[days.length - 1]}`);
+    lines.push(`- group/domain: ${group}${domain ? ` / ${domain}` : " / (unmapped \u2014 consider a planning project entry)"}`);
+    if (kws.length) lines.push(`- recurring themes: ${kws.join(", ")}`);
+    for (const s of list.filter((x) => x.title).slice(-4)) lines.push(`- ${s.day}: ${s.title}`);
+    if (kws.length) lines.push(`- [ ] suggested: track "${project}: ${kws.slice(0, 3).join(" / ")}" as a task or idea if still active`);
+    lines.push("");
+  }
+  store.write(
+    {
+      id,
+      type: "insight",
+      title: `Sessions-derived topics \u2014 ${date}`,
+      source: "sessions-derive",
+      generated_at: date,
+      confidence: "medium",
+      status: "new"
+    },
+    lines.join("\n")
+  );
+  return { id, clusters: clusters.length, sessions: sessions.length };
+}
+function cmdEditObject(store, id, edits) {
+  const existing = store.get(id);
+  if (!existing) throw new Error(`object not found: ${id}`);
+  const data = { ...existing.data };
+  if (edits.title !== void 0 && edits.title.trim()) data.title = edits.title.trim();
+  data.updated = today();
+  store.write(
+    data,
+    edits.body !== void 0 ? edits.body : existing.body
+  );
+}
+function cmdCreate(store, input) {
+  const title = input.title.trim();
+  if (!title) throw new Error("create needs a title");
+  const type = input.type || "task";
+  const folder = type === "idea" ? "ideas" : type === "plan" ? "plans" : type === "thought" ? "thoughts" : "tasks";
+  const id = uniqueId(store, `${folder}/${slugify(title)}`);
+  const defaultStatus = TYPE_DEFAULT_STATUS[type] ?? "inbox";
+  const data = {
+    id,
+    type,
+    title,
+    status: input.status || defaultStatus,
+    created: today()
+  };
+  if (input.domain) data.domain = input.domain;
+  if (input.project) {
+    const resolved = resolveProjectId(store, input.project);
+    if (resolved) data.project = resolved;
+  }
+  if (input.priority && /^p[0-3]$/.test(input.priority)) data.priority = input.priority;
+  if (input.due && /^\d{4}-\d{2}-\d{2}$/.test(input.due)) data.due = input.due;
+  store.write(data, input.body);
+  return { id };
+}
+function inferProjectFromText(store, id, text) {
+  const cfg = store.config();
+  const compile = (s) => {
+    try {
+      return new RegExp(s, "i");
+    } catch {
+      return null;
+    }
+  };
+  for (const r of cfg.project_id_rules ?? []) {
+    const re = compile(r.pattern);
+    if (re && re.test(id) && store.get(r.project)?.type === "project") return r.project;
+  }
+  const hay = `${id}
+${text}`;
+  for (const rule of cfg.project_rules ?? []) {
+    if (store.get(rule.project)?.type !== "project") continue;
+    if ((rule.patterns ?? []).some((p) => {
+      const re = compile(p);
+      return !!re && re.test(hay);
+    })) return rule.project;
+  }
+  return null;
+}
+function cmdDeriveProjects(store, opts = {}) {
+  const types = new Set(opts.types ?? ["task", "idea", "thought", "plan"]);
+  const force = !!opts.force;
+  const dryRun = !!opts.dryRun;
+  const result = {
+    examined: 0,
+    labeled: 0,
+    skippedHasProject: 0,
+    skippedNoMatch: 0,
+    changes: []
+  };
+  for (const d of store.all()) {
+    if (!types.has(d.type)) continue;
+    result.examined++;
+    const o = d.object;
+    if (o.project && !force) {
+      result.skippedHasProject++;
+      continue;
+    }
+    const o2 = d.object;
+    const hay = [
+      d.id,
+      o2.title ?? "",
+      o2.domain ?? "",
+      o2.context ?? "",
+      o2.source ?? "",
+      ...o2.related ?? [],
+      ...o2.cites ?? [],
+      d.body ?? ""
+    ].join("\n");
+    const inferred = inferProjectFromText(store, d.id, hay);
+    if (!inferred) {
+      if (force && o.project) {
+        result.changes.push({ id: d.id, project: "(cleared)", previous: o.project });
+        if (!dryRun) {
+          store.patch(d.id, (data) => {
+            delete data.project;
+            data.updated = today();
+          });
+        }
+        result.labeled++;
+      } else {
+        result.skippedNoMatch++;
+      }
+      continue;
+    }
+    if (o.project === inferred) {
+      result.skippedHasProject++;
+      continue;
+    }
+    result.changes.push({ id: d.id, project: inferred, previous: o.project });
+    if (!dryRun) {
+      store.patch(d.id, (data) => {
+        data.project = inferred;
+        data.updated = today();
+      });
+    }
+    result.labeled++;
+  }
+  return result;
+}
+function projectIdFromPath(store, projectPath) {
+  if (!projectPath) return null;
+  const p = projectPath.replace(/\/+$/, "");
+  let best = null;
+  for (const d of store.byType("project")) {
+    const o = d.object;
+    for (const repo of o.repos ?? []) {
+      const m = repo.match(/[:/]([^/]+?)(?:\.git)?$/);
+      const name = m?.[1];
+      if (!name) continue;
+      if (p.includes(`/unpolarize/${name}`) || p.endsWith(`/${name}`) || p.includes(`/projects/${name}`)) {
+        const len = name.length;
+        if (!best || len > best.len) best = { id: d.id, len };
+      }
+    }
+    const slug = o.catalog_slug ?? d.id.replace(/^projects\//, "");
+    if (p.includes(slug) && slug.length > 2) {
+      const len = slug.length;
+      if (!best || len > best.len) best = { id: d.id, len };
+    }
+  }
+  for (const rule of store.config().project_path_rules ?? []) {
+    let re = null;
+    try {
+      re = new RegExp(rule.pattern, "i");
+    } catch {
+      re = null;
+    }
+    if (re && re.test(p) && store.get(rule.project)?.type === "project") {
+      if (!best || rule.project.length > best.len) best = { id: rule.project, len: rule.project.length };
+    }
+  }
+  return best?.id ?? null;
+}
+function cmdLabelSessions(store, opts = {}) {
+  const root = opts.sessionsRoot ?? store.config().sessions_root;
+  const hosts = join5(root, "hosts");
+  const result = { examined: 0, labeled: 0, skipped: 0, changes: [] };
+  if (!existsSync5(hosts)) return result;
+  const walk = (dir) => {
+    const out = [];
+    for (const name of readdirSync4(dir)) {
+      const p = join5(dir, name);
+      const st = statSync2(p);
+      if (st.isDirectory()) out.push(...walk(p));
+      else if (name === "session.json") out.push(p);
+    }
+    return out;
+  };
+  for (const path2 of walk(hosts)) {
+    result.examined++;
+    let env;
+    try {
+      env = JSON.parse(readFileSync5(path2, "utf8"));
+    } catch {
+      result.skipped++;
+      continue;
+    }
+    const projectId = projectIdFromPath(store, env.project_path);
+    if (!projectId) {
+      result.skipped++;
+      continue;
+    }
+    const proj = store.get(projectId)?.object;
+    const slug = proj?.catalog_slug ?? projectId.replace(/^projects\//, "");
+    const label = `project:${slug}`;
+    const labels = [...env.labels ?? []];
+    const has = labels.some((l) => l === label || l.startsWith("project:"));
+    if (has && !opts.force) {
+      const existing = labels.find((l) => l.startsWith("project:"));
+      if (existing === label) {
+        result.skipped++;
+        continue;
+      }
+      if (!opts.force && existing) {
+        result.skipped++;
+        continue;
+      }
+    }
+    const next = labels.filter((l) => !l.startsWith("project:"));
+    next.push(label);
+    result.changes.push({ path: path2, uuid: env.session_id ?? "", project: projectId, label });
+    if (!opts.dryRun) {
+      env.labels = next;
+      writeFileSync3(path2, JSON.stringify(env, null, 2) + "\n", "utf8");
+    }
+    result.labeled++;
+  }
+  return result;
+}
+
+export {
+  SCHEMA_VERSION,
+  ns,
+  OBJECT_TYPES,
+  IDEA_STATUS,
+  PLAN_STATUS,
+  TASK_STATUS,
+  SESSION_PHASE,
+  INSIGHT_STATUS,
+  THOUGHT_STATUS,
+  KnowledgeRefSchema,
+  DomainSchema,
+  ProjectSchema,
+  CatalogEntrySchema,
+  IdeaSchema,
+  PlanSchema,
+  TaskSchema,
+  DailyPlanSchema,
+  ReflectionSchema,
+  InsightSchema,
+  ThoughtSchema,
+  SCHEMA_BY_TYPE,
+  ObjectSchema,
+  EDGE_KINDS,
+  EdgeSchema,
+  parseObject,
+  safeParseObject,
+  parseMarkdown,
+  serializeMarkdown,
+  DEFAULT_CONFIG,
+  Store,
+  walkMarkdown,
+  resolveKnowledgeRef,
+  readTitle,
+  hasDecision,
+  inspectKnowledgeRef,
+  PlanningIndex,
+  persistIndex,
+  buildGraph,
+  extractBullets,
+  extractProse,
+  slugify,
+  toSeeds,
+  findSessionEnvelope,
+  addPlanningRef,
+  readAllSessions,
+  sessionsByDay,
+  today,
+  cmdList,
+  cmdDaily,
+  cmdBlocked,
+  cmdGraph,
+  cmdReindex,
+  cmdCapture,
+  cmdPromote,
+  cmdLinkSession,
+  cmdInsightIngest,
+  cmdShow,
+  cmdExport,
+  cmdCalendar,
+  cmdSetDue,
+  cmdSetPriority,
+  cmdSetStatus,
+  cmdSetProject,
+  cmdEdit,
+  cmdRecategorize,
+  cmdDelete,
+  cmdResearch,
+  cmdIngestGdoc,
+  cmdIngestThoughts,
+  cmdDoctor,
+  buildTopics,
+  buildLookback,
+  cmdLookback,
+  cmdDeriveSessions,
+  cmdEditObject,
+  cmdCreate,
+  cmdDeriveProjects,
+  cmdLabelSessions,
+  commands_exports
+};