chron-mcp 0.1.25 → 0.1.28

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
@@ -102,6 +104,7 @@ Commands:
   verify          Verify a session's hash chain and Ed25519 signature
   prune           Delete sessions older than a retention cutoff
   doctor          Check your Chron setup — Node version, DB, MCP configs, SIEM
+  import          Import conversations from external AI tools into Chron
 
 Options (history):
   --limit=<n>     Max sessions to show (default: 20)
@@ -131,6 +134,9 @@ Options (prune):
 
 Options (doctor):
   --json             Machine-readable JSON output
+
+Options (import):
+  chatgpt <file>     Import from ChatGPT export (.zip or conversations.json)
 ```
 
 ### `chron doctor`
@@ -643,6 +649,34 @@ Point your MCP config at the URL:
 
 ---
 
+## ChatGPT import
+
+Bring your existing ChatGPT history into Chron's tamper-evident audit trail.
+
+```bash
+# From a ChatGPT data export ZIP
+chron import chatgpt ~/Downloads/chatgpt-export.zip
+
+# Or from an extracted conversations.json
+chron import chatgpt ~/Downloads/conversations.json
+```
+
+**How to get your ChatGPT export:**
+ChatGPT → Settings → Data Controls → Export data → wait for email → download the ZIP.
+
+**What gets imported:**
+- One Chron session per conversation, with `ai_tool=chatgpt`
+- Original message timestamps from the export
+- `external_ref=chatgpt:<conversation_id>` on every session (visible in `chron history`)
+- Full SHA-256 hash chain across all imported messages
+- Secret detection runs on all user messages
+
+**Re-running is safe** — already-imported conversations are skipped by `external_ref` match.
+
+After import, sessions appear in `chron history` and `chron verify` works on them the same as any natively-logged session.
+
+---
+
 ## Your data
 
 Your audit log lives at `~/.chron/chron.db` — a single SQLite file on your machine. Query it directly with any SQLite tool:

package/dist/cli/index.js

@@ -1184,7 +1184,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join10(chunks, separator) {
+      function join11(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -1194,7 +1194,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join10;
+      sql2.join = join11;
       function identifier(value) {
         return new Name(value);
       }
@@ -2806,7 +2806,7 @@ var require_filesystem = __commonJS({
     "use strict";
     var fs = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
-    var readFileSync7 = (path) => fs.readFileSync(path, "utf-8");
+    var readFileSync8 = (path) => fs.readFileSync(path, "utf-8");
     var readFile = (path) => new Promise((resolve, reject) => {
       fs.readFile(path, "utf-8", (err, data) => {
         if (err) {
@@ -2818,7 +2818,7 @@ var require_filesystem = __commonJS({
     });
     module2.exports = {
       LDD_PATH,
-      readFileSync: readFileSync7,
+      readFileSync: readFileSync8,
       readFile
     };
   }
@@ -2830,7 +2830,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, readFile, readFileSync: readFileSync7 } = require_filesystem();
+    var { LDD_PATH, readFile, readFileSync: readFileSync8 } = require_filesystem();
     var cachedFamilyFilesystem;
     var cachedVersionFilesystem;
     var command2 = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
@@ -2911,7 +2911,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync7(LDD_PATH);
+        const lddContent = readFileSync8(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -2968,7 +2968,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync7(LDD_PATH);
+        const lddContent = readFileSync8(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -5265,7 +5265,7 @@ var require_sender = __commonJS({
   "node_modules/ws/lib/sender.js"(exports2, module2) {
     "use strict";
     var { Duplex } = require("stream");
-    var { randomFillSync } = require("crypto");
+    var { randomFillSync: randomFillSync2 } = require("crypto");
     var PerMessageDeflate2 = require_permessage_deflate();
     var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
     var { isBlob, isValidStatusCode } = require_validation();
@@ -5337,7 +5337,7 @@ var require_sender = __commonJS({
               if (randomPool === void 0) {
                 randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
               }
-              randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+              randomFillSync2(randomPool, 0, RANDOM_POOL_SIZE);
               randomPoolPointer = 0;
             }
             mask[0] = randomPool[randomPoolPointer++];
@@ -14252,7 +14252,7 @@ var init_select2 = __esm({
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table))
             this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join10) => join10.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join11) => join11.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -15141,7 +15141,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join10) => join10.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join11) => join11.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -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);
@@ -17032,12 +17033,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 +17166,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 {
@@ -17302,6 +17308,20 @@ function keysDir() {
 function privKeyPath(sessionId) {
   return (0, import_path2.join)(keysDir(), `${sessionId}.key`);
 }
+function pubKeyPath(sessionId) {
+  return (0, import_path2.join)(keysDir(), `${sessionId}.pub`);
+}
+function generateSessionKeypair(sessionId) {
+  const { privateKey, publicKey } = (0, import_crypto2.generateKeyPairSync)("ed25519", {
+    privateKeyEncoding: { type: "pkcs8", format: "pem" },
+    publicKeyEncoding: { type: "spki", format: "pem" }
+  });
+  const dir = keysDir();
+  (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  (0, import_fs3.writeFileSync)(privKeyPath(sessionId), privateKey, { mode: 384 });
+  (0, import_fs3.writeFileSync)(pubKeyPath(sessionId), publicKey);
+  return publicKey;
+}
 function sessionDigest(sessionId, finalContentHash, messageCount, firstCreatedAt) {
   const input = `${sessionId}|${finalContentHash}|${messageCount}|${firstCreatedAt}`;
   return (0, import_crypto2.createHash)("sha256").update(input).digest();
@@ -17356,7 +17376,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "chron-mcp",
-      version: "0.1.25",
+      version: "0.1.28",
       mcpName: "io.github.sirinivask/chron",
       description: "Audit-grade timestamped logs for every AI conversation",
       repository: {
@@ -18163,6 +18183,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) {
@@ -18177,6 +18284,9 @@ async function runConnect(args2) {
     case "splunk":
       await connectSplunk();
       break;
+    case "codex":
+      await connectCodex();
+      break;
     default: {
       const name = subcommand ? `Unknown integration: ${subcommand}
 
