valija 0.1.0 → 0.2.0

package/dist/program.js

@@ -21,6 +21,75 @@ var DomainError = class extends Error {
 // src/context/domain/errors.ts
 var contextErr = (code, message) => err(new DomainError(code, message));
 
+// src/context/domain/services/context-pack.ts
+var DEFAULT_BUDGET_TOKENS = 4e3;
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+var estimateItemTokens = (item) => estimateTokens(
+  `${item.type} ${item.createdAt.toISOString().slice(0, 10)} ${item.tags.join(" ")}
+
+${item.content}`
+);
+var SECTION_TYPE_ORDER = ["decision", "preference", "progress", "fact"];
+var estimatePreambleTokens = (input) => estimateTokens(
+  `Context pack: ${input.projectName} \u2014 ${input.items.length} items, generated ${input.generatedAt.toISOString()}`
+);
+function assembleContextPack(input) {
+  const draft = {
+    sections: [],
+    included: /* @__PURE__ */ new Set(),
+    budget: input.budgetTokens ?? Number.POSITIVE_INFINITY,
+    usedTokens: estimatePreambleTokens(input)
+  };
+  addPinned(draft, input.items);
+  addLatestHandoff(draft, input.items);
+  addTypeSections(draft, input.items);
+  return {
+    projectName: input.projectName,
+    generatedAt: input.generatedAt,
+    sections: draft.sections,
+    includedCount: draft.included.size,
+    totalCount: input.items.length,
+    estimatedTokens: draft.usedTokens
+  };
+}
+function addPinned(draft, items) {
+  const pinned = items.filter((item) => item.pinned);
+  if (pinned.length === 0) return;
+  draft.usedTokens += estimateTokens("Pinned");
+  const kept = [];
+  for (const item of pinned) {
+    const cost = estimateItemTokens(item);
+    if (kept.length > 0 && draft.usedTokens + cost > draft.budget) break;
+    kept.push(item);
+    draft.usedTokens += cost;
+    draft.included.add(item.id);
+  }
+  draft.sections.push({ kind: "pinned", items: kept });
+}
+function addLatestHandoff(draft, items) {
+  const handoff = items.find((item) => item.type === "handoff" && !draft.included.has(item.id));
+  if (handoff === void 0) return;
+  const cost = estimateItemTokens(handoff) + estimateTokens("Latest handoff");
+  if (draft.usedTokens + cost > draft.budget) return;
+  draft.usedTokens += cost;
+  draft.sections.push({ kind: "latest-handoff", items: [handoff] });
+  draft.included.add(handoff.id);
+}
+function addTypeSections(draft, items) {
+  for (const type of SECTION_TYPE_ORDER) {
+    const candidates = items.filter((item) => item.type === type && !draft.included.has(item.id));
+    const kept = [];
+    for (const item of candidates) {
+      const cost = estimateItemTokens(item) + (kept.length === 0 ? estimateTokens(type) : 0);
+      if (draft.usedTokens + cost > draft.budget) break;
+      kept.push(item);
+      draft.usedTokens += cost;
+      draft.included.add(item.id);
+    }
+    if (kept.length > 0) draft.sections.push({ kind: "by-type", type, items: kept });
+  }
+}
+
 // src/context/domain/values/project-name.ts
 var PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function parseProjectName(raw) {
@@ -34,62 +103,7 @@ function parseProjectName(raw) {
   return ok(normalized);
 }
 
-// src/context/application/export-pack.ts
-var ExportPack = class {
-  constructor(sessions, getContextPack) {
-    this.sessions = sessions;
-    this.getContextPack = getContextPack;
-  }
-  sessions;
-  getContextPack;
-  execute(project, format) {
-    if (format === "md") {
-      const pack = this.getContextPack.execute({ project, budgetTokens: Number.MAX_SAFE_INTEGER });
-      return pack.ok ? ok(pack.value.markdown) : pack;
-    }
-    const name = parseProjectName(project);
-    if (!name.ok) return name;
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      const found = session.value.projects.findByName(name.value);
-      if (found === null) {
-        return contextErr("PROJECT_NOT_FOUND", `No project named "${name.value}".`);
-      }
-      const items = session.value.items.findByProject(found.id).map((item) => ({
-        id: item.id,
-        type: item.type,
-        content: item.content,
-        tags: item.tags,
-        pinned: item.pinned,
-        source: item.source ?? null,
-        createdAt: item.createdAt.toISOString()
-      }));
-      return ok(JSON.stringify({ project: name.value, items }, null, 2));
-    } finally {
-      session.value.close();
-    }
-  }
-};
-
-// src/context/application/get-context-pack.ts
-var DEFAULT_BUDGET_TOKENS = 4e3;
-var estimateTokens = (text) => Math.ceil(text.length / 4);
-var SECTION_ORDER = ["decision", "preference", "progress", "fact"];
-var SECTION_LABELS = {
-  decision: "Decisions",
-  preference: "Preferences",
-  progress: "Progress",
-  fact: "Facts"
-};
-var renderItem = (item) => {
-  const date = item.createdAt.toISOString().slice(0, 10);
-  const tags = item.tags.length > 0 ? ` \xB7 ${item.tags.map((t) => `#${t}`).join(" ")}` : "";
-  return `### ${item.type} \xB7 ${date}${tags}
-
-${item.content}
-`;
-};
+// src/context/application/use-cases/get-context-pack.use-case.ts
 var GetContextPack = class {
   constructor(sessions, clock) {
     this.sessions = sessions;
@@ -100,107 +114,62 @@ var GetContextPack = class {
   execute(input) {
     const name = parseProjectName(input.project);
     if (!name.ok) return name;
-    const budget = input.budgetTokens ?? DEFAULT_BUDGET_TOKENS;
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      const project = session.value.projects.findByName(name.value);
+    return this.sessions.withSession((session) => {
+      const project = session.projects.findByName(name.value);
       if (project === null) {
         return contextErr("PROJECT_NOT_FOUND", `No project named "${name.value}".`);
       }
-      const all = session.value.items.findByProject(project.id);
-      const included = /* @__PURE__ */ new Set();
-      const parts = [];
-      let used = 0;
-      const header = `# Context pack: ${name.value}
-
-> ${all.length} items in vault \xB7 generated ${this.clock.now().toISOString()}
-`;
-      used += estimateTokens(header);
-      const pinned = all.filter((i) => i.pinned);
-      const pinnedKept = [];
-      for (const item of pinned) {
-        const cost = estimateTokens(renderItem(item));
-        if (pinnedKept.length > 0 && used + cost > budget) break;
-        pinnedKept.push(item);
-        used += cost;
-      }
-      if (pinnedKept.length > 0) {
-        parts.push("\n## Pinned\n");
-        for (const item of pinnedKept) {
-          parts.push(renderItem(item));
-          included.add(item.id);
-        }
-      }
-      const handoff = all.find((i) => i.type === "handoff" && !included.has(i.id));
-      if (handoff) {
-        const rendered = renderItem(handoff);
-        const cost = estimateTokens(rendered);
-        if (used + cost <= budget) {
-          parts.push("\n## Latest handoff\n", rendered);
-          included.add(handoff.id);
-          used += cost;
-        }
-      }
-      for (const type of SECTION_ORDER) {
-        const items = all.filter((i) => i.type === type && !included.has(i.id));
-        let sectionOpened = false;
-        for (const item of items) {
-          const rendered = renderItem(item);
-          const sectionHeader = sectionOpened ? "" : `
-## ${SECTION_LABELS[type]}
-`;
-          const cost = estimateTokens(sectionHeader + rendered);
-          if (used + cost > budget) break;
-          if (!sectionOpened) {
-            parts.push(sectionHeader);
-            sectionOpened = true;
-          }
-          parts.push(rendered);
-          included.add(item.id);
-          used += cost;
-        }
-      }
-      const markdown = header + parts.join("\n");
-      return ok({
-        markdown,
-        includedCount: included.size,
-        totalCount: all.length,
-        estimatedTokens: estimateTokens(markdown)
-      });
-    } finally {
-      session.value.close();
-    }
-  }
-};
-
-// src/context/application/list-projects.ts
-var ListProjects = class {
-  constructor(sessions) {
-    this.sessions = sessions;
-  }
-  sessions;
-  execute() {
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      const entries = session.value.projects.list().map((summary) => ({
-        name: summary.project.name,
-        ...summary.project.description === void 0 ? {} : { description: summary.project.description },
-        itemCount: summary.itemCount,
-        lastActivityAt: summary.lastActivityAt?.toISOString() ?? null
-      }));
-      return ok(entries);
-    } finally {
-      session.value.close();
-    }
+      return ok(
+        assembleContextPack({
+          projectName: name.value,
+          items: session.items.findByProject(project.id),
+          generatedAt: this.clock.now(),
+          budgetTokens: input.budgetTokens ?? DEFAULT_BUDGET_TOKENS
+        })
+      );
+    });
   }
 };
 
 // src/context/domain/entities/context-item.ts
+import { createHash } from "crypto";
+function createContextItem(input) {
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    type: input.type,
+    content: input.content,
+    tags: input.tags,
+    pinned: input.pinned,
+    ...input.source === void 0 ? {} : { source: input.source },
+    archived: false,
+    createdAt: input.now,
+    updatedAt: input.now
+  };
+}
+function importedItemId(projectId, source, conversationId, chunkIndex) {
+  const digest = createHash("sha256").update(`${projectId} ${source} ${conversationId} ${chunkIndex}`).digest("hex");
+  return `imp-${digest.slice(0, 32)}`;
+}
+function createImportedContextItem(input) {
+  return {
+    id: importedItemId(input.projectId, input.source, input.conversationId, input.chunkIndex),
+    projectId: input.projectId,
+    type: "imported",
+    content: input.content,
+    tags: input.tags,
+    pinned: false,
+    source: `${input.source}-import`,
+    archived: false,
+    createdAt: input.createdAt,
+    updatedAt: input.now
+  };
+}
+
+// src/context/domain/values/content.ts
 var MAX_CONTENT_BYTES = 32 * 1024;
