chron-mcp 0.1.26 → 0.1.29

package/README.md

@@ -40,6 +40,8 @@ Chron stores a local audit trail of:
 
 Chron's SIEM integrations send only metadata: session starts, role-only message events, and masked secret detections. Message content and raw secret values stay local.
 
+Need runtime policy enforcement for AI agents? CLAIIM adds agent identity, approval workflows, and ALLOW/DENY gates on top of Chron proof. Try the public preview: https://claiim.io/preview
+
 ---
 
 ## Install

package/dist/cli/index.js

@@ -16582,6 +16582,7 @@ async function initDb(dbPath3) {
   }
   const client = createClient({ url: path.startsWith(":") ? path : `file:${path}` });
   await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 5000");
   await client.execute("PRAGMA foreign_keys = ON");
   for (const sql2 of CREATE_SQL) {
     await client.execute(sql2);
@@ -16614,6 +16615,14 @@ async function initDb(dbPath3) {
   if (!sessCols.includes("metadata")) {
     await client.execute("ALTER TABLE sessions ADD COLUMN metadata TEXT");
   }
+  const ftsCount = await client.execute("SELECT count(*) as n FROM messages_fts");
+  const msgCount = await client.execute("SELECT count(*) as n FROM messages");
+  if (Number(ftsCount.rows[0][0]) < Number(msgCount.rows[0][0])) {
+    await client.execute("DELETE FROM messages_fts");
+    await client.execute(
+      "INSERT INTO messages_fts(rowid, content, session_id) SELECT rowid, content, session_id FROM messages"
+    );
+  }
   return drizzle(client, { schema: schema_exports });
 }
 var import_os, import_fs, import_path, CREATE_SQL;
@@ -16663,11 +16672,81 @@ var init_db2 = __esm({
       `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
       `CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_session_id ON secrets_detected(session_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`
+      `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`,
+      `CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+    content,
+    session_id UNINDEXED,
+    tokenize = 'porter unicode61'
+  )`,
+      `CREATE TRIGGER IF NOT EXISTS messages_fts_ai
+    AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content, session_id)
+      VALUES (new.rowid, new.content, new.session_id);
+    END`,
+      `CREATE TRIGGER IF NOT EXISTS messages_fts_ad
+    AFTER DELETE ON messages BEGIN
+      DELETE FROM messages_fts WHERE rowid = old.rowid;
+    END`
     ];
   }
 });
 
+// src/tools/search.ts
+async function runSearch(db, query, limit = 10) {
+  const client = db.$client;
+  let rows;
+  try {
+    const result = await client.execute({
+      sql: `
+        SELECT
+          messages_fts.session_id                                          AS session_id,
+          snippet(messages_fts, 0, '>>>', '<<<', '\u2026', 24)                 AS excerpt,
+          s.title                                                           AS title,
+          s.ai_tool                                                         AS ai_tool,
+          s.updated_at                                                      AS updated_at
+        FROM messages_fts
+        JOIN sessions s ON s.id = messages_fts.session_id
+        WHERE messages_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `,
+      args: [query, limit * 5]
+      // over-fetch so we can group into limit distinct sessions
+    });
+    rows = result.rows;
+  } catch {
+    return [];
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const sid = String(r.session_id ?? "");
+    if (!sid)
+      continue;
+    if (!map.has(sid)) {
+      map.set(sid, {
+        session_id: sid,
+        title: String(r.title ?? ""),
+        ai_tool: r.ai_tool != null ? String(r.ai_tool) : null,
+        updated_at: String(r.updated_at ?? ""),
+        match_count: 0,
+        excerpts: []
+      });
+    }
+    const entry = map.get(sid);
+    entry.match_count++;
+    if (entry.excerpts.length < 3)
+      entry.excerpts.push(String(r.excerpt ?? ""));
+    if (map.size >= limit && entry.match_count > 1)
+      break;
+  }
+  return Array.from(map.values()).slice(0, limit);
+}
+var init_search = __esm({
+  "src/tools/search.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/history.ts
 var history_exports = {};
 __export(history_exports, {
@@ -16787,12 +16866,43 @@ ${msg.content}
     }
   }
 }
+async function printSearch(query, limit) {
+  const db = await initDb();
+  const results = await runSearch(db, query, limit);
+  if (results.length === 0) {
+    process.stdout.write(`No sessions match: ${query}
+`);
+    return;
+  }
+  process.stdout.write(`
+${BOLD}Search: ${query}${RESET}  ${DIM}(${results.length} session${results.length === 1 ? "" : "s"})${RESET}
+
+`);
+  for (const r of results) {
+    const date = fmtDate(r.updated_at);
+    const prefix = r.session_id.slice(0, 8);
+    const hits = `${r.match_count} hit${r.match_count === 1 ? "" : "s"}`;
+    process.stdout.write(
+      `  ${DIM}${date}${RESET}  ${CYAN}${prefix}${RESET}  ${BOLD}${hits}${RESET}  ${r.title}
+`
+    );
+    for (const excerpt of r.excerpts) {
+      const highlighted = excerpt.replace(/>>>/g, YELLOW).replace(/<<</g, RESET);
+      process.stdout.write(`    ${DIM}\u2026${RESET} ${highlighted}
+`);
+    }
+    process.stdout.write("\n");
+  }
+}
 async function runHistory(args2) {
   const limitArg = args2.find((a) => a.startsWith("--limit="));
   const limit = limitArg ? parseInt(limitArg.split("=")[1], 10) : 20;
   const refArg = args2.find((a) => a.startsWith("--ref="))?.split("=").slice(1).join("=");
+  const searchArg = args2.find((a) => a.startsWith("--search="))?.split("=").slice(1).join("=");
   const positional = args2.filter((a) => !a.startsWith("--"));
-  if (positional.length === 0) {
+  if (searchArg) {
+    await printSearch(searchArg, limit);
+  } else if (positional.length === 0) {
     await printList(limit, refArg);
   } else {
     await printDetail(positional[0]);
@@ -16805,6 +16915,7 @@ var init_history = __esm({
     init_drizzle_orm();
     init_db2();
     init_schema();
+    init_search();
     RESET = "\x1B[0m";
     BOLD = "\x1B[1m";
     DIM = "\x1B[2m";
@@ -17032,12 +17143,16 @@ ${overview.total_detections > 0 ? `<p class="warn">&#9888; ${overview.total_dete
   </tbody>
 </table>
 ${brokenList}
-<p style="font-size:11px;color:#6b7280">
-  Note: This report verifies <em>chain linkage</em> (prev_hash continuity). Full content-hash recomputation
-  (which detects in-place tampering) can be performed with <code>chron verify &lt;session-id&gt;</code>.
-</p>
+	<p style="font-size:11px;color:#6b7280">
+	  Note: This report verifies <em>chain linkage</em> (prev_hash continuity). Full content-hash recomputation
+	  (which detects in-place tampering) can be performed with <code>chron verify &lt;session-id&gt;</code>.
+	</p>
+	<p class="governance-note">
+	  For formal AI governance, CLAIIM extends Chron evidence with agent identity, policy gates,
+	  approvals, and runtime ALLOW/DENY enforcement. See <a href="https://claiim.io/preview">https://claiim.io/preview</a>.
+	</p>
 
-<!-- \u2466 SESSION INVENTORY -->
+	<!-- \u2466 SESSION INVENTORY -->
 <h2 class="section-break">Session Inventory</h2>
 <p>All sessions recorded in the audit database (most recent first, capped at 500 rows).</p>
 <table>
@@ -17161,6 +17276,7 @@ tr:nth-child(even) td { background: #fafafa; }
 .section-break { page-break-before: always; }
 .appendix { background: #f9fafb; border: 1px solid #e5e7eb; border-radius: 6px; padding: 16px 20px; margin-top: 12px; }
 .appendix p, .appendix li { color: #374151; font-size: 12px; }
+.governance-note { background: #f8fafc; border: 1px solid #dbeafe; border-left: 4px solid #2563eb; border-radius: 4px; padding: 12px 14px; margin: 14px 0 20px; font-size: 12px; color: #374151; }
 ul { padding-left: 20px; margin-bottom: 8px; }
 li { margin-bottom: 4px; }
 @media print {
@@ -17370,7 +17486,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "chron-mcp",
-      version: "0.1.26",
+      version: "0.1.29",
       mcpName: "io.github.sirinivask/chron",
       description: "Audit-grade timestamped logs for every AI conversation",
       repository: {
@@ -18177,6 +18293,93 @@ ${DIM4}Authenticating with Azure AD...${RESET5} `);
 `);
   process.stdout.write(`${DIM4}Config saved to ~/.chron/config.json \u2014 events will flow immediately in all running sessions.${RESET5}
 
+`);
+}
+function codexGlobalConfigPath() {
+  return (0, import_path5.join)((0, import_os6.homedir)(), ".codex", "config.toml");
+}
+function isChronInCodexConfig(content) {
+  return content.includes("[mcp_servers.chron]");
+}
+function appendChronToToml(content) {
+  return content.trimEnd() + "\n" + CODEX_MCP_BLOCK;
+}
+async function connectCodex() {
+  process.stdout.write(`
+${BOLD5}Connect Chron \u2192 Codex${RESET5}
+
+`);
+  const globalPath = codexGlobalConfigPath();
+  const projectPath = (0, import_path5.join)(process.cwd(), ".codex", "config.toml");
+  const hasGlobal = (0, import_fs5.existsSync)(globalPath);
+  const hasProject = (0, import_fs5.existsSync)(projectPath);
+  let targetPath;
+  let isProject = false;
+  if (hasGlobal && hasProject) {
+    process.stdout.write(`${DIM4}Found both global and project Codex configs.${RESET5}
+`);
+    process.stdout.write(`${DIM4}  Global:  ${globalPath}${RESET5}
+`);
+    process.stdout.write(`${DIM4}  Project: ${projectPath}${RESET5}
+
+`);
+    const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    const choice = await new Promise(
+      (resolve) => rl.question(`  Add Chron to (g)lobal or (p)roject config? [g/p]: `, resolve)
+    );
+    rl.close();
+    isProject = choice.trim().toLowerCase() === "p";
+    targetPath = isProject ? projectPath : globalPath;
+  } else if (hasProject) {
+    targetPath = projectPath;
+    isProject = true;
+  } else if (hasGlobal) {
+    targetPath = globalPath;
+  } else {
+    process.stdout.write(`${YELLOW3}!${RESET5} Codex config not found. Creating ${globalPath}
+
+`);
+    (0, import_fs5.mkdirSync)((0, import_path5.join)((0, import_os6.homedir)(), ".codex"), { recursive: true });
+    (0, import_fs5.writeFileSync)(globalPath, CODEX_MCP_BLOCK.trimStart());
+    process.stdout.write(`${GREEN2}\u2713${RESET5} Created ${globalPath} with Chron MCP config.
+`);
+    _printCodexNextSteps();
+    return;
+  }
+  const existing = (0, import_fs5.readFileSync)(targetPath, "utf8");
+  if (isChronInCodexConfig(existing)) {
+    process.stdout.write(`${GREEN2}\u2713${RESET5} Chron MCP is already configured in ${targetPath}
+
+`);
+    _printCodexNextSteps();
+    return;
+  }
+  const updated = appendChronToToml(existing);
+  (0, import_fs5.writeFileSync)(targetPath, updated, "utf8");
+  process.stdout.write(`${GREEN2}\u2713${RESET5} Added Chron MCP to ${targetPath}
+
+`);
+  _printCodexNextSteps();
+}
+function _printCodexNextSteps() {
+  process.stdout.write(`${BOLD5}Next steps:${RESET5}
+
+`);
+  process.stdout.write(`  1. Restart Codex to pick up the new MCP server.
+`);
+  process.stdout.write(`  2. Ask Codex to start a Chron session:
+`);
+  process.stdout.write(`     ${DIM4}"Use init_session to start a Chron audit session for this work."${RESET5}
+`);
+  process.stdout.write(`  3. Verify setup:
+`);
+  process.stdout.write(`     ${CYAN4}chron doctor${RESET5}
+
+`);
+  process.stdout.write(`${DIM4}Codex will automatically call log_tool_call, log_tool_result, and
+`);
+  process.stdout.write(`log_code_change during its work once the session is started.${RESET5}
+
 `);
 }
 async function runConnect(args2) {
@@ -18191,6 +18394,9 @@ async function runConnect(args2) {
     case "splunk":
       await connectSplunk();
       break;
+    case "codex":
+      await connectCodex();
+      break;
     default: {
       const name = subcommand ? `Unknown integration: ${subcommand}
 
@@ -18199,6 +18405,7 @@ async function runConnect(args2) {
         `${name}Usage: chron connect <integration>
 
 Integrations:
+  codex          Add Chron MCP to Codex config (global or project)
   crowdstrike    Connect to CrowdStrike LogScale (direct ingest)
   sentinel       Connect to Microsoft Sentinel (Azure Monitor Logs Ingestion API)
   splunk         Connect to Splunk via HTTP Event Collector (HEC)
@@ -18208,7 +18415,7 @@ Integrations:
     }
   }
 }
-var import_readline, import_os6, import_path5, import_fs5, RESET5, BOLD5, DIM4, CYAN4, GREEN2, RED, YELLOW3;
+var import_readline, import_os6, import_path5, import_fs5, RESET5, BOLD5, DIM4, CYAN4, GREEN2, RED, YELLOW3, CODEX_MCP_BLOCK;
 var init_connect = __esm({
   "src/cli/connect.ts"() {
     "use strict";
@@ -18223,6 +18430,11 @@ var init_connect = __esm({
     GREEN2 = "\x1B[32m";
     RED = "\x1B[31m";
     YELLOW3 = "\x1B[33m";
+    CODEX_MCP_BLOCK = `
+[mcp_servers.chron]
+command = "npx"
+args = ["-y", "chron-mcp"]
+`;
   }
 });
 
@@ -18545,7 +18757,15 @@ async function runSign(args2) {
     process.exit(1);
   }
   const signature = signSession(session.id, finalContentHash, messageCount, firstCreatedAt);
-  await db.update(sessions).set({ signature }).where(eq(sessions.id, session.id));
+  try {
+    await db.update(sessions).set({ signature }).where(eq(sessions.id, session.id));
+  } catch (err) {
+    const cause = err?.cause ?? err;
+    process.stderr.write(`Failed to save signature: ${cause?.message ?? err.message}
+`);
+    process.stderr.write("Tip: if the Chron MCP server is running, it may hold a write lock. Retry or stop the MCP server first.\n");
+    process.exit(1);
+  }
   const sigData = {
     chron_signature: "v1",
     session_id: session.id,
@@ -18870,7 +19090,7 @@ function loadConfig2() {
 function mcpConfigs() {
   const home = (0, import_os9.homedir)();
   const plat = (0, import_os9.platform)();
-  const candidates = [
+  const jsonCandidates = [
     {
       name: "Claude Desktop",
       path: plat === "win32" ? (0, import_path9.join)(process.env.APPDATA ?? (0, import_path9.join)(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : (0, import_path9.join)(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
@@ -18879,7 +19099,7 @@ function mcpConfigs() {
     { name: "Cursor", path: (0, import_path9.join)(home, ".cursor", "mcp.json") },
     { name: "Windsurf", path: (0, import_path9.join)(home, ".codeium", "windsurf", "mcp_config.json") }
   ];
-  return candidates.map((c) => {
+  const results = jsonCandidates.map((c) => {
     if (!(0, import_fs10.existsSync)(c.path)) {
       return { name: c.name, path: c.path, exists: false, chronConfigured: null };
     }
@@ -18894,6 +19114,22 @@ function mcpConfigs() {
       return { name: c.name, path: c.path, exists: true, chronConfigured: null, note: "Could not parse config" };
     }
   });
+  const codexGlobal = (0, import_path9.join)(home, ".codex", "config.toml");
+  const codexProject = (0, import_path9.join)(process.cwd(), ".codex", "config.toml");
+  for (const p of [codexGlobal, codexProject]) {
+    if (!(0, import_fs10.existsSync)(p)) {
+      results.push({ name: p === codexGlobal ? "Codex (global)" : "Codex (project)", path: p, exists: false, chronConfigured: null });
+    } else {
+      try {
+        const content = (0, import_fs10.readFileSync)(p, "utf8");
+        const configured = content.includes("[mcp_servers.chron]");
+        results.push({ name: p === codexGlobal ? "Codex (global)" : "Codex (project)", path: p, exists: true, chronConfigured: configured });
+      } catch {
+        results.push({ name: p === codexGlobal ? "Codex (global)" : "Codex (project)", path: p, exists: true, chronConfigured: null, note: "Could not read config" });
+      }
+    }
+  }
+  return results;
 }
 function npmLatestVersion() {
   try {
@@ -19023,14 +19259,16 @@ ${BOLD8}chron doctor${RESET8}  ${DIM7}v${import_package2.version}${RESET8}
       if (!jsonMode)
         ok2(`${t.name}`, "chron configured");
     } else {
+      const isCodex = t.name.startsWith("Codex");
+      const fixHint = isCodex ? `chron connect codex` : `Add chron to mcpServers in ${t.path}
+      See: https://github.com/sirinivask/chron#installation`;
       results.push({
         pass: "warn",
-        label: `${t.name}: chron NOT in mcpServers`,
-        fix: `Add chron to mcpServers in ${t.path}
-      See: https://github.com/sirinivask/chron#installation`
+        label: `${t.name}: chron not configured`,
+        fix: fixHint
       });
       if (!jsonMode)
-        warn2(`${t.name}`, `chron not in mcpServers \u2014 add it to ${t.path}`);
+        warn2(`${t.name}`, isCodex ? "chron not in MCP servers \u2014 run: chron connect codex" : `chron not in mcpServers \u2014 add it to ${t.path}`);
     }
   }
   if (!jsonMode)
@@ -19089,6 +19327,9 @@ ${BOLD8}chron doctor${RESET8}  ${DIM7}v${import_package2.version}${RESET8}
     if (failures.length === 0 && warnings.length === 0) {
       process.stdout.write(`${GREEN5}${BOLD8}All checks passed.${RESET8} Chron is correctly set up.
 
+`);
+      process.stdout.write(`${DIM7}Team AI governance: CLAIIM adds runtime ALLOW/DENY gates on top of Chron proof \u2014 ${CLAIIM_PREVIEW_URL}${RESET8}
+
 `);
     } else {
       if (failures.length > 0) {
@@ -19137,7 +19378,7 @@ ${BOLD8}chron doctor${RESET8}  ${DIM7}v${import_package2.version}${RESET8}
   }
   process.exit(failures.length > 0 ? 1 : 0);
 }
-var import_os9, import_path9, import_fs10, import_child_process3, import_package2, RESET8, BOLD8, DIM7, GREEN5, RED4, YELLOW6, CYAN6;
+var import_os9, import_path9, import_fs10, import_child_process3, import_package2, RESET8, BOLD8, DIM7, GREEN5, RED4, YELLOW6, CYAN6, CLAIIM_PREVIEW_URL;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
@@ -19153,6 +19394,7 @@ var init_doctor = __esm({
     RED4 = "\x1B[31m";
     YELLOW6 = "\x1B[33m";
     CYAN6 = "\x1B[36m";
+    CLAIIM_PREVIEW_URL = "https://claiim.io/preview";
   }
 });
 
@@ -19845,7 +20087,7 @@ Commands:
   export          Export a session as markdown
   secrets         List detected secrets across sessions
   settings        View current configuration
-  connect         Connect to a SIEM integration (crowdstrike, sentinel, splunk)
+  connect         Connect to a SIEM or AI tool (codex, crowdstrike, sentinel, splunk)
   summary         Structured summary of a session (timeline, mutations, secrets)
   sign            Sign a session with its Ed25519 key \u2014 produces a .chron.sig file
   verify          Verify a session's hash chain and Ed25519 signature
@@ -19854,9 +20096,10 @@ Commands:
   import          Import conversations from external AI tools
 
 Options (history):
-  --limit=<n>     Max sessions to show (default: 20)
-  --ref=<value>   Filter by external_ref prefix (e.g. --ref=jira: or --ref=jira:ENG-123)
-  <id-prefix>     Show full log for the session with this ID prefix
+  --limit=<n>       Max sessions to show (default: 20)
+  --search=<query>  Full-text search across all sessions (FTS5: phrases, boolean, prefix*)
+  --ref=<value>     Filter by external_ref prefix
+  <id-prefix>       Show full log for the session with this ID prefix
 
 Options (report):
   --since=<range>   Filter by date: 7d, 30d, or YYYY-MM-DD (default: all time)

package/dist/index.js

@@ -22792,6 +22792,7 @@ async function initDb(dbPath) {
   }
   const client = createClient({ url: path.startsWith(":") ? path : `file:${path}` });
   await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 5000");
   await client.execute("PRAGMA foreign_keys = ON");
   for (const sql2 of CREATE_SQL) {
     await client.execute(sql2);
@@ -22824,6 +22825,14 @@ async function initDb(dbPath) {
   if (!sessCols.includes("metadata")) {
     await client.execute("ALTER TABLE sessions ADD COLUMN metadata TEXT");
   }
+  const ftsCount = await client.execute("SELECT count(*) as n FROM messages_fts");
+  const msgCount = await client.execute("SELECT count(*) as n FROM messages");
+  if (Number(ftsCount.rows[0][0]) < Number(msgCount.rows[0][0])) {
+    await client.execute("DELETE FROM messages_fts");
+    await client.execute(
+      "INSERT INTO messages_fts(rowid, content, session_id) SELECT rowid, content, session_id FROM messages"
+    );
+  }
   return drizzle(client, { schema: schema_exports });
 }
 var import_os, import_fs, import_path, CREATE_SQL;
@@ -22873,7 +22882,21 @@ var init_db2 = __esm({
       `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
       `CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_session_id ON secrets_detected(session_id)`,
-      `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`
+      `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`,
+      `CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+    content,
+    session_id UNINDEXED,
+    tokenize = 'porter unicode61'
+  )`,
+      `CREATE TRIGGER IF NOT EXISTS messages_fts_ai
+    AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content, session_id)
+      VALUES (new.rowid, new.content, new.session_id);
+    END`,
+      `CREATE TRIGGER IF NOT EXISTS messages_fts_ad
+    AFTER DELETE ON messages BEGIN
+      DELETE FROM messages_fts WHERE rowid = old.rowid;
+    END`
     ];
   }
 });
@@ -38479,7 +38502,7 @@ var init_time = __esm({
 var version4;
 var init_package = __esm({
   "package.json"() {
-    version4 = "0.1.26";
+    version4 = "0.1.29";
   }
 });
 
@@ -38837,6 +38860,44 @@ var init_ntp = __esm({
   }
 });
 
+// src/utils/terminal.ts
+function resolvedLevel() {
+  const raw = (process.env.CHRON_LOG_LEVEL ?? "").toLowerCase();
+  if (raw === "off" || raw === "false" || raw === "0")
+    return "off";
+  if (raw === "summary")
+    return "summary";
+  const legacy = process.env.CHRON_TERMINAL_AUDIT;
+  if (legacy && DISABLE_VALUES.has(legacy.toLowerCase()))
+    return "off";
+  return "verbose";
+}
+function terminalAudit(message, level = "message") {
+  const mode = resolvedLevel();
+  if (mode === "off")
+    return;
+  if (mode === "summary" && level === "message")
+    return;
+  process.stderr.write(`[chron] ${message}
+`);
+}
+function formatDuration(ms) {
+  if (ms < 1e3)
+    return `${ms}ms`;
+  if (ms < 6e4)
+    return `${(ms / 1e3).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+var DISABLE_VALUES;
+var init_terminal = __esm({
+  "src/utils/terminal.ts"() {
+    "use strict";
+    DISABLE_VALUES = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+  }
+});
+
 // src/tools/sessions.ts
 function attachNtpMetadata(db, sessionId) {
   setImmediate(() => {
@@ -38867,6 +38928,7 @@ function startSession(db) {
       });
       attachNtpMetadata(db, id);
       emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: id.slice(0, 8), ai_tool: args.ai_tool ?? null } });
+      terminalAudit(`session ${id.slice(0, 8)} started at ${now} (${args.ai_tool ?? "unknown"}: ${args.title})`, "session");
       return {
         content: [{
           type: "text",
@@ -38882,6 +38944,7 @@ function startSession(db) {
       const [countRow] = await db.select({ count: sql`count(*)` }).from(messages).where(eq(messages.session_id, session.id));
       await db.update(sessions).set({ updated_at: now }).where(eq(sessions.id, session.id));
       emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: session.id.slice(0, 8), ai_tool: session.ai_tool } });
+      terminalAudit(`session ${session.id.slice(0, 8)} resumed at ${now} (${session.ai_tool ?? "unknown"}: ${session.title})`, "session");
       return {
         content: [{
           type: "text",
@@ -38918,6 +38981,7 @@ function initSession(db) {
       created = true;
       ai_tool = args.ai_tool ?? null;
       attachNtpMetadata(db, id);
+      terminalAudit(`session ${id.slice(0, 8)} started at ${now} (${ai_tool ?? "unknown"}: ${args.title})`, "session");
     } catch (e) {
       const isUnique = e?.message?.includes("UNIQUE constraint failed") || e?.code === "SQLITE_CONSTRAINT_UNIQUE" || e?.cause?.message?.includes("UNIQUE constraint failed") || e?.cause?.extendedCode === "SQLITE_CONSTRAINT_UNIQUE";
       if (!isUnique)
@@ -38928,6 +38992,7 @@ function initSession(db) {
       session_id = session.id;
       created = false;
       ai_tool = session.ai_tool;
+      terminalAudit(`session ${session.id.slice(0, 8)} resumed at ${now} (${ai_tool ?? "unknown"}: ${session.title})`, "session");
     }
     emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: session_id.slice(0, 8), ai_tool } });
     const limit = args.limit ?? 10;
@@ -39016,6 +39081,7 @@ var init_sessions = __esm({
     init_relay();
     init_signing();
     init_ntp();
+    init_terminal();
   }
 });
 
@@ -39328,7 +39394,7 @@ function isFkError(e) {
 }
 async function insertMessage(db, session_id, role, content, event_type) {
   return db.transaction(async (tx) => {
-    const last = await tx.select({ content_hash: messages.content_hash }).from(messages).where(eq(messages.session_id, session_id)).orderBy(desc(messages.created_at), desc(sql`rowid`)).limit(1);
+    const last = await tx.select({ content_hash: messages.content_hash, created_at: messages.created_at }).from(messages).where(eq(messages.session_id, session_id)).orderBy(desc(messages.created_at), desc(sql`rowid`)).limit(1);
     const ts = localISOString();
     const msgId = v4_default();
     const prevHash = last[0]?.content_hash ?? null;
@@ -39345,7 +39411,13 @@ async function insertMessage(db, session_id, role, content, event_type) {
     });
     await tx.update(sessions).set({ updated_at: ts }).where(eq(sessions.id, session_id));
     const [sessionRow] = await tx.select({ ai_tool: sessions.ai_tool }).from(sessions).where(eq(sessions.id, session_id)).limit(1);
-    return { id: msgId, now: ts, contentHash: hash, ai_tool: sessionRow?.ai_tool ?? null };
+    return {
+      id: msgId,
+      now: ts,
+      contentHash: hash,
+      ai_tool: sessionRow?.ai_tool ?? null,
+      previous_created_at: last[0]?.created_at ?? null
+    };
   });
 }
 function logMessage(db) {
@@ -39361,6 +39433,9 @@ function logMessage(db) {
       now = result.now;
       contentHash = result.contentHash;
       sessionAiTool = result.ai_tool;
+      const elapsed = result.previous_created_at ? ` (+${formatDuration(new Date(now).getTime() - new Date(result.previous_created_at).getTime())})` : "";
+      const marker = args.role === "user" ? "user start" : "assistant end";
+      terminalAudit(`${marker} ${now}${elapsed} session ${args.session_id.slice(0, 8)}`);
     } catch (e) {
       if (isFkError(e)) {
         return { content: [{ type: "text", text: `Session not found: ${args.session_id}` }], isError: true };
@@ -39508,6 +39583,7 @@ var init_messages = __esm({
     init_hash();
     init_detect();
     init_relay();
+    init_terminal();
   }
 });
 
@@ -39831,6 +39907,73 @@ var init_summary2 = __esm({
   }
 });
 
+// src/tools/search.ts
+async function runSearch(db, query, limit = 10) {
+  const client = db.$client;
+  let rows;
+  try {
+    const result = await client.execute({
+      sql: `
+        SELECT
+          messages_fts.session_id                                          AS session_id,
+          snippet(messages_fts, 0, '>>>', '<<<', '\u2026', 24)                 AS excerpt,
+          s.title                                                           AS title,
+          s.ai_tool                                                         AS ai_tool,
+          s.updated_at                                                      AS updated_at
+        FROM messages_fts
+        JOIN sessions s ON s.id = messages_fts.session_id
+        WHERE messages_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `,
+      args: [query, limit * 5]
+      // over-fetch so we can group into limit distinct sessions
+    });
+    rows = result.rows;
+  } catch {
+    return [];
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const sid = String(r.session_id ?? "");
+    if (!sid)
+      continue;
+    if (!map.has(sid)) {
+      map.set(sid, {
+        session_id: sid,
+        title: String(r.title ?? ""),
+        ai_tool: r.ai_tool != null ? String(r.ai_tool) : null,
+        updated_at: String(r.updated_at ?? ""),
+        match_count: 0,
+        excerpts: []
+      });
+    }
+    const entry = map.get(sid);
+    entry.match_count++;
+    if (entry.excerpts.length < 3)
+      entry.excerpts.push(String(r.excerpt ?? ""));
+    if (map.size >= limit && entry.match_count > 1)
+      break;
+  }
+  return Array.from(map.values()).slice(0, limit);
+}
+function searchSessions(db) {
+  return async (args) => {
+    const results = await runSearch(db, args.query, args.limit ?? 10);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ query: args.query, total: results.length, results })
+      }]
+    };
+  };
+}
+var init_search = __esm({
+  "src/tools/search.ts"() {
+    "use strict";
+  }
+});
+
 // src/server.ts
 function createServer(db) {
   const server = new McpServer({
@@ -39954,6 +40097,15 @@ function createServer(db) {
     },
     deleteSession(db)
   );
+  server.tool(
+    "search_sessions",
+    'Full-text search across all logged AI conversations. Returns matching sessions with excerpts. Uses SQLite FTS5 with porter stemming \u2014 supports phrases ("exact match"), boolean (term1 OR term2), and prefix (migrat*).',
+    {
+      query: external_exports.string().describe('FTS5 search query, e.g. "database migration" or "auth bug" or "deploy OR release"'),
+      limit: external_exports.number().int().positive().optional().describe("Max sessions to return (default: 10)")
+    },
+    searchSessions(db)
+  );
   server.tool(
     "summarize_session",
     "Return a structured summary of a session: timeline with latencies, mutations detected, secrets touched, and possible prod-account references. Useful for compliance review and change-control evidence.",
@@ -39984,6 +40136,7 @@ var init_server3 = __esm({
     init_verify();
     init_detect2();
     init_summary2();
+    init_search();
     init_package();
     roleEnum = external_exports.enum(["user", "assistant"]);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "mcpName": "io.github.sirinivask/chron",
   "description": "Audit-grade timestamped logs for every AI conversation",
   "repository": {

package/skills/codex.skill.md

@@ -0,0 +1,73 @@
+# Chron — Codex Audit Skill
+
+Chron creates a tamper-evident audit trail of every Codex session — messages, tool calls, tool results, and code changes — stored in a local SQLite database the user owns. No data leaves the machine.
+
+## Session Start
+
+At the beginning of every Codex thread, call:
+
+```
+init_session(title="<short description of the task>", ai_tool="codex")
+```
+
+This creates or resumes a session and returns `session_id`, `message_count`, and recent `messages`. Save `session_id` — you will use it for every subsequent call.
+
+If `message_count > 0`, you are resuming an existing session. Acknowledge this to the user.
+
+## Every Exchange
+
+For every user message and your response, log both ends before outputting:
+
+1. `log_message(session_id, role="user", content=<exact user message>)` — log the user's message first
+2. Compose your response internally
+3. `log_message(session_id, role="assistant", content=<your response>)` — log before outputting
+4. Output the response
+
+## Tool Calls and Results
+
+Before executing any tool (shell command, file read, browser action, code execution):
+
+```
+log_tool_call(session_id, tool_name="<tool>", tool_input={<args>})
+```
+
+After receiving the tool output:
+
+```
+log_tool_result(session_id, tool_call_id=<id from log_tool_call>, output="<result>", exit_code=<n>)
+```
+
+## Code Changes
+
+After writing or editing any file:
+
+```
+log_code_change(
+  session_id,
+  file_path="<absolute or repo-relative path>",
+  operation="create" | "edit" | "delete",
+  diff="<unified diff of the change>"
+)
+```
+
+This creates a cryptographically linked record of every file edit, tied to the conversation that caused it.
+
+## Audit Order (per turn)
+
+```
+log_message(role="user")          ← before doing anything
+  log_tool_call(...)              ← before each tool
+  log_tool_result(...)            ← after each tool result
+  log_code_change(...)            ← after each file edit
+log_message(role="assistant")     ← before final response output
+```
+
+## Verify Integrity
+
+At any point, the user can run:
+
+```bash
+chron verify <session-id-prefix>
+```
+
+This walks the SHA-256 hash chain and verifies the Ed25519 session signature, confirming the audit record has not been modified since it was written.