@@ -18185,6 +18295,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)
@@ -18194,7 +18305,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";
@@ -18209,6 +18320,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"]
+`;
   }
 });
 
@@ -18531,7 +18647,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,
@@ -18651,9 +18775,9 @@ ${BOLD7}Signature${RESET7}
       warn("No manifest.sig \u2014 bundle was not signed");
     }
     if (sigFile?.session_id && sigFile?.signature) {
-      const pubKeyPath = (0, import_path8.join)(tempDir, "pubkeys", `${sigFile.session_id}.pub`);
+      const pubKeyPath2 = (0, import_path8.join)(tempDir, "pubkeys", `${sigFile.session_id}.pub`);
       try {
-        const pubKey = (0, import_fs9.readFileSync)(pubKeyPath, "utf8");
+        const pubKey = (0, import_fs9.readFileSync)(pubKeyPath2, "utf8");
         const valid = verifyBufferSignature(pubKey, sigFile.signature, manifestBytes);
         if (valid) {
           ok(`Ed25519 signature valid (session ${sigFile.session_id.slice(0, 8)})`);
@@ -18856,7 +18980,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")
@@ -18865,7 +18989,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 };
     }
@@ -18880,6 +19004,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 {
@@ -19009,14 +19149,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)
@@ -19075,6 +19217,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) {
@@ -19123,7 +19268,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";
@@ -19139,6 +19284,619 @@ var init_doctor = __esm({
     RED4 = "\x1B[31m";
     YELLOW6 = "\x1B[33m";
     CYAN6 = "\x1B[36m";
+    CLAIIM_PREVIEW_URL = "https://claiim.io/preview";
+  }
+});
+
+// node_modules/uuid/dist/esm/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var byteToHex;
+var init_stringify = __esm({
+  "node_modules/uuid/dist/esm/stringify.js"() {
+    byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+  }
+});
+
+// node_modules/uuid/dist/esm/rng.js
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    (0, import_crypto5.randomFillSync)(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+var import_crypto5, rnds8Pool, poolPtr;
+var init_rng = __esm({
+  "node_modules/uuid/dist/esm/rng.js"() {
+    import_crypto5 = require("crypto");
+    rnds8Pool = new Uint8Array(256);
+    poolPtr = rnds8Pool.length;
+  }
+});
+
+// node_modules/uuid/dist/esm/native.js
+var import_crypto6, native_default;
+var init_native = __esm({
+  "node_modules/uuid/dist/esm/native.js"() {
+    import_crypto6 = require("crypto");
+    native_default = { randomUUID: import_crypto6.randomUUID };
+  }
+});
+
+// node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default;
+var init_v4 = __esm({
+  "node_modules/uuid/dist/esm/v4.js"() {
+    init_native();
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// node_modules/uuid/dist/esm/index.js
+var init_esm = __esm({
+  "node_modules/uuid/dist/esm/index.js"() {
+    init_v4();
+  }
+});
+
+// src/utils/detect.ts
+function luhnCheck(value) {
+  const digits = value.replace(/\D/g, "");
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = parseInt(digits[i], 10);
+    if (alt) {
+      n *= 2;
+      if (n > 9)
+        n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+function ibanCheck(value) {
+  const normalized = value.replace(/\s/g, "").toUpperCase();
+  if (normalized.length < 15 || normalized.length > 34)
+    return false;
+  const rearranged = normalized.slice(4) + normalized.slice(0, 4);
+  const numeric2 = rearranged.replace(/[A-Z]/g, (c) => String(c.charCodeAt(0) - 55));
+  let remainder = 0;
+  for (const ch of numeric2) {
+    remainder = (remainder * 10 + parseInt(ch, 10)) % 97;
+  }
+  return remainder === 1;
+}
+function contextMatches(kw, input, idx) {
+  const lo = Math.max(0, idx - CONTEXT_WINDOW);
+  const hi = Math.min(input.length, idx + CONTEXT_WINDOW);
+  return kw.test(input.slice(lo, hi));
+}
+function annotate(s) {
+  return {
+    ...s,
+    severity: SEVERITY2[s.type] ?? "low",
+    category: CATEGORY[s.type] ?? "other"
+  };
+}
+function scanForSecrets(input) {
+  const withPriority = [];
+  for (let i = 0; i < PATTERNS.length; i++) {
+    const { type, regex, validate } = PATTERNS[i];
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(input)) !== null) {
+      if (validate && !validate(match[0], input, match.index))
+        continue;
+      withPriority.push({
+        type,
+        value: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+        priority: i
+      });
+    }
+  }
+  withPriority.sort((a, b) => a.priority - b.priority || a.start - b.start);
+  let deduped = deduplicateOverlaps(withPriority);
+  const pairs = detectCredentialPairs(input, deduped);
+  if (pairs.length > 0) {
+    for (const pair of pairs) {
+      deduped.push({ ...pair, priority: -1 });
+    }
+    deduped.sort((a, b) => a.priority - b.priority || a.start - b.start);
+    deduped = deduplicateOverlaps(deduped);
+  }
+  deduped.sort((a, b) => a.start - b.start);
+  return deduped.map(({ priority: _p, ...s }) => annotate(s));
+}
+function looksLikePassword(s) {
+  if (s.length < 8)
+    return false;
+  const hasUpper = /[A-Z]/.test(s);
+  const hasLower = /[a-z]/.test(s);
+  const hasDigit = /[0-9]/.test(s);
+  const hasSpecial = /[@!#$%^&*\-_+=?]/.test(s);
+  const score = [hasUpper, hasLower, hasDigit, hasSpecial].filter(Boolean).length;
+  return score >= 3;
+}
+function detectCredentialPairs(input, _existing) {
+  const results = [];
+  EMAIL_RE.lastIndex = 0;
+  let match;
+  while ((match = EMAIL_RE.exec(input)) !== null) {
+    const emailStart = match.index;
+    const emailEnd = match.index + match[0].length;
+    const charBefore = emailStart > 0 ? input[emailStart - 1] : "";
+    if (charBefore === "@" || charBefore === ":")
+      continue;
+    const windowStart = Math.max(0, emailStart - PAIR_WINDOW);
+    const windowEnd = Math.min(input.length, emailEnd + PAIR_WINDOW);
+    const surrounding = input.slice(windowStart, windowEnd);
+    const tokens = surrounding.match(/\S+/g) ?? [];
+    for (const token of tokens) {
+      if (token === match[0])
+        continue;
+      if (!looksLikePassword(token))
+        continue;
+      const tokenAbsoluteStart = windowStart + surrounding.indexOf(token);
+      const pairStart = Math.min(emailStart, tokenAbsoluteStart);
+      const pairEnd = Math.max(emailEnd, tokenAbsoluteStart + token.length);
+      results.push({
+        type: "credential_pair",
+        value: input.slice(pairStart, pairEnd),
+        start: pairStart,
+        end: pairEnd
+      });
+      break;
+    }
+  }
+  return results;
+}
+function deduplicateOverlaps(secrets) {
+  const kept = [];
+  for (const candidate of secrets) {
+    const overlaps = kept.some((k) => candidate.start < k.end && candidate.end > k.start);
+    if (!overlaps)
+      kept.push(candidate);
+  }
+  return kept;
+}
+var CONTEXT_WINDOW, DOB_KEYWORDS, PASS_KEYWORDS, SSN_KEYWORDS, PATTERNS, SEVERITY2, CATEGORY, EMAIL_RE, PAIR_WINDOW;
+var init_detect = __esm({
+  "src/utils/detect.ts"() {
+    "use strict";
+    CONTEXT_WINDOW = 120;
+    DOB_KEYWORDS = /\b(?:dob|date\s+of\s+birth|birth\s+date|born\s+on|birthday)\b/i;
+    PASS_KEYWORDS = /\b(?:passport|travel\s+document|document\s+no(?:\.|\b))\b/i;
+    SSN_KEYWORDS = /\b(?:ssn|social\s+security|tin\b)\b/i;
+    PATTERNS = [
+      // Private key blocks (must come first — multiline, unambiguous)
+      { type: "private_key", regex: /-----BEGIN [A-Z ]+ PRIVATE KEY-----[\s\S]+?-----END [A-Z ]+ PRIVATE KEY-----/g },
+      // Cloud / AI provider keys
+      { type: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/g },
+      { type: "anthropic_api_key", regex: /sk-ant-api\d{2}-[a-zA-Z0-9\-_]{40,}/g },
+      { type: "openai_api_key", regex: /sk-proj-[a-zA-Z0-9\-_]{20,}/g },
+      { type: "google_api_key", regex: /AIza[0-9A-Za-z\-_]{35}/g },
+      // SaaS API keys
+      { type: "github_token", regex: /gh[pousr]_[a-zA-Z0-9]{30,}/g },
+      { type: "slack_token", regex: /xox[bpas]-[0-9]{8,13}-[0-9]{8,13}-[a-zA-Z0-9]{20,}/g },
+      { type: "stripe_key", regex: /sk_(live|test)_[a-zA-Z0-9]{24,}/g },
+      { type: "sendgrid_key", regex: /SG\.[a-zA-Z0-9\-_]{22,}\.[a-zA-Z0-9\-_]{22,}/g },
+      { type: "huggingface_token", regex: /hf_[a-zA-Z0-9]{30,}/g },
+      // Auth / session tokens
+      { type: "jwt", regex: /eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/g },
+      // Credentials in URLs (before env_value so it wins on connection strings)
+      { type: "url_credentials", regex: /\w+:\/\/[^:@\s\/]{1,64}:[^@\s]{4,}@[^\s]/g },
+      // Passwords in key=value and JSON
+      { type: "password", regex: /(?:password|passwd|pwd)["']?\s*[=:]\s*["']?([^\s"',]{6,})/gi },
+      // PII — financial
+      {
+        type: "credit_card",
+        regex: /\b\d{4}[\s\-]\d{4}[\s\-]\d{4}[\s\-]\d{4}\b/g,
+        validate: (v) => luhnCheck(v)
+      },
+      {
+        type: "iban",
+        regex: /\b[A-Z]{2}\d{2}[A-Z0-9]{4,30}\b/g,
+        validate: (v) => ibanCheck(v)
+      },
+      // PII — identity (context-aware)
+      {
+        type: "ssn",
+        regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+        validate: (_v, input, idx) => {
+          if (contextMatches(SSN_KEYWORDS, input, idx))
+            return true;
+          const surrounding = input.slice(Math.max(0, idx - 20), idx + 20);
+          if (/(?:19|20)\d{2}/.test(surrounding))
+            return false;
+          return true;
+        }
+      },
+      {
+        type: "dob",
+        regex: /\b(?:0?[1-9]|1[0-2])[-\/](?:0?[1-9]|[12]\d|3[01])[-\/](?:19|20)\d{2}\b/g,
+        validate: (_v, input, idx) => contextMatches(DOB_KEYWORDS, input, idx)
+      },
+      {
+        type: "passport",
+        regex: /\b[A-Z]\d{8}\b/g,
+        validate: (_v, input, idx) => contextMatches(PASS_KEYWORDS, input, idx)
+      },
+      // PII — contact
+      { type: "email", regex: /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g },
+      {
+        type: "phone_us",
+        // Requires area code starting 2-9 (excludes version numbers, dates, plain 7-digit numbers)
+        regex: /\b(?:\+?1[-.\s]?)?\(?([2-9][0-9]{2})\)?[-.\s]([2-9][0-9]{2})[-.\s]([0-9]{4})\b/g
+      },
+      {
+        type: "phone_e164",
+        // E.164 international (non-US, min 8 digits after +)
+        regex: /\+(?!1[^0-9])(?:[2-9][0-9]{1}|[1][^1])[0-9]{6,12}\b/g
+      },
+      // Network — internal RFC-1918 addresses
+      {
+        type: "internal_ip",
+        regex: /\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b/g
+      },
+      // Generic env assignment (lowest priority — catches remaining secrets)
+      { type: "env_value", regex: /\b[A-Z][A-Z0-9_]{2,}=[^\s]{8,}/g }
+    ];
+    SEVERITY2 = {
+      private_key: "critical",
+      credit_card: "critical",
+      ssn: "critical",
+      iban: "critical",
+      aws_access_key: "high",
+      anthropic_api_key: "high",
+      openai_api_key: "high",
+      google_api_key: "high",
+      github_token: "high",
+      slack_token: "high",
+      stripe_key: "high",
+      sendgrid_key: "high",
+      huggingface_token: "high",
+      jwt: "high",
+      url_credentials: "high",
+      password: "high",
+      credential_pair: "high",
+      passport: "high",
+      dob: "high",
+      email: "medium",
+      phone_us: "medium",
+      phone_e164: "medium",
+      internal_ip: "low",
+      env_value: "low"
+    };
+    CATEGORY = {
+      private_key: "credential",
+      credit_card: "financial",
+      ssn: "identity",
+      iban: "financial",
+      passport: "identity",
+      dob: "identity",
+      aws_access_key: "credential",
+      anthropic_api_key: "credential",
+      openai_api_key: "credential",
+      google_api_key: "credential",
+      github_token: "credential",
+      slack_token: "credential",
+      stripe_key: "credential",
+      sendgrid_key: "credential",
+      huggingface_token: "credential",
+      jwt: "credential",
+      url_credentials: "credential",
+      password: "credential",
+      credential_pair: "credential",
+      email: "contact",
+      phone_us: "contact",
+      phone_e164: "contact",
+      internal_ip: "network",
+      env_value: "credential"
+    };
+    EMAIL_RE = /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g;
+    PAIR_WINDOW = 100;
+  }
+});
+
+// src/cli/import.ts
+var import_exports = {};
+__export(import_exports, {
+  importGptConversations: () => importGptConversations,
+  runImport: () => runImport
+});
+function unixToIso(ts) {
+  if (!ts)
+    return (/* @__PURE__ */ new Date()).toISOString().replace("Z", "+00:00");
+  return new Date(ts * 1e3).toISOString().replace("Z", "+00:00");
+}
+function extractText(content) {
+  if (!content)
+    return "";
+  if (!content.parts)
+    return "";
+  return content.parts.filter((p) => typeof p === "string" && p.trim().length > 0).join("\n").trim();
+}
+function maskValue(v) {
+  return v.length > 8 ? v.slice(0, 4) + "****" + v.slice(-4) : "****";
+}
+function linearize(mapping) {
+  const root = Object.values(mapping).find((n) => n.parent === null || !mapping[n.parent ?? ""]);
+  if (!root)
+    return [];
+  const path = [];
+  let current = root;
+  while (current) {
+    path.push(current);
+    const lastChildId = current.children[current.children.length - 1];
+    current = lastChildId ? mapping[lastChildId] : void 0;
+  }
+  return path;
+}
+function messagesFromConversation(conv) {
+  const nodes = linearize(conv.mapping);
+  const result = [];
+  for (const node of nodes) {
+    const msg = node.message;
+    if (!msg)
+      continue;
+    const role = msg.author.role;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    const text2 = extractText(msg.content);
+    if (!text2)
+      continue;
+    result.push({ role, content: text2, ts: unixToIso(msg.create_time) });
+  }
+  return result;
+}
+function findFile(dir, name) {
+  for (const entry of (0, import_fs11.readdirSync)(dir)) {
+    const full = (0, import_path10.join)(dir, entry);
+    try {
+      if ((0, import_fs11.statSync)(full).isDirectory()) {
+        const found = findFile(full, name);
+        if (found)
+          return found;
+      } else if (entry === name) {
+        return full;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function importGptConversations(db, conversations) {
+  let imported = 0;
+  let skipped = 0;
+  let totalMessages = 0;
+  let totalSecrets = 0;
+  const errors = [];
+  for (const conv of conversations) {
+    const externalRef = `chatgpt:${conv.id}`;
+    const displayTitle = (conv.title ?? "Untitled").slice(0, 60);
+    const [existing] = await db.select({ id: sessions.id }).from(sessions).where(eq(sessions.external_ref, externalRef)).limit(1);
+    if (existing) {
+      skipped++;
+      continue;
+    }
+    const msgs = messagesFromConversation(conv);
+    if (msgs.length === 0) {
+      skipped++;
+      continue;
+    }
+    try {
+      let sessionSecrets = 0;
+      await db.transaction(async (tx) => {
+        let baseTitle = (conv.title ?? "Untitled ChatGPT conversation").slice(0, 500);
+        const [titleConflict] = await tx.select({ id: sessions.id }).from(sessions).where(eq(sessions.title, baseTitle)).limit(1);
+        if (titleConflict) {
+          baseTitle = `${baseTitle} (${conv.id.slice(0, 8)})`.slice(0, 500);
+        }
+        const sessionId = v4_default();
+        let publicKey = null;
+        try {
+          publicKey = generateSessionKeypair(sessionId);
+        } catch {
+        }
+        await tx.insert(sessions).values({
+          id: sessionId,
+          title: baseTitle,
+          ai_tool: "chatgpt",
+          created_at: unixToIso(conv.create_time),
+          updated_at: unixToIso(conv.update_time),
+          external_ref: externalRef,
+          parent_session_id: null,
+          public_key: publicKey
+        });
+        let prevHash = null;
+        for (const m of msgs) {
+          const msgId = v4_default();
+          const hash = computeContentHash(sessionId, m.role, m.content, m.ts, prevHash, "message");
+          await tx.insert(messages).values({
+            id: msgId,
+            session_id: sessionId,
+            role: m.role,
+            content: m.content,
+            created_at: m.ts,
+            prev_hash: prevHash,
+            content_hash: hash,
+            event_type: "message"
+          });
+          if (m.role === "user") {
+            const found = scanForSecrets(m.content);
+            if (found.length > 0) {
+              const now = (/* @__PURE__ */ new Date()).toISOString().replace("Z", "+00:00");
+              await tx.insert(secrets_detected).values(
+                found.map((s) => ({
+                  id: v4_default(),
+                  session_id: sessionId,
+                  message_id: msgId,
+                  type: s.type,
+                  masked_value: maskValue(s.value),
+                  detected_at: now
+                }))
+              );
+              sessionSecrets += found.length;
+              totalSecrets += found.length;
+            }
+          }
+          prevHash = hash;
+        }
+      });
+      totalMessages += msgs.length;
+      imported++;
+    } catch (err) {
+      errors.push({ title: displayTitle, error: err?.message ?? String(err) });
+    }
+  }
+  return { imported, skipped, totalMessages, totalSecrets, errors };
+}
+async function importConversations(filePath) {
+  const db = await initDb();
+  let raw;
+  let tempDir = null;
+  const ext = (0, import_path10.extname)(filePath).toLowerCase();
+  if (ext === ".zip") {
+    tempDir = (0, import_path10.join)((0, import_os10.tmpdir)(), `chron-import-${Date.now()}`);
+    (0, import_fs11.mkdirSync)(tempDir, { recursive: true });
+    try {
+      (0, import_child_process4.execFileSync)("unzip", ["-q", "-o", filePath, "conversations.json", "-d", tempDir], { stdio: "pipe" });
+    } catch {
+      try {
+        (0, import_child_process4.execFileSync)("unzip", ["-q", "-o", filePath, "-d", tempDir], { stdio: "pipe" });
+      } catch {
+        process.stderr.write(`Failed to extract ${filePath}. Make sure 'unzip' is installed.
+`);
+        (0, import_fs11.rmSync)(tempDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+    }
+    const found = findFile(tempDir, "conversations.json");
+    if (!found) {
+      process.stderr.write(`conversations.json not found inside the ZIP.
+`);
+      (0, import_fs11.rmSync)(tempDir, { recursive: true, force: true });
+      process.exit(1);
+    }
+    raw = (0, import_fs11.readFileSync)(found, "utf8");
+  } else if (ext === ".json") {
+    raw = (0, import_fs11.readFileSync)(filePath, "utf8");
+  } else {
+    process.stderr.write(`Unsupported file type: ${ext}. Pass a .zip export or a conversations.json file.
+`);
+    process.exit(1);
+  }
+  let conversations;
+  try {
+    conversations = JSON.parse(raw);
+    if (!Array.isArray(conversations))
+      throw new Error("Expected a JSON array");
+  } catch {
+    process.stderr.write(`Failed to parse conversations JSON.
+`);
+    if (tempDir)
+      (0, import_fs11.rmSync)(tempDir, { recursive: true, force: true });
+    process.exit(1);
+  }
+  process.stdout.write(`
+${BOLD9}chron import chatgpt${RESET9}  ${DIM8}${filePath}${RESET9}
+`);
+  process.stdout.write(`${DIM8}${conversations.length} conversation(s) found${RESET9}
+
+`);
+  const result = await importGptConversations(db, conversations);
+  for (const e of result.errors) {
+    process.stderr.write(`  ${YELLOW7}!${RESET9} Failed to import "${e.title}": ${e.error}
+`);
+  }
+  if (tempDir)
+    (0, import_fs11.rmSync)(tempDir, { recursive: true, force: true });
+  process.stdout.write("\n");
+  process.stdout.write(`${BOLD9}Done.${RESET9}  `);
+  process.stdout.write(`${GREEN6}${result.imported} imported${RESET9}`);
+  if (result.skipped > 0)
+    process.stdout.write(`  ${DIM8}${result.skipped} skipped (already in DB)${RESET9}`);
+  process.stdout.write(`  ${CYAN7}${result.totalMessages} messages total${RESET9}`);
+  if (result.totalSecrets > 0)
+    process.stdout.write(`  ${YELLOW7}${result.totalSecrets} secret(s) detected${RESET9}`);
+  if (result.errors.length > 0)
+    process.stdout.write(`  ${YELLOW7}${result.errors.length} error(s)${RESET9}`);
+  process.stdout.write("\n\n");
+  process.stdout.write(`${DIM8}Run 'chron history' to browse imported sessions.${RESET9}
+
+`);
+}
+async function runImport(args2) {
+  const [subcommand, filePath] = args2;
+  if (subcommand !== "chatgpt" || !filePath) {
+    process.stderr.write(
+      "Usage: chron import chatgpt <file>\n\n  <file>  Path to ChatGPT export ZIP (chatgpt-export-*.zip)\n          or extracted conversations.json\n\nExample:\n  chron import chatgpt ~/Downloads/chatgpt-export.zip\n  chron import chatgpt ~/Downloads/conversations.json\n"
+    );
+    process.exit(1);
+  }
+  const resolved = filePath.replace(/^~/, process.env.HOME ?? "");
+  if (!(0, import_fs11.existsSync)(resolved)) {
+    process.stderr.write(`File not found: ${resolved}
+`);
+    process.exit(1);
+  }
+  await importConversations(resolved);
+}
+var import_fs11, import_path10, import_os10, import_child_process4, RESET9, BOLD9, DIM8, GREEN6, YELLOW7, CYAN7;
+var init_import = __esm({
+  "src/cli/import.ts"() {
+    "use strict";
+    import_fs11 = require("fs");
+    import_path10 = require("path");
+    import_os10 = require("os");
+    import_child_process4 = require("child_process");
+    init_drizzle_orm();
+    init_esm();
+    init_db2();
+    init_schema();
+    init_hash();
+    init_detect();
+    init_signing();
+    RESET9 = "\x1B[0m";
+    BOLD9 = "\x1B[1m";
+    DIM8 = "\x1B[2m";
+    GREEN6 = "\x1B[32m";
+    YELLOW7 = "\x1B[33m";
+    CYAN7 = "\x1B[36m";
   }
 });
 
@@ -19201,6 +19959,11 @@ async function main() {
       await runDoctor2(args);
       break;
     }
+    case "import": {
+      const { runImport: runImport2 } = await Promise.resolve().then(() => (init_import(), import_exports));
+      await runImport2(args);
+      break;
+    }
     default: {
       const name = command ? `Unknown command: ${command}
 