-function validateContent(content) {
-  const trimmed = content.trim();
+function parseContent(raw) {
+  const trimmed = raw.trim();
   if (trimmed.length === 0) {
     return contextErr("CONTENT_EMPTY", "Content must not be empty.");
   }
@@ -214,18 +183,6 @@ function validateContent(content) {
   return ok(trimmed);
 }
 
-// src/context/domain/values/item-type.ts
-var ITEM_TYPES = ["decision", "progress", "preference", "fact", "handoff"];
-function parseItemType(raw) {
-  if (ITEM_TYPES.includes(raw)) {
-    return ok(raw);
-  }
-  return contextErr(
-    "INVALID_ITEM_TYPE",
-    `Item type must be one of ${ITEM_TYPES.join(", ")}. Got: "${raw}"`
-  );
-}
-
 // src/context/domain/values/tag.ts
 var PATTERN2 = /^[a-z0-9][a-z0-9-]{0,31}$/;
 var MAX_TAGS = 10;
@@ -249,7 +206,103 @@ function parseTags(raw) {
   return ok(tags);
 }
 
-// src/context/application/save-context.ts
+// src/context/application/use-cases/import-items.use-case.ts
+var ImportItems = class {
+  constructor(sessions, clock, idGen) {
+    this.sessions = sessions;
+    this.clock = clock;
+    this.idGen = idGen;
+  }
+  sessions;
+  clock;
+  idGen;
+  execute(input) {
+    const name = parseProjectName(input.projectName);
+    if (!name.ok) return name;
+    return this.sessions.withSession((session) => {
+      const { project, created } = this.findOrCreateProject(session, name.value);
+      const failures = [];
+      let imported = 0;
+      for (const draft of input.items) {
+        const saved = this.saveDraft(session, project.id, draft);
+        if (saved.ok) imported += 1;
+        else failures.push({ conversationId: draft.conversationId, reason: saved.error.message });
+      }
+      return ok({ projectCreated: created, imported, failed: failures.length, failures });
+    });
+  }
+  /** Re-validate tags and content at the vault boundary — defense in depth, even though the renderer aims well under the limit. */
+  saveDraft(session, projectId, draft) {
+    const tags = parseTags(draft.tags);
+    if (!tags.ok) return tags;
+    const content = parseContent(draft.content);
+    if (!content.ok) return content;
+    session.items.save(
+      createImportedContextItem({
+        projectId,
+        source: draft.source,
+        conversationId: draft.conversationId,
+        chunkIndex: draft.chunkIndex,
+        content: content.value,
+        tags: tags.value,
+        createdAt: draft.createdAt,
+        now: this.clock.now()
+      })
+    );
+    return ok(void 0);
+  }
+  findOrCreateProject(session, name) {
+    const existing = session.projects.findByName(name);
+    if (existing !== null) return { project: existing, created: false };
+    const now = this.clock.now();
+    const project = { id: this.idGen.next(), name, createdAt: now, updatedAt: now };
+    session.projects.save(project);
+    return { project, created: true };
+  }
+};
+
+// src/context/application/use-cases/list-projects.use-case.ts
+var ListProjects = class {
+  constructor(sessions) {
+    this.sessions = sessions;
+  }
+  sessions;
+  execute() {
+    return this.sessions.withSession((session) => {
+      const entries = session.projects.list().map((summary) => ({
+        name: summary.project.name,
+        ...summary.project.description === void 0 ? {} : { description: summary.project.description },
+        itemCount: summary.itemCount,
+        lastActivityAt: summary.lastActivityAt?.toISOString() ?? null
+      }));
+      return ok(entries);
+    });
+  }
+};
+
+// src/context/domain/values/item-type.ts
+var ITEM_TYPES = ["decision", "progress", "preference", "fact", "handoff"];
+function parseItemType(raw) {
+  if (ITEM_TYPES.includes(raw)) {
+    return ok(raw);
+  }
+  return contextErr(
+    "INVALID_ITEM_TYPE",
+    `Item type must be one of ${ITEM_TYPES.join(", ")}. Got: "${raw}"`
+  );
+}
+var STORABLE_ITEM_TYPES = [...ITEM_TYPES, "imported"];
+function parseStorableItemType(raw) {
+  if (STORABLE_ITEM_TYPES.includes(raw)) {
+    return ok(raw);
+  }
+  return contextErr(
+    "INVALID_ITEM_TYPE",
+    `Item type must be one of ${STORABLE_ITEM_TYPES.join(", ")}. Got: "${raw}"`
+  );
+}
+
+// src/context/application/use-cases/save-context.use-case.ts
 var SaveContext = class {
   constructor(sessions, clock, idGen) {
     this.sessions = sessions;
@@ -260,129 +313,134 @@ var SaveContext = class {
   clock;
   idGen;
   execute(input) {
+    const validated = this.parseInput(input);
+    if (!validated.ok) return validated;
+    return this.sessions.withSession((session) => {
+      const { project, created } = this.findOrCreateProject(session, validated.value.name);
+      const item = createContextItem({
+        id: this.idGen.next(),
+        projectId: project.id,
+        type: validated.value.type,
+        content: validated.value.content,
+        tags: validated.value.tags,
+        pinned: validated.value.pinned,
+        ...validated.value.source === void 0 ? {} : { source: validated.value.source },
+        now: this.clock.now()
+      });
+      session.items.save(item);
+      return ok({
+        itemId: item.id,
+        project: validated.value.name,
+        type: validated.value.type,
+        projectCreated: created
+      });
+    });
+  }
+  /** Everything is parsed before a session is opened: bad input never touches the vault. */
+  parseInput(input) {
     const name = parseProjectName(input.project);
     if (!name.ok) return name;
     const type = parseItemType(input.type ?? "fact");
     if (!type.ok) return type;
     const tags = parseTags(input.tags ?? []);
     if (!tags.ok) return tags;
-    const content = validateContent(input.content);
+    const content = parseContent(input.content);
     if (!content.ok) return content;
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      const now = this.clock.now();
-      let project = session.value.projects.findByName(name.value);
-      const projectCreated = project === null;
-      if (project === null) {
-        project = {
-          id: this.idGen.next(),
-          name: name.value,
-          createdAt: now,
-          updatedAt: now
-        };
-        session.value.projects.save(project);
-      }
-      const itemId = this.idGen.next();
-      session.value.items.save({
-        id: itemId,
-        projectId: project.id,
-        type: type.value,
-        content: content.value,
-        tags: tags.value,
-        pinned: input.pinned ?? false,
-        ...input.source === void 0 ? {} : { source: input.source },
-        archived: false,
-        createdAt: now,
-        updatedAt: now
-      });
-      return ok({ itemId, project: name.value, type: type.value, projectCreated });
-    } finally {
-      session.value.close();
-    }
+    return ok({
+      name: name.value,
+      type: type.value,
+      tags: tags.value,
+      content: content.value,
+      pinned: input.pinned ?? false,
+      ...input.source === void 0 ? {} : { source: input.source }
+    });
+  }
+  findOrCreateProject(session, name) {
+    const existing = session.projects.findByName(name);
+    if (existing !== null) return { project: existing, created: false };
+    const now = this.clock.now();
+    const project = { id: this.idGen.next(), name, createdAt: now, updatedAt: now };
+    session.projects.save(project);
+    return { project, created: true };
   }
 };
 
-// src/context/application/search-context.ts
+// src/context/application/dto/context-item-view.ts
+var toContextItemView = (item, projectName) => ({
+  id: item.id,
+  project: projectName,
+  type: item.type,
+  content: item.content,
+  tags: [...item.tags],
+  pinned: item.pinned,
+  ...item.source === void 0 ? {} : { source: item.source },
+  createdAt: item.createdAt.toISOString()
+});
+
+// src/context/application/use-cases/search-context.use-case.ts
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
 var SearchContext = class {
   constructor(sessions) {
     this.sessions = sessions;
   }
   sessions;
   execute(input) {
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      let projectId;
-      if (input.project !== void 0) {
-        const name = parseProjectName(input.project);
-        if (!name.ok) return name;
-        const project = session.value.projects.findByName(name.value);
-        if (project === null) {
-          return contextErr("PROJECT_NOT_FOUND", `No project named "${name.value}".`);
-        }
-        projectId = project.id;
-      }
-      const limit = Math.min(Math.max(input.limit ?? 20, 1), 100);
-      const hits = session.value.items.search(input.query, projectId, limit).map((result) => ({
-        id: result.item.id,
-        project: result.projectName,
-        type: result.item.type,
-        content: result.item.content,
-        tags: [...result.item.tags],
-        pinned: result.item.pinned,
-        createdAt: result.item.createdAt.toISOString()
-      }));
+    return this.sessions.withSession((session) => {
+      const scope = this.resolveProjectScope(session, input.project);
+      if (!scope.ok) return scope;
+      const limit = Math.min(Math.max(input.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+      const hits = session.items.search(input.query, scope.value, limit).map((result) => toContextItemView(result.item, result.projectName));
       return ok(hits);
-    } finally {
-      session.value.close();
+    });
+  }
+  /** No project given → search everywhere; otherwise the project must exist. */
+  resolveProjectScope(session, project) {
+    if (project === void 0) return ok(void 0);
+    const name = parseProjectName(project);
+    if (!name.ok) return name;
+    const found = session.projects.findByName(name.value);
+    if (found === null) {
+      return contextErr("PROJECT_NOT_FOUND", `No project named "${name.value}".`);
     }
+    return ok(found.id);
   }
 };
 
-// src/context/application/show-project.ts
+// src/context/application/use-cases/show-project.use-case.ts
 var ShowProject = class {
   constructor(sessions) {
     this.sessions = sessions;
   }
   sessions;
-  execute(project, type) {
-    const name = parseProjectName(project);
-    if (!name.ok) return name;
-    let typeValue;
-    if (type !== void 0) {
-      const parsed = parseItemType(type);
-      if (!parsed.ok) return parsed;
-      typeValue = parsed.value;
-    }
-    const session = this.sessions.open();
-    if (!session.ok) return session;
-    try {
-      const found = session.value.projects.findByName(name.value);
+  execute(input) {
+    const filters = this.parseFilters(input);
+    if (!filters.ok) return filters;
+    return this.sessions.withSession((session) => {
+      const found = session.projects.findByName(filters.value.name);
       if (found === null) {
-        return contextErr("PROJECT_NOT_FOUND", `No project named "${name.value}".`);
+        return contextErr("PROJECT_NOT_FOUND", `No project named "${filters.value.name}".`);
       }
-      const items = session.value.items.findByProject(
+      const items = session.items.findByProject(
         found.id,
-        typeValue === void 0 ? {} : { type: typeValue }
-      );
-      return ok(
-        items.map((item) => ({
-          id: item.id,
-          project: name.value,
-          type: item.type,
-          content: item.content,
-          tags: [...item.tags],
-          pinned: item.pinned,
-          createdAt: item.createdAt.toISOString()
-        }))
+        filters.value.type === void 0 ? {} : { type: filters.value.type }
       );
-    } finally {
-      session.value.close();
-    }
+      return ok(items.map((item) => toContextItemView(item, filters.value.name)));
+    });
+  }
+  parseFilters(input) {
+    const name = parseProjectName(input.project);
+    if (!name.ok) return name;
+    if (input.type === void 0) return ok({ name: name.value });
+    const parsed = parseStorableItemType(input.type);
+    if (!parsed.ok) return parsed;
+    return ok({ name: name.value, type: parsed.value });
   }
 };
 
+// src/shared/infra/migrations.ts
+import { copyFileSync, rmSync } from "fs";
+
 // src/shared/infra/migrations/001-init.ts
 var MIGRATION_001 = `
 CREATE TABLE projects (
@@ -433,24 +491,92 @@ CREATE TRIGGER items_au AFTER UPDATE ON context_items BEGIN
 END;
 `;
 
+// src/shared/infra/migrations/002-imported-type.ts
+var MIGRATION_002 = `
+DROP TRIGGER items_ai;
+DROP TRIGGER items_ad;
+DROP TRIGGER items_au;
+
+CREATE TABLE context_items_new (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  type TEXT NOT NULL CHECK (type IN ('decision','progress','preference','fact','handoff','imported')),
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL DEFAULT '[]',
+  pinned INTEGER NOT NULL DEFAULT 0,
+  source TEXT,
+  archived INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+INSERT INTO context_items_new
+  (id, project_id, type, content, tags, pinned, source, archived, created_at, updated_at)
+SELECT
+  id, project_id, type, content, tags, pinned, source, archived, created_at, updated_at
+FROM context_items;
+
+DROP TABLE context_items;
+ALTER TABLE context_items_new RENAME TO context_items;
+
+CREATE INDEX idx_items_project ON context_items(project_id, created_at DESC);
+
+CREATE TRIGGER items_ai AFTER INSERT ON context_items BEGIN
+  INSERT INTO context_items_fts(rowid, content, tags)
+  VALUES (new.rowid, new.content, new.tags);
+END;
+
+CREATE TRIGGER items_ad AFTER DELETE ON context_items BEGIN
+  INSERT INTO context_items_fts(context_items_fts, rowid, content, tags)
+  VALUES ('delete', old.rowid, old.content, old.tags);
+END;
+
+CREATE TRIGGER items_au AFTER UPDATE ON context_items BEGIN
+  INSERT INTO context_items_fts(context_items_fts, rowid, content, tags)
+  VALUES ('delete', old.rowid, old.content, old.tags);
+  INSERT INTO context_items_fts(rowid, content, tags)
+  VALUES (new.rowid, new.content, new.tags);
+END;
+
+INSERT INTO context_items_fts(context_items_fts) VALUES('rebuild');
+`;
+
 // src/shared/infra/migrations.ts
 var MIGRATIONS = [
-  { version: 1, sql: MIGRATION_001 }
+  { version: 1, sql: MIGRATION_001 },
+  { version: 2, sql: MIGRATION_002, backup: true }
 ];
-function migrate(db) {
+function migrate(db, dbPath) {
   db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-  const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
-  const current = row ? Number(row.value) : 0;
+  const current = schemaVersion(db);
   for (const migration of MIGRATIONS) {
     if (migration.version <= current) continue;
-    db.transaction(() => {
-      db.exec(migration.sql);
-      db.prepare(
-        "INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
-      ).run(String(migration.version));
-    })();
+    applyMigration(db, migration, current, dbPath);
   }
 }
+function applyMigration(db, migration, current, dbPath) {
+  const backupPath = migration.backup === true && current >= 1 && dbPath !== void 0 ? backupCiphertext(db, dbPath, migration.version) : null;
+  db.transaction(() => {
+    db.exec(migration.sql);
+    setSchemaVersion(db, migration.version);
+  })();
+  if (backupPath !== null) rmSync(backupPath, { force: true });
+}
+function backupCiphertext(db, dbPath, version) {
+  db.pragma("wal_checkpoint(TRUNCATE)");
+  const backupPath = `${dbPath}.pre-${String(version).padStart(3, "0")}.bak`;
+  copyFileSync(dbPath, backupPath);
+  return backupPath;
+}
+function setSchemaVersion(db, version) {
+  db.prepare(
+    "INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(String(version));
+}
+function schemaVersion(db) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  return row ? Number(row.value) : 0;
+}
 
 // src/shared/infra/sqlite.ts
 import { mkdirSync } from "fs";
@@ -672,23 +798,44 @@ var SqliteProjectRepository = class {
   }
 };
 
-// src/context/infra/session-factory.ts
+// src/context/infra/vault-sessions.ts
 var LOCKED_MESSAGE = 'Vault is locked. Ask the user to run "valija unlock" in a terminal.';
-var SqliteVaultSessionFactory = class {
+function runWithSession(open, action) {
+  const session = open();
+  if (!session.ok) return session;
+  try {
+    return action(session.value);
+  } finally {
+    session.value.close();
+  }
+}
+var SqliteVaultSessions = class {
   constructor(paths, keychain) {
     this.paths = paths;
     this.keychain = keychain;
   }
   paths;
   keychain;
+  withSession(action) {
+    return runWithSession(() => this.open(), action);
+  }
   open() {
     const header = readVaultHeader(this.paths.header);
     if (!header.ok) return header;
-    const keyHex = this.keychain.getKey(header.value.vaultId);
+    const keyHex = this.requireKey(header.value.vaultId);
+    if (!keyHex.ok) return keyHex;
+    return this.openRepositories(header.value.vaultId, keyHex.value);
+  }
+  /** The session key must be present in the OS keychain — otherwise the vault is locked. */
+  requireKey(vaultId) {
+    const keyHex = this.keychain.getKey(vaultId);
     if (keyHex === null) return vaultErr("VAULT_LOCKED", LOCKED_MESSAGE);
+    return ok(keyHex);
+  }
+  openRepositories(vaultId, keyHex) {
     try {
       const db = openVaultDb(this.paths.db, keyHex);
-      migrate(db);
+      migrate(db, this.paths.db);
       return ok({
         projects: new SqliteProjectRepository(db),
         items: new SqliteContextItemRepository(db),
@@ -696,7 +843,7 @@ var SqliteVaultSessionFactory = class {
       });
     } catch (error) {
       if (isWrongKeyError(error)) {
-        this.keychain.deleteKey(header.value.vaultId);
+        this.keychain.deleteKey(vaultId);
         return vaultErr("VAULT_LOCKED", LOCKED_MESSAGE);
       }
       return vaultErr("STORAGE_ERROR", `Could not open vault: ${error.message}`);
@@ -704,6 +851,607 @@ var SqliteVaultSessionFactory = class {
   }
 };
 
+// src/importers/domain/errors.ts
+var importerErr = (code, message) => err(new DomainError(code, message));
+
+// src/importers/domain/services/chunk-render.ts
+var DEFAULT_BYTE_BUDGET = 28 * 1024;
+var HEADER_RESERVE = 768;
+var SEPARATOR = "\n\n";
+var MAX_TITLE_CHARS = 120;
+var encoder = new TextEncoder();
+var byteLength = (text) => encoder.encode(text).length;
+var ROLE_LABEL = { user: "User", assistant: "Assistant", system: "System" };
+var SOURCE_LABEL = {
+  chatgpt: "ChatGPT",
+  claude: "Claude",
+  generic: "Generic"
+};
+var renderMessage = (message) => `**${ROLE_LABEL[message.role]}:** ${message.content}`;
+function hardSplit(text, limit) {
+  const pieces = [];
+  let buffer = "";
+  let bufferBytes = 0;
+  for (const char of text) {
+    const charBytes = byteLength(char);
+    if (bufferBytes + charBytes > limit && buffer.length > 0) {
+      pieces.push(buffer);
+      buffer = "";
+      bufferBytes = 0;
+    }
+    buffer += char;
+    bufferBytes += charBytes;
+  }
+  if (buffer.length > 0) pieces.push(buffer);
+  return pieces;
+}
+function packBodies(messages, limit) {
+  const bodies = [];
+  let current = [];
+  let currentBytes = 0;
+  const flush = () => {
+    if (current.length > 0) {
+      bodies.push(current.join(SEPARATOR));
+      current = [];
+      currentBytes = 0;
+    }
+  };
+  for (const message of messages) {
+    const block = renderMessage(message);
+    const blockBytes = byteLength(block);
+    if (blockBytes > limit) {
+      flush();
+      for (const piece of hardSplit(block, limit)) bodies.push(piece);
+      continue;
+    }
+    const cost = (current.length > 0 ? byteLength(SEPARATOR) : 0) + blockBytes;
+    if (currentBytes + cost > limit) flush();
+    current.push(block);
+    currentBytes += current.length > 1 ? byteLength(SEPARATOR) + blockBytes : blockBytes;
+  }
+  flush();
+  return bodies;
+}
+function provenanceHeader(conversation, source, part, total) {
+  const title = conversation.title.length > MAX_TITLE_CHARS ? `${conversation.title.slice(0, MAX_TITLE_CHARS - 3)}...` : conversation.title;
+  const date = conversation.createdAt.toISOString().slice(0, 10);
+  return `> Imported from ${SOURCE_LABEL[source]} \xB7 "${title}" \xB7 ${date} \xB7 part ${part}/${total}`;
+}
+function renderConversationChunks(conversation, source, byteBudget = DEFAULT_BYTE_BUDGET) {
+  const limit = byteBudget - HEADER_RESERVE;
+  const bodies = packBodies(conversation.messages, limit);
+  const total = bodies.length;
+  return bodies.map(
+    (body, index) => `${provenanceHeader(conversation, source, index + 1, total)}
+
+${body}`
+  );
+}
+
+// src/importers/domain/services/selection.ts
+function parsePickSpec(spec, count) {
+  const tokens = spec.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return importerErr("INVALID_SELECTION", "--pick is empty.");
+  }
+  const indices = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const range = token.match(/^(\d+)-(\d+)$/);
+    const single = token.match(/^(\d+)$/);
+    if (range) {
+      const start = Number(range[1]);
+      const end = Number(range[2]);
+      if (start < 1 || end > count || start > end) {
+        return importerErr(
+          "INVALID_SELECTION",
+          `--pick range "${token}" is out of bounds (valid: 1-${count}).`
+        );
+      }
+      for (let i = start; i <= end; i++) indices.add(i - 1);
+    } else if (single) {
+      const index = Number(single[1]);
+      if (index < 1 || index > count) {
+        return importerErr(
+          "INVALID_SELECTION",
+          `--pick index "${token}" is out of bounds (valid: 1-${count}).`
+        );
+      }
+      indices.add(index - 1);
+    } else {
+      return importerErr("INVALID_SELECTION", `--pick token "${token}" is not a number or range.`);
+    }
+  }
+  return ok([...indices].sort((a, b) => a - b));
+}
+function selectConversations(conversations, filters) {
+  let selected = [...conversations];
+  if (filters.pick !== void 0) {
+    const picked = parsePickSpec(filters.pick, conversations.length);
+    if (!picked.ok) return picked;
+    selected = picked.value.map((index) => conversations[index]).filter((conversation) => conversation !== void 0);
+  }
+  if (filters.since !== void 0) {
+    const since = new Date(filters.since);
+    if (Number.isNaN(since.getTime())) {
+      return importerErr(
+        "INVALID_SELECTION",
+        `--since "${filters.since}" is not a valid date (use YYYY-MM-DD).`
+      );
+    }
+    selected = selected.filter(
+      (conversation) => conversation.createdAt.getTime() >= since.getTime()
+    );
+  }
+  if (filters.query !== void 0) {
+    const needle = filters.query.toLowerCase();
+    selected = selected.filter((conversation) => conversation.title.toLowerCase().includes(needle));
+  }
+  if (selected.length === 0) {
+    return importerErr("NO_CONVERSATIONS_SELECTED", "No conversations matched the given filters.");
+  }
+  return ok(selected);
+}
+
+// src/importers/application/use-cases/import-conversations.use-case.ts
+var ImportConversations = class {
+  constructor(reader2, registry, importItems, clock) {
+    this.reader = reader2;
+    this.registry = registry;
+    this.importItems = importItems;
+    this.clock = clock;
+  }
+  reader;
+  registry;
+  importItems;
+  clock;
+  execute(input) {
+    const docs = this.reader.read(input.filePath);
+    if (!docs.ok) return docs;
+    const resolved = this.resolveParser(docs.value, input.from);
+    if (!resolved.ok) return resolved;
+    const parsed = resolved.value.parser.parse(resolved.value.doc);
+    if (!parsed.ok) return parsed;
+    const source = resolved.value.parser.source;
+    const conversations = [...parsed.value.conversations].sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+    );
+    const parseFailures = parsed.value.failures.map((failure) => ({
+      conversation: failure.title,
+      reason: failure.reason
+    }));
+    const mode = this.resolveMode(input);
+    if (mode === "list") {
+      return ok(
+        this.summary(mode, source, input, parseFailures, {
+          listing: this.toListing(conversations, source)
+        })
+      );
+    }
+    const selected = selectConversations(conversations, {
+      ...input.all === void 0 ? {} : { all: input.all },
+      ...input.pick === void 0 ? {} : { pick: input.pick },
+      ...input.query === void 0 ? {} : { query: input.query },
+      ...input.since === void 0 ? {} : { since: input.since }
+    });
+    if (!selected.ok) return selected;
+    const { items, skipped, contributed } = this.buildItems(selected.value, source);
+    if (mode === "dry-run") {
+      return ok(
+        this.summary(mode, source, input, parseFailures, {
+          imported: items.length,
+          conversations: contributed,
+          skipped
+        })
+      );
+    }
+    const written = this.importItems.execute({ projectName: input.projectName ?? "", items });
+    if (!written.ok) return written;
+    const importFailures = written.value.failures.map((failure) => ({
+      conversation: failure.conversationId,
+      reason: failure.reason
+    }));
+    return ok(
+      this.summary(mode, source, input, [...parseFailures, ...importFailures], {
+        imported: written.value.imported,
+        conversations: contributed,
+        skipped
+      })
+    );
+  }
+  /** With `--from`, use that parser and surface its parse error verbatim; otherwise first `detect()` wins. */
+  resolveParser(docs, from) {
+    if (from !== void 0) {
+      const parser = this.registry.forSource(from);
+      const doc = docs.find((candidate) => parser.detect(candidate)) ?? docs[0];
+      if (doc === void 0) return importerErr("EMPTY_EXPORT", "The export was empty.");
+      return ok({ parser, doc });
+    }
+    for (const parser of this.registry.autodetect) {
+      const doc = docs.find((candidate) => parser.detect(candidate));
+      if (doc !== void 0) return ok({ parser, doc });
+    }
+    return importerErr(
+      "UNSUPPORTED_SOURCE",
+      "Could not detect the export format. Pass --from chatgpt, claude, or generic."
+    );
+  }
+  /** No selection flag (or an explicit --list) lists; otherwise --dry-run previews, else import. */
+  resolveMode(input) {
+    const hasSelection = input.all === true || input.pick !== void 0 || input.query !== void 0 || input.since !== void 0;
+    if (input.list === true || !hasSelection) return "list";
+    return input.dryRun === true ? "dry-run" : "import";
+  }
+  toListing(conversations, source) {
+    return conversations.map((conversation, index) => ({
+      index: index + 1,
+      title: conversation.title,
+      date: conversation.createdAt.toISOString().slice(0, 10),
+      messageCount: conversation.messages.length,
+      estimatedChunks: renderConversationChunks(conversation, source).length
+    }));
+  }
+  buildItems(conversations, source) {
+    const now = this.clock.now();
+    const items = [];
+    let skipped = 0;
+    let contributed = 0;
+    for (const conversation of conversations) {
+      const chunks = renderConversationChunks(conversation, source);
+      if (chunks.length === 0) {
+        skipped += 1;
+        continue;
+      }
+      contributed += 1;
+      const createdAt = conversation.createdAt.getTime() === 0 ? now : conversation.createdAt;
+      chunks.forEach((content, chunkIndex) => {
+        items.push({
+          source,
+          conversationId: conversation.id,
+          chunkIndex,
+          content,
+          createdAt,
+          tags: ["imported", source]
+        });
+      });
+    }
+    return { items, skipped, contributed };
+  }
+  summary(mode, source, input, failures, counts) {
+    return {
+      mode,
+      source,
+      ...input.projectName === void 0 ? {} : { project: input.projectName },
+      ...counts.listing === void 0 ? {} : { listing: counts.listing },
+      imported: counts.imported ?? 0,
+      conversations: counts.conversations ?? 0,
+      skipped: counts.skipped ?? 0,
+      failed: failures.length,
+      failures
+    };
+  }
+};
+
+// src/importers/infra/file-export-reader.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { unzipSync } from "fflate";
+var MAX_ENTRY_BYTES = 128 * 1024 * 1024;
+var MAX_TOTAL_BYTES = 256 * 1024 * 1024;
+var decoder = new TextDecoder();
+function parseJsonBytes(bytes) {
+  try {
+    return ok(JSON.parse(decoder.decode(bytes)));
+  } catch (error) {
+    return importerErr("MALFORMED_EXPORT", `Invalid JSON: ${error.message}`);
+  }
+}
+var FileExportReader = class {
+  constructor(maxEntryBytes = MAX_ENTRY_BYTES, maxTotalBytes = MAX_TOTAL_BYTES) {
+    this.maxEntryBytes = maxEntryBytes;
+    this.maxTotalBytes = maxTotalBytes;
+  }
+  maxEntryBytes;
+  maxTotalBytes;
+  read(filePath) {
+    let bytes;
+    try {
+      bytes = readFileSync2(filePath);
+    } catch (error) {
+      return importerErr(
+        "UNREADABLE_FILE",
+        `Could not read "${filePath}": ${error.message}`
+      );
+    }
+    return filePath.toLowerCase().endsWith(".zip") ? this.readZip(bytes) : this.readJson(bytes);
+  }
+  readJson(bytes) {
+    const parsed = parseJsonBytes(bytes);
+    if (!parsed.ok) return parsed;
+    return ok([parsed.value]);
+  }
+  readZip(bytes) {
+    let entries;
+    let total = 0;
+    try {
+      entries = unzipSync(bytes, {
+        filter: (file) => {
+          if (!file.name.toLowerCase().endsWith(".json")) return false;
+          if (file.originalSize > this.maxEntryBytes) {
+            throw new Error(`entry "${file.name}" exceeds the ${this.maxEntryBytes}-byte cap`);
+          }
+          total += file.originalSize;
+          if (total > this.maxTotalBytes) {
+            throw new Error(`archive exceeds the ${this.maxTotalBytes}-byte total cap`);
+          }
+          return true;
+        }
+      });
+    } catch (error) {
+      return importerErr(
+        "CORRUPT_ARCHIVE",
+        `Could not read the archive: ${error.message}`
+      );
+    }
+    const docs = [];
+    for (const entryBytes of Object.values(entries)) {
+      const parsed = parseJsonBytes(entryBytes);
+      if (!parsed.ok) return parsed;
+      docs.push(parsed.value);
+    }
+    if (docs.length === 0) {
+      return importerErr("EMPTY_EXPORT", "The archive contained no .json files.");
+    }
+    return ok(docs);
+  }
+};
+
+// src/importers/infra/parsers/chatgpt-parser.ts
+import { z as z2 } from "zod";
+var ChatgptMessage = z2.object({
+  author: z2.object({ role: z2.string().optional() }).nullish(),
+  content: z2.object({ parts: z2.array(z2.unknown()).optional() }).nullish(),
+  create_time: z2.number().nullish()
+});
+var ChatgptConversation = z2.object({
+  id: z2.string().optional(),
+  conversation_id: z2.string().optional(),
+  title: z2.string().optional(),
+  create_time: z2.number().nullish(),
+  mapping: z2.record(z2.string(), z2.object({ message: ChatgptMessage.nullish() }))
+});
+var HasMapping = z2.object({ mapping: z2.record(z2.string(), z2.unknown()) });
+function toArray(doc) {
+  if (Array.isArray(doc)) return doc;
+  if (doc !== null && typeof doc === "object" && "conversations" in doc) {
+    const inner = doc.conversations;
+    return Array.isArray(inner) ? inner : null;
+  }
+  return null;
+}
+function mapRole(role) {
+  return role === "user" || role === "assistant" || role === "system" ? role : null;
+}
+function joinParts(parts) {
+  if (!parts) return "";
+  return parts.filter((part) => typeof part === "string").join("\n");
+}
+function linearize(data, index) {
+  const timed = [];
+  for (const node of Object.values(data.mapping)) {
+    const raw = node.message;
+    const role = mapRole(raw?.author?.role);
+    if (raw === null || raw === void 0 || role === null) continue;
+    const text = joinParts(raw.content?.parts);
+    if (text.trim().length === 0) continue;
+    const time = typeof raw.create_time === "number" ? raw.create_time : 0;
+    const message = {
+      role,
+      content: text,
+      ...typeof raw.create_time === "number" ? { createdAt: new Date(raw.create_time * 1e3) } : {}
+    };
+    timed.push({ message, time });
+  }
+  timed.sort((a, b) => a.time - b.time);
+  const firstTime = timed[0]?.time;
+  const convTime = data.create_time ?? firstTime;
+  return {
+    id: data.id ?? data.conversation_id ?? `chatgpt-${index}`,
+    title: data.title ?? "Untitled",
+    createdAt: typeof convTime === "number" ? new Date(convTime * 1e3) : /* @__PURE__ */ new Date(0),
+    messages: timed.map((entry) => entry.message)
+  };
+}
+var ChatgptParser = class {
+  source = "chatgpt";
+  detect(doc) {
+    const arr = toArray(doc);
+    const first = arr?.[0];
+    return first !== void 0 && HasMapping.safeParse(first).success;
+  }
+  parse(doc) {
+    const arr = toArray(doc);
+    if (arr === null) {
+      return importerErr("MALFORMED_EXPORT", "Expected an array of ChatGPT conversations.");
+    }
+    const conversations = [];
+    const failures = [];
+    for (const [index, raw] of arr.entries()) {
+      const parsed = ChatgptConversation.safeParse(raw);
+      if (!parsed.success) {
+        failures.push({
+          title: `Conversation ${index + 1}`,
+          reason: parsed.error.issues[0]?.message ?? "invalid conversation shape"
+        });
+        continue;
+      }
+      conversations.push(linearize(parsed.data, index));
+    }
+    if (conversations.length === 0 && failures.length === 0) {
+      return importerErr("EMPTY_EXPORT", "No conversations found in the ChatGPT export.");
+    }
+    return ok({ conversations, failures });
+  }
+};
+
+// src/importers/infra/parsers/claude-parser.ts
+import { z as z3 } from "zod";
+var ClaudeMessage = z3.object({
+  sender: z3.string().optional(),
+  text: z3.string().optional(),
+  content: z3.array(z3.object({ type: z3.string().optional(), text: z3.string().optional() })).optional(),
+  created_at: z3.string().optional()
+});
+var ClaudeConversation = z3.object({
+  uuid: z3.string().optional(),
+  name: z3.string().optional(),
+  created_at: z3.string().optional(),
+  chat_messages: z3.array(ClaudeMessage)
+});
+var HasChatMessages = z3.object({ chat_messages: z3.array(z3.unknown()) });
+function parseDate(iso) {
+  if (iso === void 0) return null;
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function messageText(message) {
+  if (message.text !== void 0 && message.text.trim().length > 0) return message.text;
+  if (message.content === void 0) return "";
+  return message.content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+var ClaudeParser = class {
+  source = "claude";
+  detect(doc) {
+    const first = Array.isArray(doc) ? doc[0] : void 0;
+    return first !== void 0 && HasChatMessages.safeParse(first).success;
+  }
+  parse(doc) {
+    if (!Array.isArray(doc)) {
+      return importerErr("MALFORMED_EXPORT", "Expected an array of Claude conversations.");
+    }
+    const conversations = [];
+    const failures = [];
+    for (const [index, raw] of doc.entries()) {
+      const parsed = ClaudeConversation.safeParse(raw);
+      if (!parsed.success) {
+        failures.push({
+          title: `Conversation ${index + 1}`,
+          reason: parsed.error.issues[0]?.message ?? "invalid conversation shape"
+        });
+        continue;
+      }
+      const messages = [];
+      for (const rawMessage of parsed.data.chat_messages) {
+        const role = rawMessage.sender === "human" ? "user" : "assistant";
+        const text = messageText(rawMessage);
+        if (text.trim().length === 0) continue;
+        const at = parseDate(rawMessage.created_at);
+        messages.push({ role, content: text, ...at === null ? {} : { createdAt: at } });
+      }
+      const firstAt = messages[0]?.createdAt;
+      const convAt = parseDate(parsed.data.created_at) ?? firstAt ?? /* @__PURE__ */ new Date(0);
+      conversations.push({
+        id: parsed.data.uuid ?? `claude-${index}`,
+        title: parsed.data.name ?? "Untitled",
+        createdAt: convAt,
+        messages
+      });
+    }
+    if (conversations.length === 0 && failures.length === 0) {
+      return importerErr("EMPTY_EXPORT", "No conversations found in the Claude export.");
+    }
+    return ok({ conversations, failures });
+  }
+};
+
+// src/importers/infra/parsers/generic-parser.ts
+import { z as z4 } from "zod";
+var GENERIC_IMPORT_VERSION = 1;
+var GenericMessage = z4.object({
+  role: z4.enum(["user", "assistant", "system"]),
+  content: z4.string(),
+  createdAt: z4.string().optional()
+});
+var GenericConversation = z4.object({
+  id: z4.string(),
+  title: z4.string().optional(),
+  createdAt: z4.string(),
+  messages: z4.array(GenericMessage)
+});
+var GenericEnvelope = z4.object({
+  valija_import_version: z4.number(),
+  conversations: z4.array(z4.unknown())
+});
+function parseDate2(iso) {
+  if (iso === void 0) return null;
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+var GenericParser = class {
+  source = "generic";
+  detect(doc) {
+    return doc !== null && typeof doc === "object" && !Array.isArray(doc) && "valija_import_version" in doc;
+  }
+  parse(doc) {
+    const envelope = GenericEnvelope.safeParse(doc);
+    if (!envelope.success) {
+      return importerErr("MALFORMED_EXPORT", "Not a valija generic import envelope.");
+    }
+    if (envelope.data.valija_import_version !== GENERIC_IMPORT_VERSION) {
+      return importerErr(
+        "UNSUPPORTED_GENERIC_VERSION",
+        `Unsupported generic import version ${envelope.data.valija_import_version}; this valija supports version ${GENERIC_IMPORT_VERSION}.`
+      );
+    }
+    const conversations = [];
+    const failures = [];
+    for (const [index, raw] of envelope.data.conversations.entries()) {
+      const parsed = GenericConversation.safeParse(raw);
+      if (!parsed.success) {
+        failures.push({
+          title: `Conversation ${index + 1}`,
+          reason: parsed.error.issues[0]?.message ?? "invalid conversation shape"
+        });
+        continue;
+      }
+      const createdAt = parseDate2(parsed.data.createdAt);
+      if (createdAt === null) {
+        failures.push({
+          title: parsed.data.title ?? parsed.data.id,
+          reason: `Invalid createdAt: "${parsed.data.createdAt}"`
+        });
+        continue;
+      }
+      const messages = parsed.data.messages.map((message) => {
+        const at = parseDate2(message.createdAt);
+        return {
+          role: message.role,
+          content: message.content,
+          ...at === null ? {} : { createdAt: at }
+        };
+      });
+      conversations.push({
+        id: parsed.data.id,
+        title: parsed.data.title ?? "Untitled",
+        createdAt,
+        messages
+      });
+    }
+    if (conversations.length === 0 && failures.length === 0) {
+      return importerErr("EMPTY_EXPORT", "No conversations found in the generic export.");
+    }
+    return ok({ conversations, failures });
+  }
+};
+
+// src/importers/infra/parser-registry.ts
+var chatgpt = new ChatgptParser();
+var claude = new ClaudeParser();
+var generic = new GenericParser();
+var BY_SOURCE = { chatgpt, claude, generic };
+var parserRegistry = {
+  autodetect: [chatgpt, claude],
+  forSource: (source) => BY_SOURCE[source]
+};
+
 // src/shared/infra/vault-paths.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -716,10 +1464,22 @@ function resolveVaultPaths(rootOverride) {
   };
 }
 
-// src/vault/application/hex.ts
+// src/vault/domain/values/key-hex.ts
 var bytesToHex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 var isKeyHex = (value) => /^[0-9a-f]{64}$/i.test(value);
 
+// src/vault/domain/values/passphrase.ts
+var MIN_PASSPHRASE_LENGTH = 8;
+function parsePassphrase(raw) {
+  if (raw.length < MIN_PASSPHRASE_LENGTH) {
+    return vaultErr(
+      "WEAK_PASSPHRASE",
+      `Passphrase must be at least ${MIN_PASSPHRASE_LENGTH} characters.`
+    );
+  }
+  return ok(raw);
+}
+
 // src/vault/application/ports/crypto.ts
 var DEFAULT_KDF_PARAMS = {
   algorithm: "argon2id",
@@ -728,8 +1488,7 @@ var DEFAULT_KDF_PARAMS = {
   parallelism: 1
 };
 
-// src/vault/application/create-vault.ts
-var MIN_PASSPHRASE_LENGTH = 8;
+// src/vault/application/use-cases/create-vault.use-case.ts
 var CreateVault = class {
   constructor(store, crypto, keychain, clock, idGen) {
     this.store = store;
@@ -747,26 +1506,38 @@ var CreateVault = class {
     if (this.store.headerExists()) {
       return vaultErr("VAULT_ALREADY_EXISTS", "A vault already exists on this machine.");
     }
-    if (passphrase.length < MIN_PASSPHRASE_LENGTH) {
-      return vaultErr(
-        "WEAK_PASSPHRASE",
-        `Passphrase must be at least ${MIN_PASSPHRASE_LENGTH} characters.`
-      );
-    }
+    const parsed = parsePassphrase(passphrase);
+    if (!parsed.ok) return parsed;
+    const vault = await this.forgeVault(parsed.value);
+    this.store.writeHeader(vault.header);
+    const initialized = this.store.initializeDb(vault.keyHex);
+    if (!initialized.ok) return initialized;
+    this.keychain.setKey(vault.header.vaultId, vault.keyHex);
+    return ok({
+      vaultId: vault.header.vaultId,
+      keyHex: vault.keyHex,
+      createdAt: vault.header.createdAt
+    });
+  }
+  /** Mint the vault identity: id + salt + key derived from the passphrase. */
+  async forgeVault(passphrase) {
     const vaultId = this.idGen.next();
     const salt = this.crypto.generateSalt();
     const key = await this.crypto.deriveKey(passphrase, salt, DEFAULT_KDF_PARAMS);
-    const keyHex = bytesToHex(key);
-    const createdAt = this.clock.now().toISOString();
-    this.store.writeHeader({ vaultId, schemaVersion: 1, kdf: DEFAULT_KDF_PARAMS, salt, createdAt });
-    const init = this.store.initializeDb(keyHex);
-    if (!init.ok) return init;
-    this.keychain.setKey(vaultId, keyHex);
-    return ok({ vaultId, keyHex, createdAt });
+    return {
+      header: {
+        vaultId,
+        schemaVersion: 1,
+        kdf: DEFAULT_KDF_PARAMS,
+        salt,
+        createdAt: this.clock.now().toISOString()
+      },
+      keyHex: bytesToHex(key)
+    };
   }
 };
 
-// src/vault/application/lock-vault.ts
+// src/vault/application/use-cases/lock-vault.use-case.ts
 var LockVault = class {
   constructor(store, keychain) {
     this.store = store;
@@ -782,7 +1553,7 @@ var LockVault = class {
   }
 };
 
-// src/vault/application/unlock-vault.ts
+// src/vault/application/use-cases/unlock-vault.use-case.ts
 var UnlockVault = class {
   constructor(store, crypto, keychain) {
     this.store = store;
@@ -795,30 +1566,30 @@ var UnlockVault = class {
   async execute(input) {
     const header = this.store.readHeader();
     if (!header.ok) return header;
-    let keyHex;
+    const keyHex = await this.resolveKey(input, header.value);
+    if (!keyHex.ok) return keyHex;
+    const verified = this.store.verifyKey(keyHex.value);
+    if (!verified.ok) return verified;
+    this.keychain.setKey(header.value.vaultId, keyHex.value);
+    return ok({ vaultId: header.value.vaultId });
+  }
+  /** A recovery key is used as-is; a passphrase is derived with the header's salt + KDF params. */
+  async resolveKey(input, header) {
     if (input.recoveryKeyHex !== void 0) {
       if (!isKeyHex(input.recoveryKeyHex)) {
         return vaultErr("WRONG_PASSPHRASE", "Recovery key must be 64 hex characters.");
       }
-      keyHex = input.recoveryKeyHex.toLowerCase();
-    } else if (input.passphrase !== void 0) {
-      const key = await this.crypto.deriveKey(
-        input.passphrase,
-        header.value.salt,
-        header.value.kdf
-      );
-      keyHex = bytesToHex(key);
-    } else {
-      return vaultErr("WRONG_PASSPHRASE", "Provide a passphrase or a recovery key.");
+      return ok(input.recoveryKeyHex.toLowerCase());
     }
-    const verified = this.store.verifyKey(keyHex);
-    if (!verified.ok) return verified;
-    this.keychain.setKey(header.value.vaultId, keyHex);
-    return ok({ vaultId: header.value.vaultId });
+    if (input.passphrase !== void 0) {
+      const key = await this.crypto.deriveKey(input.passphrase, header.salt, header.kdf);
+      return ok(bytesToHex(key));
+    }
+    return vaultErr("WRONG_PASSPHRASE", "Provide a passphrase or a recovery key.");
   }
 };
 
-// src/vault/application/vault-status.ts
+// src/vault/application/use-cases/vault-status.use-case.ts
 var VaultStatus = class {
   constructor(store, keychain) {
     this.store = store;
@@ -882,7 +1653,7 @@ var FileVaultStore = class {
   initializeDb(keyHex) {
     try {
       const db = openVaultDb(this.paths.db, keyHex);
-      migrate(db);
+      migrate(db, this.paths.db);
       db.close();
       return ok(void 0);
     } catch (error) {
@@ -937,8 +1708,8 @@ function buildContainer() {
   const store = new FileVaultStore(paths);
   const crypto = new Argon2VaultCrypto();
   const keychain = new OsKeychain();
-  const sessions = new SqliteVaultSessionFactory(paths, keychain);
-  const getContextPack = new GetContextPack(sessions, systemClock);
+  const sessions = new SqliteVaultSessions(paths, keychain);
+  const importItems = new ImportItems(sessions, systemClock, ulidIds);
   return {
     paths,
     createVault: new CreateVault(store, crypto, keychain, systemClock, ulidIds),
@@ -948,19 +1719,64 @@ function buildContainer() {
     saveContext: new SaveContext(sessions, systemClock, ulidIds),
     listProjects: new ListProjects(sessions),
     searchContext: new SearchContext(sessions),
-    getContextPack,
-    exportPack: new ExportPack(sessions, getContextPack),
-    showProject: new ShowProject(sessions)
+    getContextPack: new GetContextPack(sessions, systemClock),
+    showProject: new ShowProject(sessions),
+    importConversations: new ImportConversations(
+      new FileExportReader(),
+      parserRegistry,
+      importItems,
+      systemClock
+    )
   };
 }
 
 // src/delivery/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
+import { z as z5 } from "zod";
+
+// src/delivery/context-pack-markdown.ts
+var TYPE_LABELS = {
+  decision: "Decisions",
+  preference: "Preferences",
+  progress: "Progress",
+  fact: "Facts",
+  handoff: "Handoffs"
+};
+var sectionTitle = (section) => {
+  switch (section.kind) {
+    case "pinned":
+      return "Pinned";
+    case "latest-handoff":
+      return "Latest handoff";
+    case "by-type":
+      return TYPE_LABELS[section.type];
+  }
+};
+var renderItem = (item) => {
+  const date = item.createdAt.toISOString().slice(0, 10);
+  const tags = item.tags.length > 0 ? ` \xB7 ${item.tags.map((t) => `#${t}`).join(" ")}` : "";
+  return `### ${item.type} \xB7 ${date}${tags}
+
+${item.content}
+`;
+};
+function renderContextPackMarkdown(pack) {
+  const header = `# Context pack: ${pack.projectName}
+
+> ${pack.totalCount} items in vault \xB7 generated ${pack.generatedAt.toISOString()}
+`;
+  const parts = pack.sections.flatMap((section) => [
+    `
+## ${sectionTitle(section)}
+`,
+    ...section.items.map(renderItem)
+  ]);
+  return header + parts.join("\n");
+}
 
 // src/delivery/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
 // src/delivery/mcp/server.ts
 var ok2 = (text) => ({ content: [{ type: "text", text }] });
@@ -984,10 +1800,10 @@ function buildMcpServer(c) {
       title: "Save context",
       description: DESCRIPTIONS.save_context,
       inputSchema: {
-        project: z2.string().describe("Project slug, e.g. 'vault-app'. Created if it does not exist."),
-        content: z2.string().describe("Self-contained markdown. Max 32 KB."),
-        type: z2.enum(ITEM_TYPES).optional().describe("Kind of context. Defaults to 'fact'."),
-        tags: z2.array(z2.string()).max(10).optional().describe("Lowercase tags for recall.")
+        project: z5.string().describe("Project slug, e.g. 'vault-app'. Created if it does not exist."),
+        content: z5.string().describe("Self-contained markdown. Max 32 KB."),
+        type: z5.enum(ITEM_TYPES).optional().describe("Kind of context. Defaults to 'fact'."),
+        tags: z5.array(z5.string()).max(10).optional().describe("Lowercase tags for recall.")
       }
     },
     async ({ project, content, type, tags }) => {
@@ -1011,8 +1827,8 @@ function buildMcpServer(c) {
       title: "Save handoff",
       description: DESCRIPTIONS.save_handoff,
       inputSchema: {
-        project: z2.string().describe("Project slug. Created if it does not exist."),
-        content: z2.string().describe("Goal, what was done, blockers, exact next step, relevant files or links.")
+        project: z5.string().describe("Project slug. Created if it does not exist."),
+        content: z5.string().describe("Goal, what was done, blockers, exact next step, relevant files or links.")
       }
     },
     async ({ project, content }) => {
@@ -1033,8 +1849,8 @@ function buildMcpServer(c) {
       title: "Get context pack",
       description: DESCRIPTIONS.get_context,
       inputSchema: {
-        project: z2.string().describe("Project slug to load."),
-        budget: z2.number().int().positive().optional().describe("Token budget. Default 4000.")
+        project: z5.string().describe("Project slug to load."),
+        budget: z5.number().int().positive().optional().describe("Token budget. Default 4000.")
       }
     },
     async ({ project, budget }) => {
@@ -1043,7 +1859,7 @@ function buildMcpServer(c) {
         ...budget === void 0 ? {} : { budgetTokens: budget }
       });
       if (!r.ok) return err2(r.error);
-      return ok2(r.value.markdown);
+      return ok2(renderContextPackMarkdown(r.value));
     }
   );
   server.registerTool(
@@ -1052,9 +1868,9 @@ function buildMcpServer(c) {
       title: "Search context",
       description: DESCRIPTIONS.search_context,
       inputSchema: {
-        query: z2.string().describe("Full-text query, e.g. 'auth decision'."),
-        project: z2.string().optional().describe("Limit to one project."),
-        limit: z2.number().int().positive().max(100).optional().describe("Max results. Default 20.")
+        query: z5.string().describe("Full-text query, e.g. 'auth decision'."),
+        project: z5.string().optional().describe("Limit to one project."),
+        limit: z5.number().int().positive().max(100).optional().describe("Max results. Default 20.")
       }
     },
     async ({ query, project, limit }) => {
@@ -1095,7 +1911,7 @@ ${lines.join("\n")}`);
     {
       title: "Save session context to valija",
       description: "Distill this session into a self-contained context save.",
-      argsSchema: { project: z2.string().optional() }
+      argsSchema: { project: z5.string().optional() }
     },
     ({ project }) => ({
       messages: [
@@ -1119,7 +1935,7 @@ ${lines.join("\n")}`);
     {
       title: "Load project context from valija",
       description: "Load a project's context pack and resume work.",
-      argsSchema: { project: z2.string() }
+      argsSchema: { project: z5.string() }
     },
     ({ project }) => ({
       messages: [
@@ -1177,7 +1993,10 @@ function projectsCommand(c) {
   }
 }
 function showCommand(c, project, options) {
-  const result = c.showProject.execute(project, options.type);
+  const result = c.showProject.execute({
+    project,
+    ...options.type === void 0 ? {} : { type: options.type }
+  });
   if (!result.ok) fail(result.error);
   if (result.value.length === 0) {
     console.log("No items.");
@@ -1207,9 +2026,17 @@ function searchCommand(c, query, options) {
     );
   }
 }
+var exportMarkdown = (c, project) => {
+  const pack = c.getContextPack.execute({ project, budgetTokens: Number.POSITIVE_INFINITY });
+  return pack.ok ? ok(renderContextPackMarkdown(pack.value)) : pack;
+};
+var exportJson = (c, project) => {
+  const items = c.showProject.execute({ project });
+  return items.ok ? ok(JSON.stringify({ project, items: items.value }, null, 2)) : items;
+};
 function exportCommand(c, project, options) {
   const format = options.json ? "json" : "md";
-  const result = c.exportPack.execute(project, format);
+  const result = options.json ? exportJson(c, project) : exportMarkdown(c, project);
   if (!result.ok) fail(result.error);
   if (options.output !== void 0) {
     writeFileSync2(options.output, result.value, "utf8");
@@ -1220,10 +2047,10 @@ function exportCommand(c, project, options) {
 }
 
 // src/delivery/cli/doctor.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 
 // src/delivery/cli/installer.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 var CLIENTS = ["claude-code", "claude-desktop", "cursor"];
@@ -1248,24 +2075,32 @@ function clientConfigPath(client, platform = process.platform) {
     }
   }
 }
-function installIntoClient(client) {
-  const configPath = clientConfigPath(client);
-  let existing = {};
-  let backupPath = null;
-  if (existsSync3(configPath)) {
-    const raw = readFileSync2(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error(`${configPath} does not contain a JSON object; not touching it.`);
-    }
-    existing = parsed;
-    backupPath = `${configPath}.backup-${Date.now()}`;
-    copyFileSync(configPath, backupPath);
-  } else {
+function readExistingConfig(configPath) {
+  if (!existsSync3(configPath)) return {};
+  const parsed = JSON.parse(readFileSync3(configPath, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${configPath} does not contain a JSON object; not touching it.`);
+  }
+  return parsed;
+}
+function backupExisting(configPath) {
+  if (!existsSync3(configPath)) {
     mkdirSync3(dirname2(configPath), { recursive: true });
+    return null;
   }
+  const backupPath = `${configPath}.backup-${Date.now()}`;
+  copyFileSync2(configPath, backupPath);
+  return backupPath;
+}
+function mergeValijaEntry(existing) {
   const servers = typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {};
-  const merged = { ...existing, mcpServers: { ...servers, valija: MCP_ENTRY } };
+  return { ...existing, mcpServers: { ...servers, valija: MCP_ENTRY } };
+}
+function installIntoClient(client) {
+  const configPath = clientConfigPath(client);
+  const existing = readExistingConfig(configPath);
+  const backupPath = backupExisting(configPath);
+  const merged = mergeValijaEntry(existing);
   writeFileSync3(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   return { configPath, backupPath };
@@ -1278,59 +2113,69 @@ function manualInstructions(client) {
 }
 
 // src/delivery/cli/doctor.ts
-async function doctorCommand(c) {
-  const checks = [];
+function checkNode() {
   const [major] = process.versions.node.split(".").map(Number);
-  checks.push({
+  return {
     name: "node",
     ok: (major ?? 0) >= 22,
     detail: `v${process.versions.node} (need >=22)`,
     fatal: true
-  });
+  };
+}
+async function checkSqlcipher() {
   try {
     const { default: Db } = await import("better-sqlite3-multiple-ciphers");
     const db = new Db(":memory:");
     db.pragma("cipher='sqlcipher'");
     db.close();
-    checks.push({ name: "sqlcipher", ok: true, detail: "native module loads" });
+    return { name: "sqlcipher", ok: true, detail: "native module loads" };
   } catch (e) {
-    checks.push({ name: "sqlcipher", ok: false, detail: e.message, fatal: true });
+    return { name: "sqlcipher", ok: false, detail: e.message, fatal: true };
   }
+}
+function checkKeychain() {
   try {
     const keychain = new OsKeychain();
     keychain.setKey("doctor-probe", "test");
     const roundtrip = keychain.getKey("doctor-probe") === "test";
     keychain.deleteKey("doctor-probe");
-    checks.push({ name: "keychain", ok: roundtrip, detail: "OS keychain read/write" });
+    return { name: "keychain", ok: roundtrip, detail: "OS keychain read/write" };
   } catch (e) {
-    checks.push({ name: "keychain", ok: false, detail: e.message });
+    return { name: "keychain", ok: false, detail: e.message };
   }
+}
+function checkVault(c) {
   const status = c.vaultStatus.execute();
-  if (status.ok) {
-    checks.push({
-      name: "vault",
-      ok: status.value.initialized,
-      detail: status.value.initialized ? `${status.value.unlocked ? "unlocked" : "locked"} at ${status.value.dbPath}` : 'not initialized \u2014 run "valija init"'
-    });
-  } else {
-    checks.push({ name: "vault", ok: false, detail: status.error.message });
-  }
-  for (const client of CLIENTS) {
-    const path = clientConfigPath(client);
-    let detail = "config not found";
-    let installed = false;
-    if (existsSync4(path)) {
-      detail = "config found, valija not installed";
-      try {
-        const parsed = JSON.parse(readFileSync3(path, "utf8"));
-        installed = parsed.mcpServers?.valija !== void 0;
-        if (installed) detail = "valija installed";
-      } catch {
-        detail = "config exists but is not valid JSON";
-      }
-    }
-    checks.push({ name: client, ok: installed, detail });
+  if (!status.ok) return { name: "vault", ok: false, detail: status.error.message };
+  return {
+    name: "vault",
+    ok: status.value.initialized,
+    detail: status.value.initialized ? `${status.value.unlocked ? "unlocked" : "locked"} at ${status.value.dbPath}` : 'not initialized \u2014 run "valija init"'
+  };
+}
+function checkClient(client) {
+  const path = clientConfigPath(client);
+  if (!existsSync4(path)) return { name: client, ok: false, detail: "config not found" };
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const installed = parsed.mcpServers?.valija !== void 0;
+    return {
+      name: client,
+      ok: installed,
+      detail: installed ? "valija installed" : "config found, valija not installed"
+    };
+  } catch {
+    return { name: client, ok: false, detail: "config exists but is not valid JSON" };
   }
+}
+async function doctorCommand(c) {
+  const checks = [
+    checkNode(),
+    await checkSqlcipher(),
+    checkKeychain(),
+    checkVault(c),
+    ...CLIENTS.map(checkClient)
+  ];
   let fatal = false;
   for (const check of checks) {
     console.log(`${check.ok ? "\u2713" : "\u2717"} ${check.name.padEnd(16)} ${check.detail}`);
@@ -1339,6 +2184,75 @@ async function doctorCommand(c) {
   if (fatal) process.exit(1);
 }
 
+// src/importers/domain/values/import-source.ts
+var IMPORT_SOURCES = ["chatgpt", "claude", "generic"];
+function parseImportSource(raw) {
+  if (IMPORT_SOURCES.includes(raw)) {
+    return ok(raw);
+  }
+  return importerErr(
+    "UNSUPPORTED_SOURCE",
+    `Source must be one of ${IMPORT_SOURCES.join(", ")}. Got: "${raw}"`
+  );
+}
+
+// src/delivery/cli/import-command.ts
+function importCommand(c, file, options) {
+  const hasSelection = options.all === true || options.pick !== void 0 || options.query !== void 0 || options.since !== void 0;
+  if (hasSelection && options.project === void 0) {
+    console.error("error: -p <project> is required to import. Run with --list first to preview.");
+    process.exit(1);
+  }
+  const input = {
+    filePath: file,
+    ...options.project === void 0 ? {} : { projectName: options.project },
+    ...options.from === void 0 ? {} : { from: resolveSource(options.from) },
+    ...options.list === void 0 ? {} : { list: options.list },
+    ...options.pick === void 0 ? {} : { pick: options.pick },
+    ...options.query === void 0 ? {} : { query: options.query },
+    ...options.since === void 0 ? {} : { since: options.since },
+    ...options.all === void 0 ? {} : { all: options.all },
+    ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }
+  };
+  const result = c.importConversations.execute(input);
+  if (!result.ok) fail(result.error);
+  if (result.value.mode === "list") renderListing(result.value);
+  else renderSummary(result.value);
+}
+function resolveSource(raw) {
+  const parsed = parseImportSource(raw);
+  if (!parsed.ok) fail(parsed.error);
+  return parsed.value;
+}
+function renderListing(summary) {
+  const rows = summary.listing ?? [];
+  if (rows.length === 0) {
+    console.log("No conversations found in this export.");
+    return;
+  }
+  console.log(`${rows.length} conversation(s) in this ${summary.source} export:
+`);
+  console.log("  #  DATE        CHUNKS  TITLE");
+  for (const row of rows) {
+    console.log(
+      `${String(row.index).padStart(3)}  ${row.date}  ${String(row.estimatedChunks).padStart(6)}  ${truncate(row.title, 48)}`
+    );
+  }
+  console.log(
+    "\nSelect with --pick 1,3-5, --query <text>, --since <YYYY-MM-DD>, or --all. Add --dry-run to preview."
+  );
+}
+function renderSummary(summary) {
+  const target = summary.project === void 0 ? "" : ` into "${summary.project}"`;
+  const verb = summary.mode === "dry-run" ? "Would import" : "Imported";
+  console.log(
+    `${verb} ${summary.imported} item(s) from ${summary.conversations} conversation(s)${target} (skipped ${summary.skipped}, failed ${summary.failed}).`
+  );
+  for (const failure of summary.failures) {
+    console.error(`  failed: ${failure.conversation} \u2014 ${failure.reason}`);
+  }
+}
+
 // src/vault/infra/recovery-kit.ts
 function renderRecoveryKit(vaultId, keyHex, createdAt) {
   return `================================================================
@@ -1490,7 +2404,7 @@ program.command("unlock").description("Unlock the vault for this session (key go
 program.command("lock").description("Lock the vault (remove the key from the OS keychain).").action(() => lockCommand(container));
 program.command("status").description("Show vault location and lock state.").action(() => statusCommand(container));
 program.command("projects").description("List projects with item counts and last activity.").action(() => projectsCommand(container));
-program.command("show").description("Print the items of a project.").argument("<project>", "project slug").option("--type <type>", "filter by type (decision|progress|preference|fact|handoff)").action(
+program.command("show").description("Print the items of a project.").argument("<project>", "project slug").option("--type <type>", "filter by type (decision|progress|preference|fact|handoff|imported)").action(
   (project, options) => showCommand(container, project, options)
 );
 program.command("search").description("Full-text search across saved context.").argument("<query>", "search terms").option("-p, --project <project>", "limit to one project").action(
@@ -1499,6 +2413,9 @@ program.command("search").description("Full-text search across saved context.").
 program.command("export").description("Export a project's context pack (markdown by default).").argument("<project>", "project slug").option("--json", "export as JSON instead of markdown").option("-o, --output <file>", "write to a file instead of stdout").action(
   (project, options) => exportCommand(container, project, options)
 );
+program.command("import").description("Import chatbot history (ChatGPT/Claude/generic export) into the vault.").argument("<file>", "path to an export file (.json or .zip)").option("-p, --project <project>", "target project (required to import; created if new)").option("--from <source>", "chatgpt | claude | generic (auto-detected if omitted)").option("--list", "list conversations and exit (the default when no selection is given)").option("--pick <spec>", "1-based indices/ranges into the list, e.g. 1,3-5").option("--query <text>", "select conversations whose title contains this text").option("--since <date>", "select conversations on or after YYYY-MM-DD").option("--all", "import every conversation").option("--dry-run", "report what would be imported; write nothing").action(
+  (file, options) => importCommand(container, file, options)
+);
 program.command("install").description("Wire the valija MCP server into an AI tool's config.").argument("<client>", `one of: ${CLIENTS.join(", ")}`).action((client) => {
   if (!CLIENTS.includes(client)) {
     console.error(`error: unknown client "${client}". Use one of: ${CLIENTS.join(", ")}`);