codetrap 0.1.7 → 0.1.8

package/src/db/queries.ts

@@ -179,10 +179,6 @@ export function listTrapEvidence(db: Database, trapId: number): TrapEvidence[] {
     .all(trapId) as TrapEvidence[];
 }
 
-export function archiveTrap(db: Database, id: number): boolean {
-  return markTrapArchived(db, id);
-}
-
 export function markTrapArchived(db: Database, id: number): boolean {
   const result = db
     .prepare(
@@ -198,27 +194,6 @@ export function markTrapArchived(db: Database, id: number): boolean {
   return result.changes > 0;
 }
 
-export function supersedeTrap(
-  db: Database,
-  id: number,
-  supersededById: number,
-  stateKey?: string
-): boolean {
-  if (id === supersededById) return false;
-
-  const oldTrap = getTrap(db, id);
-  const newTrap = getTrap(db, supersededById);
-  if (!oldTrap || !newTrap) return false;
-
-  const key = stateKey ?? oldTrap.state_key ?? newTrap.state_key ?? `trap:${id}`;
-  const tx = db.transaction(() => {
-    markTrapSuperseded(db, id, key);
-    markTrapSuperseding(db, supersededById, id, key);
-  });
-  tx();
-  return true;
-}
-
 export function markTrapSuperseded(db: Database, id: number, stateKey: string): boolean {
   const result = db.prepare(supersedeTrapSql).run(stateKey, id);
   return result.changes > 0;

package/src/db/repository.ts

@@ -11,32 +11,39 @@ import type {
 import { SearchService, type SearchOptions } from "../lib/search-service";
 import {
   type EmbeddingConfig,
-  type EmbeddingProvider,
   type StoredEmbedding,
 } from "../lib/embedder";
+import {
+  embeddingRuntimeFrom,
+  type EmbeddingRuntime,
+  type EmbeddingRuntimeInput,
+} from "../lib/embedding-runtime";
 import { runEmbeddingJob } from "../lib/embedding-job";
 import { passageFieldsChanged } from "../lib/trap-search-document";
+import * as embeddingQueries from "./embedding-queries";
 import * as queries from "./queries";
 import type { TrapStatus } from "../lib/constants";
 import { TrapSearchPolicy } from "../lib/search-policy";
-import { DatabaseEmbeddingIndex } from "../lib/embedding-index";
+import type { RankingConfig } from "../lib/search-policy";
 import { archiveTrapLifecycle, supersedeTrapLifecycle } from "../lib/trap-lifecycle";
+import type { EmbeddingProfileSummary } from "./embedding-queries";
 
 export type TrapStats = ReturnType<typeof queries.getStats>;
-export type EmbeddingStateCounts = ReturnType<DatabaseEmbeddingIndex["stateCounts"]>;
+export type EmbeddingStateCounts = ReturnType<typeof embeddingQueries.getEmbeddingStateCounts>;
 export type TrapRecordInsert = queries.TrapRecordInsert;
 
 export class TrapRepository {
   private readonly searchService: SearchService;
   private readonly searchPolicy = new TrapSearchPolicy();
-  private readonly embeddingIndex: DatabaseEmbeddingIndex;
+  private readonly embeddings: EmbeddingRuntime;
 
   constructor(
     private readonly db: Database,
-    private readonly embedder?: EmbeddingProvider
+    embeddings?: EmbeddingRuntimeInput,
+    ranking?: RankingConfig
   ) {
-    this.searchService = new SearchService(db, embedder);
-    this.embeddingIndex = new DatabaseEmbeddingIndex(db);
+    this.embeddings = embeddingRuntimeFrom(embeddings);
+    this.searchService = new SearchService(db, this.embeddings, ranking);
   }
 
   add(input: TrapInput): number {
@@ -79,7 +86,7 @@ export class TrapRepository {
   update(id: number, input: TrapUpdate): boolean {
     const success = queries.updateTrap(this.db, id, input);
     if (success && passageFieldsChanged(input)) {
-      this.embeddingIndex.delete(id);
+      embeddingQueries.deleteEmbedding(this.db, id);
     }
     return success;
   }
@@ -114,7 +121,11 @@ export class TrapRepository {
   }
 
   embeddingStats(config: EmbeddingConfig | null, opts: { scope?: string; status?: TrapStatus | "all" } = {}): EmbeddingStateCounts {
-    return this.embeddingIndex.stateCounts(config, opts);
+    return embeddingQueries.getEmbeddingStateCounts(this.db, config, opts);
+  }
+
+  embeddingProfiles(opts: { scope?: string; status?: TrapStatus | "all" } = {}): EmbeddingProfileSummary[] {
+    return embeddingQueries.listEmbeddingProfiles(this.db, opts);
   }
 
   exportAll(): TrapExportRecord[] {
@@ -145,23 +156,23 @@ export class TrapRepository {
     return this.db.transaction(callback)();
   }
 
-  getEmbedding(trapId: number): StoredEmbedding | null {
-    return this.embeddingIndex.get(trapId);
+  getEmbedding(trapId: number, config?: EmbeddingConfig): StoredEmbedding | null {
+    return embeddingQueries.getEmbedding(this.db, trapId, config);
   }
 
   upsertEmbedding(record: StoredEmbedding): void {
-    this.embeddingIndex.save(record);
+    embeddingQueries.upsertEmbedding(this.db, record);
   }
 
   deleteEmbedding(trapId: number): void {
-    this.embeddingIndex.delete(trapId);
+    embeddingQueries.deleteEmbedding(this.db, trapId);
   }
 
   getTrapsNeedingEmbeddings(
     config: EmbeddingConfig,
     opts: { scope?: string; category?: string; status?: TrapStatus | "all"; force?: boolean; limit?: number } = {}
   ): Trap[] {
-    return this.embeddingIndex.trapsNeedingEmbeddings(config, opts);
+    return embeddingQueries.getTrapsNeedingEmbeddings(this.db, config, opts);
   }
 
   async ensureEmbeddings(opts: { scope?: string; category?: string; limit?: number; force?: boolean; batchSize?: number } = {}): Promise<{
@@ -169,18 +180,18 @@ export class TrapRepository {
     skipped: number;
     batches: number;
   }> {
-    if (!this.embedder) {
-      throw new Error("Embedding provider is unavailable. Set JINA_API_KEY to generate embeddings.");
-    }
+    const provider = this.embeddings.requireProvider(
+      "Embedding provider is unavailable. Configure an embedding provider to generate embeddings."
+    );
 
     return runEmbeddingJob(
       {
-        countEmbeddable: (countOpts) => this.embeddingIndex.countEmbeddable(countOpts),
+        countEmbeddable: (countOpts) => embeddingQueries.countEmbeddableTraps(this.db, countOpts),
         trapsNeedingEmbeddings: (config, jobOpts) =>
-          this.embeddingIndex.trapsNeedingEmbeddings(config, jobOpts),
-        saveEmbedding: (record) => this.embeddingIndex.save(record),
+          embeddingQueries.getTrapsNeedingEmbeddings(this.db, config, jobOpts),
+        saveEmbedding: (record) => embeddingQueries.upsertEmbedding(this.db, record),
       },
-      this.embedder,
+      provider,
       opts
     );
   }

package/src/db/schema.ts

@@ -175,6 +175,86 @@ function applyMigrations(db: Database, from: number): void {
 
     db.prepare("UPDATE schema_version SET version = ?").run(5);
   }
+
+  if (from < 6) {
+    migrateEmbeddingProfiles(db);
+    db.prepare("UPDATE schema_version SET version = ?").run(6);
+  }
+}
+
+function migrateEmbeddingProfiles(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS embedding_profiles (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      dimensions INTEGER NOT NULL,
+      passage_version INTEGER NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+
+  const hasTrapEmbeddings = tableExists(db, "trap_embeddings");
+  if (!hasTrapEmbeddings || columnExists(db, "trap_embeddings", "profile_id")) {
+    createProfileAwareEmbeddingsTable(db);
+    return;
+  }
+
+  db.exec("ALTER TABLE trap_embeddings RENAME TO trap_embeddings_legacy_v5");
+  createProfileAwareEmbeddingsTable(db);
+
+  db.exec(`
+    INSERT OR IGNORE INTO embedding_profiles (
+      id, provider, model, dimensions, passage_version, created_at, updated_at
+    )
+    SELECT
+      provider || ':' || model || ':' || dimensions || ':p' || passage_version,
+      provider,
+      model,
+      dimensions,
+      passage_version,
+      MIN(updated_at),
+      MAX(updated_at)
+    FROM trap_embeddings_legacy_v5
+    GROUP BY provider, model, dimensions, passage_version;
+
+    INSERT OR REPLACE INTO trap_embeddings (
+      trap_id, profile_id, passage_hash, embedding, updated_at
+    )
+    SELECT
+      trap_id,
+      provider || ':' || model || ':' || dimensions || ':p' || passage_version,
+      passage_hash,
+      embedding,
+      updated_at
+    FROM trap_embeddings_legacy_v5;
+
+    DROP TABLE trap_embeddings_legacy_v5;
+  `);
+}
+
+function createProfileAwareEmbeddingsTable(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS trap_embeddings (
+      trap_id INTEGER NOT NULL REFERENCES traps(id) ON DELETE CASCADE,
+      profile_id TEXT NOT NULL REFERENCES embedding_profiles(id) ON DELETE CASCADE,
+      passage_hash TEXT NOT NULL,
+      embedding BLOB NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (trap_id, profile_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_trap_embeddings_profile
+      ON trap_embeddings(profile_id);
+  `);
+}
+
+function tableExists(db: Database, table: string): boolean {
+  const row = db
+    .query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+    .get(table) as { name: string } | null;
+  return row !== null;
 }
 
 function columnExists(db: Database, table: string, column: string): boolean {

package/src/index.ts

@@ -15,8 +15,12 @@ if (args.length === 0) {
 } else if (args[0] === "serve") {
   import("./mcp/server").then((m) => m.start());
 } else if (args[0] === "web") {
-  const { startWebServerFromArgs } = await import("./web/server");
-  await startWebServerFromArgs(args.slice(1));
+  if (args.slice(1).some(isHelpArg)) {
+    showWebHelp();
+  } else {
+    const { startWebServerFromArgs } = await import("./web/server");
+    await startWebServerFromArgs(args.slice(1));
+  }
 } else if (args[0] === "init") {
   const cwd = process.cwd();
   if (findProjectRoot(cwd)) {
@@ -31,6 +35,10 @@ if (args.length === 0) {
   await run(args, store);
 }
 
+function isHelpArg(arg: string | undefined): boolean {
+  return arg === "--help" || arg === "-h" || arg === "help";
+}
+
 function showHelp(): void {
   console.log("codetrap — capture coding pitfalls so AI doesn't repeat mistakes");
   console.log("");
@@ -45,7 +53,8 @@ function showHelp(): void {
   console.log("  add_trap_evidence     Attach evidence to a trap");
   console.log("  archive_trap          Archive a trap");
   console.log("  supersede_trap        Mark one trap as superseded by another");
-  console.log("  embed                 Generate embeddings for semantic search");
+  console.log("  embed                 Generate embeddings for semantic search (Ollama or Jina)");
+  console.log("  embeddings            Manage embedding profiles, provider config, and reindexing");
   console.log("  session               Record implementation notes and capture candidate traps");
   console.log("  web                   Start local review and trap library console");
   console.log("  export                Export traps as JSON");
@@ -77,3 +86,19 @@ function showHelp(): void {
   console.log("  --to-project-path <path>    Destination project path for scope repair/migration");
   console.log("  --dry-run|--apply       Preview or apply scope repair/migration");
 }
+
+function showWebHelp(): void {
+  console.log("codetrap web — start the local review and trap library console");
+  console.log("");
+  console.log("Usage:");
+  console.log("  codetrap web [--project <path>] [--host <host>] [--port <n>]");
+  console.log("");
+  console.log("Options:");
+  console.log("  --project <path>  Project path to open in the web console");
+  console.log("  --host <host>     Host to bind (default 127.0.0.1)");
+  console.log("  --port <n>        Port to try first (default 4737; next free port is used if busy)");
+  console.log("");
+  console.log("Examples:");
+  console.log("  codetrap web");
+  console.log("  codetrap web --project /path/to/project --port 4789");
+}

package/src/lib/command-requests.ts

@@ -1,5 +1,12 @@
 import { SEARCH_MODES, type SearchMode } from "./constants";
-import type { SearchDefaults } from "./config";
+import type { EmbeddingProviderSetting, EmbeddingSettings, SearchDefaults } from "./config";
+import {
+  DEFAULT_OLLAMA_DIMENSIONS,
+  DEFAULT_OLLAMA_ENDPOINT,
+  DEFAULT_OLLAMA_MODEL,
+} from "./embedder";
+import { capturedTrapMarkdownInput } from "./session-capture";
+import { uniqueStrings as uniqueStringList } from "./string-list";
 import type { SearchTrapsArgs, ListTrapsArgs } from "./trap-operations";
 
 type RawArgs = Record<string, unknown>;
@@ -12,6 +19,10 @@ export type EmbedRequest = {
   batchSize?: number;
 };
 
+export type EmbeddingsUseRequest = {
+  embeddings: EmbeddingSettings;
+};
+
 export type StatsRequest = {
   scope?: string;
 };
@@ -40,6 +51,15 @@ export type SessionCloseRequest = {
   proposeTraps: boolean;
 };
 
+export type SessionCaptureRequest = {
+  trap: Record<string, unknown>;
+  goal?: string;
+  kind?: string;
+  relatedFiles?: string[];
+  sourceRef?: string;
+  evidenceNote?: string;
+};
+
 export type SessionIdRequest = {
   sessionId?: string;
 };
@@ -73,6 +93,12 @@ export type SessionNoteStdin = {
   read: () => string;
 };
 
+export type SessionCaptureInput = {
+  isTTY: boolean;
+  readStdin: () => string;
+  readFile: (path: string) => string;
+};
+
 export function searchRequestFromArgs(query: string, args: RawArgs, defaults: SearchDefaults): SearchTrapsArgs {
   return {
     query,
@@ -117,6 +143,27 @@ export function embedRequestFromArgs(args: RawArgs): EmbedRequest {
   };
 }
 
+export function embeddingsUseRequestFromArgs(
+  positionals: string[],
+  args: RawArgs
+): EmbeddingsUseRequest {
+  const provider = embeddingProviderOption(requiredPositional(positionals, 0, "provider"));
+  if (provider === "jina") {
+    return {
+      embeddings: { provider },
+    };
+  }
+
+  return {
+    embeddings: {
+      provider,
+      endpoint: stringOption(args, "endpoint") ?? DEFAULT_OLLAMA_ENDPOINT,
+      model: stringOption(args, "model") ?? DEFAULT_OLLAMA_MODEL,
+      dimensions: optionalIntOption(args, "dimensions") ?? DEFAULT_OLLAMA_DIMENSIONS,
+    },
+  };
+}
+
 export function evidenceRequestFromArgs(args: RawArgs): RawArgs {
   return {
     source_type: stringOption(args, "source_type", "source-type"),
@@ -175,6 +222,35 @@ export function sessionCloseRequestFromArgs(positionals: string[], args: RawArgs
   };
 }
 
+export function sessionCaptureRequestFromArgs(args: RawArgs, input?: SessionCaptureInput): SessionCaptureRequest {
+  const sources = [
+    args["trap-json"] !== undefined,
+    args["trap-markdown"] !== undefined,
+    args["trap-markdown-file"] !== undefined,
+  ].filter(Boolean).length;
+  if (sources === 0) throw new Error("--trap-json, --trap-markdown, or --trap-markdown-file is required.");
+  if (sources > 1) throw new Error("Choose only one of --trap-json, --trap-markdown, or --trap-markdown-file.");
+
+  const markdown = markdownCaptureInput(args, input);
+  const parsedMarkdown = markdown === undefined ? null : capturedTrapMarkdownInput(markdown);
+  const trap: Record<string, unknown> | undefined = parsedMarkdown
+    ? { ...parsedMarkdown.trap }
+    : jsonObjectOption(args, "trap-json");
+  if (!trap) throw new Error("--trap-json, --trap-markdown, or --trap-markdown-file is required.");
+
+  return {
+    trap,
+    goal: stringOption(args, "goal"),
+    kind: stringOption(args, "kind"),
+    relatedFiles: uniqueStrings([
+      ...(csvOrArrayOption(args, "related_files", "related-files") ?? []),
+      ...(parsedMarkdown?.relatedFiles ?? []),
+    ]),
+    sourceRef: stringOption(args, "source_ref", "source-ref"),
+    evidenceNote: parsedMarkdown?.evidenceNote,
+  };
+}
+
 export function sessionIdRequestFromArgs(positionals: string[]): SessionIdRequest {
   return {
     sessionId: positionals[0],
@@ -249,6 +325,11 @@ function searchModeOption(args: RawArgs, key: string): SearchMode | undefined {
   throw new Error(`Invalid search mode: ${value}. Expected one of: ${SEARCH_MODES.join(", ")}`);
 }
 
+function embeddingProviderOption(value: string): EmbeddingProviderSetting {
+  if (value === "ollama" || value === "jina") return value;
+  throw new Error(`Invalid embedding provider: ${value}. Expected ollama or jina.`);
+}
+
 function booleanOption(args: RawArgs, ...keys: string[]): boolean | undefined {
   for (const key of keys) {
     const value = args[key];
@@ -296,6 +377,36 @@ function jsonObjectOption(args: RawArgs, key: string): Record<string, unknown> |
   }
 }
 
+function markdownCaptureInput(args: RawArgs, input: SessionCaptureInput | undefined): string | undefined {
+  const inline = stringOption(args, "trap-markdown");
+  const file = stringOption(args, "trap-markdown-file");
+  if (inline === undefined && file === undefined) return undefined;
+
+  const text = file !== undefined
+    ? readMarkdownFile(file, input)
+    : inline === "-"
+      ? readMarkdownStdin(input)
+      : inline ?? "";
+  if (text.trim() === "") throw new Error("Markdown trap input is required.");
+  return text;
+}
+
+function readMarkdownStdin(input: SessionCaptureInput | undefined): string {
+  if (!input) throw new Error("--trap-markdown - requires stdin support.");
+  if (input.isTTY) throw new Error("--trap-markdown - requires piped input.");
+  return input.readStdin();
+}
+
+function readMarkdownFile(path: string, input: SessionCaptureInput | undefined): string {
+  if (!input) throw new Error("--trap-markdown-file requires file read support.");
+  return input.readFile(path);
+}
+
+function uniqueStrings(values: string[]): string[] | undefined {
+  const unique = uniqueStringList(values);
+  return unique.length > 0 ? unique : undefined;
+}
+
 function parseDurationDays(value: string): number {
   const match = value.trim().match(/^(\d+)\s*(d|day|days)?$/i);
   if (!match) throw new Error(`Invalid duration: ${value}. Use a value like 90d.`);

package/src/lib/config.ts

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { CODETRAP_DIR, SCOPES, SEARCH_MODES, type Scope, type SearchMode } from "./constants";
+import { isRecord } from "./value-types";
 
 export type CodetrapConfig = {
   search?: {
@@ -10,6 +11,16 @@ export type CodetrapConfig = {
     scope?: Scope;
     rerank?: boolean;
   };
+  embeddings?: EmbeddingSettings;
+};
+
+export type EmbeddingProviderSetting = "ollama" | "jina";
+
+export type EmbeddingSettings = {
+  provider?: EmbeddingProviderSetting;
+  endpoint?: string;
+  model?: string;
+  dimensions?: number;
 };
 
 export type SearchDefaults = {
@@ -19,6 +30,11 @@ export type SearchDefaults = {
   rerank: boolean;
 };
 
+export type ConfigWriteResult = {
+  path: string;
+  config: CodetrapConfig;
+};
+
 const BUILT_IN_SEARCH_DEFAULTS: SearchDefaults = {
   mode: "hybrid",
   limit: 20,
@@ -26,7 +42,7 @@ const BUILT_IN_SEARCH_DEFAULTS: SearchDefaults = {
 };
 
 export function loadCodetrapConfig(home = homedir()): CodetrapConfig {
-  const path = join(home, CODETRAP_DIR, "config.json");
+  const path = codetrapConfigPath(home);
   if (!existsSync(path)) return {};
 
   try {
@@ -38,6 +54,26 @@ export function loadCodetrapConfig(home = homedir()): CodetrapConfig {
   }
 }
 
+export function codetrapConfigPath(home = homedir()): string {
+  return join(home, CODETRAP_DIR, "config.json");
+}
+
+export function writeCodetrapConfig(config: CodetrapConfig, home = homedir()): ConfigWriteResult {
+  const path = codetrapConfigPath(home);
+  mkdirSync(join(home, CODETRAP_DIR), { recursive: true });
+  const normalized = normalizeConfig(config);
+  writeFileSync(path, `${JSON.stringify(normalized, null, 2)}\n`);
+  return { path, config: normalized };
+}
+
+export function setCodetrapEmbeddingSettings(
+  embeddings: EmbeddingSettings,
+  home = homedir()
+): ConfigWriteResult {
+  const current = loadCodetrapConfig(home);
+  return writeCodetrapConfig({ ...current, embeddings }, home);
+}
+
 export function searchDefaultsFromConfig(config = loadCodetrapConfig(), env = process.env): SearchDefaults {
   return {
     mode: config.search?.mode ?? parseSearchModeEnv(env.CODETRAP_SEARCH_MODE) ?? BUILT_IN_SEARCH_DEFAULTS.mode,
@@ -50,7 +86,11 @@ export function searchDefaultsFromConfig(config = loadCodetrapConfig(), env = pr
 function normalizeConfig(value: unknown): CodetrapConfig {
   if (!isRecord(value)) return {};
   const search = isRecord(value.search) ? normalizeSearchConfig(value.search) : undefined;
-  return search ? { search } : {};
+  const embeddings = isRecord(value.embeddings) ? normalizeEmbeddingSettings(value.embeddings) : undefined;
+  return {
+    ...(search ? { search } : {}),
+    ...(embeddings ? { embeddings } : {}),
+  };
 }
 
 function normalizeSearchConfig(value: Record<string, unknown>): CodetrapConfig["search"] {
@@ -62,6 +102,15 @@ function normalizeSearchConfig(value: Record<string, unknown>): CodetrapConfig["
   return out;
 }
 
+function normalizeEmbeddingSettings(value: Record<string, unknown>): EmbeddingSettings {
+  const out: EmbeddingSettings = {};
+  if (typeof value.provider === "string") out.provider = parseEmbeddingProvider(value.provider);
+  if (typeof value.endpoint === "string") out.endpoint = value.endpoint;
+  if (typeof value.model === "string") out.model = value.model;
+  if (typeof value.dimensions === "number") out.dimensions = parsePositiveInt(value.dimensions, "embeddings.dimensions");
+  return out;
+}
+
 function parseSearchModeEnv(value?: string): SearchMode | undefined {
   return value ? parseSearchMode(value) : undefined;
 }
@@ -92,11 +141,12 @@ function parseScope(value: string): Scope {
   throw new Error(`Invalid scope: ${value}. Expected one of: ${SCOPES.join(", ")}`);
 }
 
+function parseEmbeddingProvider(value: string): EmbeddingProviderSetting {
+  if (value === "ollama" || value === "jina") return value;
+  throw new Error("Invalid embeddings.provider: expected one of: ollama, jina");
+}
+
 function parsePositiveInt(value: number, label: string): number {
   if (Number.isInteger(value) && value > 0) return value;
   throw new Error(`Invalid ${label}: expected a positive integer.`);
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/lib/constants.ts

@@ -49,7 +49,7 @@ export const DEFAULT_TRAP_STATUS: TrapStatus = "active";
 
 // Increment this when schema changes in a breaking way.
 // Migrations are stored in src/db/migrations.ts
-export const SCHEMA_VERSION = 5;
+export const SCHEMA_VERSION = 6;
 
 // Directory and file names
 export const CODETRAP_DIR = ".codetrap";