@@ -19214,12 +19977,13 @@ 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
   prune           Delete sessions older than a retention cutoff
   doctor          Check your Chron setup \u2014 Node version, DB, MCP configs, SIEM
+  import          Import conversations from external AI tools
 
 Options (history):
   --limit=<n>     Max sessions to show (default: 20)
@@ -19249,6 +20013,9 @@ Options (prune):
 
 Options (doctor):
   --json             Machine-readable JSON output
+
+Options (import):
+  chatgpt <file>     Import from ChatGPT export (.zip or conversations.json)
 `
       );
       process.exit(command ? 1 : 0);

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);
@@ -38479,7 +38480,7 @@ var init_time = __esm({
 var version4;
 var init_package = __esm({
   "package.json"() {
-    version4 = "0.1.25";
+    version4 = "0.1.28";
   }
 });
 
@@ -38837,6 +38838,31 @@ var init_ntp = __esm({
   }
 });
 
+// src/utils/terminal.ts
+function terminalAudit(message) {
+  const setting = process.env.CHRON_TERMINAL_AUDIT;
+  if (setting && DISABLE_VALUES.has(setting.toLowerCase()))
+    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 +38893,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})`);
       return {
         content: [{
           type: "text",
@@ -38882,6 +38909,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})`);
       return {
         content: [{
           type: "text",
@@ -38918,6 +38946,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})`);
     } 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 +38957,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})`);
     }
     emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: session_id.slice(0, 8), ai_tool } });
     const limit = args.limit ?? 10;
@@ -39016,6 +39046,7 @@ var init_sessions = __esm({
     init_relay();
     init_signing();
     init_ntp();
+    init_terminal();
   }
 });
 
@@ -39328,7 +39359,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 +39376,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 +39398,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 +39548,7 @@ var init_messages = __esm({
     init_hash();
     init_detect();
     init_relay();
+    init_terminal();
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.25",
+  "version": "0.1.28",
   "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.