chron-mcp 0.1.0

package/README.md

@@ -0,0 +1,207 @@
+# Chron
+
+> A timestamped audit trail for every AI conversation — stored locally, owned by you.
+
+AI tools show when you sent a message. Chron logs when the AI responded too — and keeps a permanent, queryable record of every exchange across every tool you use.
+
+Works with Claude Desktop, Claude Code, Cursor, Windsurf, and any MCP-compatible AI tool.
+
+---
+
+## Why
+
+AI tools produce no audit trail by default. You cannot answer:
+- What did the AI say, and when exactly?
+- How long did the AI take to respond?
+- What was the full conversation that produced this output?
+- What did I ask Claude last week about this codebase?
+
+Chron fixes that. Every exchange is logged with a precise local datetime (including timezone offset) to a SQLite file you own. No cloud, no vendor lock-in, no data leaving your machine.
+
+---
+
+## Install
+
+Add to your AI tool's MCP config:
+
+```json
+{
+  "mcpServers": {
+    "chron": {
+      "command": "npx",
+      "args": ["-y", "chron-mcp"]
+    }
+  }
+}
+```
+
+First run creates `~/.chron/chron.db` automatically. No database setup, no env vars, no migrations.
+
+---
+
+## What it logs
+
+Every exchange is recorded with precise local timestamps — user message when received, assistant response when sent:
+
+```
+[user: 2026-05-08 14:32:11 +02:00 | assistant: 2026-05-08 14:32:43 +02:00]
+
+The main risks of deploying this contract are...
+```
+
+The gap between user and assistant timestamps is real generation time. Both are stored in your local SQLite DB with full timezone offset.
+
+---
+
+## Config by tool
+
+### Claude Desktop
+
+Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "chron": {
+      "command": "npx",
+      "args": ["-y", "chron-mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add chron npx -y chron-mcp
+```
+
+Then add the skill hook to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cat ~/.chron/chron.skill.md"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Cursor
+
+Edit `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "chron": {
+      "command": "npx",
+      "args": ["-y", "chron-mcp"]
+    }
+  }
+}
+```
+
+### Windsurf
+
+Edit `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "chron": {
+      "command": "npx",
+      "args": ["-y", "chron-mcp"]
+    }
+  }
+}
+```
+
+---
+
+## Companion skill file
+
+Chron ships with `skills/chron.skill.md` — a plain-text instruction file that tells the AI how to use the MCP tools automatically. Load it into your AI tool once. After that, the AI:
+
+1. Creates or resumes a named session at the start of every conversation
+2. Logs your message before it starts responding (captures the real user timestamp)
+3. Logs its response after composing it (captures the real assistant timestamp)
+4. Shows `[user: YYYY-MM-DD HH:MM:SS ±HH:MM | assistant: YYYY-MM-DD HH:MM:SS ±HH:MM]` at the top of every response
+5. Retrieves prior session history so context is never lost across conversations
+
+---
+
+## MCP Tools
+
+| Tool | Description |
+|---|---|
+| `start_session` | Create or resume a named audit session |
+| `log_message` | Record a single message with the current local datetime |
+| `log_exchange` | Log a user/assistant pair atomically (for batch imports) |
+| `list_sessions` | List all sessions ordered by most recently active |
+| `get_session_history` | Retrieve the full timestamped log for a session |
+
+---
+
+## Configuration
+
+| Env var | Default | Description |
+|---|---|---|
+| `CHRON_DB_PATH` | `~/.chron/chron.db` | Path to SQLite database file |
+| `CHRON_TRANSPORT` | `stdio` | Set to `http` to enable HTTP+SSE mode |
+| `CHRON_API_KEY` | _(none)_ | Bearer token for HTTP mode |
+| `PORT` | `3001` | Port for HTTP mode |
+
+---
+
+## HTTP+SSE mode (team / self-hosted)
+
+For teams or remote use, run Chron as an HTTP server:
+
+```bash
+CHRON_TRANSPORT=http CHRON_API_KEY=your-key PORT=3001 npx chron-mcp
+```
+
+Point your MCP config at the URL:
+
+```json
+{
+  "mcpServers": {
+    "chron": {
+      "url": "https://your-server/mcp",
+      "headers": {
+        "Authorization": "Bearer your-key"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Your data
+
+Your audit log lives at `~/.chron/chron.db` — a single SQLite file on your machine. Query it directly with any SQLite tool:
+
+```bash
+sqlite3 ~/.chron/chron.db \
+  "SELECT s.title, m.role, m.content, m.created_at
+   FROM messages m JOIN sessions s ON s.id = m.session_id
+   ORDER BY m.created_at"
+```
+
+No cloud, no telemetry, no data leaving your machine. Change the location with `CHRON_DB_PATH`.
+
+---
+
+## License
+
+MIT

package/dist/db/index.d.ts

@@ -0,0 +1,3 @@
+import * as schema from './schema';
+export declare function initDb(dbPath?: string): Promise<import("drizzle-orm/libsql").LibSQLDatabase<typeof schema>>;
+export type Db = Awaited<ReturnType<typeof initDb>>;

package/dist/db/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDb = initDb;
+const client_1 = require("@libsql/client");
+const libsql_1 = require("drizzle-orm/libsql");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const schema = __importStar(require("./schema"));
+function getDbPath() {
+    const envPath = process.env.CHRON_DB_PATH;
+    if (envPath)
+        return envPath;
+    return (0, path_1.join)((0, os_1.homedir)(), '.chron', 'chron.db');
+}
+const CREATE_SQL = [
+    `CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    ai_tool TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+  )`,
+];
+async function initDb(dbPath) {
+    const path = dbPath ?? getDbPath();
+    if (!path.startsWith(':')) {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+    }
+    const client = (0, client_1.createClient)({ url: path.startsWith(':') ? path : `file:${path}` });
+    await client.execute('PRAGMA journal_mode = WAL');
+    await client.execute('PRAGMA foreign_keys = ON');
+    for (const sql of CREATE_SQL) {
+        await client.execute(sql);
+    }
+    return (0, libsql_1.drizzle)(client, { schema });
+}

package/dist/db/schema.d.ts

@@ -0,0 +1,134 @@
+export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "title";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        ai_tool: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "ai_tool";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "messages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        session_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "session_id";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        role: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "role";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "user" | "assistant";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: ["user", "assistant"];
+            baseColumn: never;
+        }, object>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/db/schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messages = exports.sessions = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+exports.sessions = (0, sqlite_core_1.sqliteTable)('sessions', {
+    id: (0, sqlite_core_1.text)('id').primaryKey(),
+    title: (0, sqlite_core_1.text)('title').notNull(),
+    ai_tool: (0, sqlite_core_1.text)('ai_tool'),
+    created_at: (0, sqlite_core_1.text)('created_at').notNull(),
+    updated_at: (0, sqlite_core_1.text)('updated_at').notNull(),
+});
+exports.messages = (0, sqlite_core_1.sqliteTable)('messages', {
+    id: (0, sqlite_core_1.text)('id').primaryKey(),
+    session_id: (0, sqlite_core_1.text)('session_id').notNull(),
+    role: (0, sqlite_core_1.text)('role', { enum: ['user', 'assistant'] }).notNull(),
+    content: (0, sqlite_core_1.text)('content').notNull(),
+    created_at: (0, sqlite_core_1.text)('created_at').notNull(),
+});

package/dist/http/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { Request, Response, NextFunction } from 'express';
+export declare function apiKeyMiddleware(apiKey: string): (req: Request, res: Response, next: NextFunction) => void;

package/dist/http/middleware.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyMiddleware = apiKeyMiddleware;
+function apiKeyMiddleware(apiKey) {
+    return (req, res, next) => {
+        const header = req.headers.authorization;
+        if (!header || header !== `Bearer ${apiKey}`) {
+            res.status(401).end();
+            return;
+        }
+        next();
+    };
+}

package/dist/http/server.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Db } from '../db/index';
+export declare function startHttpServer(server: McpServer, db: Db): Promise<void>;

package/dist/http/server.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHttpServer = startHttpServer;
+const express_1 = __importDefault(require("express"));
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const middleware_1 = require("./middleware");
+const server_1 = require("../server");
+async function startHttpServer(server, db) {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    const apiKey = process.env.CHRON_API_KEY;
+    if (apiKey) {
+        app.use((0, middleware_1.apiKeyMiddleware)(apiKey));
+    }
+    const transports = new Map();
+    app.get('/sse', async (req, res) => {
+        const instanceServer = (0, server_1.createServer)(db);
+        const transport = new sse_js_1.SSEServerTransport('/messages', res);
+        transports.set(transport.sessionId, { transport, server: instanceServer });
+        transport.onclose = () => transports.delete(transport.sessionId);
+        await instanceServer.connect(transport);
+    });
+    app.post('/messages', async (req, res) => {
+        const sessionId = req.query.sessionId;
+        const entry = transports.get(sessionId);
+        if (!entry) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        await entry.transport.handlePostMessage(req, res);
+    });
+    const port = parseInt(process.env.PORT ?? '3001', 10);
+    await new Promise(resolve => app.listen(port, resolve));
+    process.stderr.write(`Chron HTTP server listening on port ${port}\n`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const index_1 = require("./db/index");
+const server_1 = require("./server");
+async function main() {
+    const db = await (0, index_1.initDb)();
+    const server = (0, server_1.createServer)(db);
+    if (process.env.CHRON_TRANSPORT === 'http') {
+        const { startHttpServer } = await Promise.resolve().then(() => __importStar(require('./http/server')));
+        await startHttpServer(server, db);
+    }
+    else {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`Failed to start chron: ${err}\n`);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Db } from './db/index';
+export declare function createServer(db: Db): McpServer;

package/dist/server.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const sessions_1 = require("./tools/sessions");
+const messages_1 = require("./tools/messages");
+const roleEnum = zod_1.z.enum(['user', 'assistant']);
+function createServer(db) {
+    const server = new mcp_js_1.McpServer({
+        name: 'chron',
+        version: '0.1.0',
+    });
+    // @ts-expect-error — MCP SDK deep generic type instantiation limit hit; runtime types are correct
+    server.tool('start_session', 'Create a new audit session or resume an existing one by title. Call this at the start of every conversation.', {
+        title: zod_1.z.string().describe('Descriptive session title, e.g. "Contract review — 2026-05-08"'),
+        ai_tool: zod_1.z.string().optional().describe('AI tool name: "claude", "cursor", "windsurf", etc.'),
+    }, (0, sessions_1.startSession)(db));
+    server.tool('log_message', 'Record a single message (user or assistant) with the current UTC datetime. Call before responding for user messages, and before sending for assistant messages.', {
+        session_id: zod_1.z.string().describe('Session ID returned by start_session'),
+        role: roleEnum,
+        content: zod_1.z.string().describe('Full message text'),
+    }, (0, messages_1.logMessage)(db));
+    server.tool('log_exchange', 'Log a user message and assistant response together in one call. Preferred over two log_message calls — faster and atomic.', {
+        session_id: zod_1.z.string().describe('Session ID returned by start_session'),
+        user_content: zod_1.z.string().describe('The exact user message'),
+        assistant_content: zod_1.z.string().describe('The exact assistant response'),
+    }, (0, messages_1.logExchange)(db));
+    // @ts-expect-error — MCP SDK deep generic type instantiation limit hit; runtime types are correct
+    server.tool('list_sessions', 'List all audit sessions ordered by most recently active. Returns id, title, ai_tool, message_count, created_at, updated_at.', {
+        limit: zod_1.z.number().int().positive().optional().describe('Return only the most recent N sessions'),
+    }, (0, sessions_1.listSessions)(db));
+    server.tool('get_session_history', 'Retrieve the full timestamped audit log for a session, oldest first.', {
+        session_id: zod_1.z.string(),
+        limit: zod_1.z.number().int().positive().optional().describe('Return only the most recent N messages'),
+    }, (0, sessions_1.getSessionHistory)(db));
+    return server;
+}

package/dist/tools/messages.d.ts

@@ -0,0 +1,21 @@
+import type { Db } from '../db/index';
+export declare function logMessage(db: Db): (args: {
+    session_id: string;
+    role: "user" | "assistant";
+    content: string;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function logExchange(db: Db): (args: {
+    session_id: string;
+    user_content: string;
+    assistant_content: string;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/messages.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logMessage = logMessage;
+exports.logExchange = logExchange;
+const drizzle_orm_1 = require("drizzle-orm");
+const uuid_1 = require("uuid");
+const schema_1 = require("../db/schema");
+const time_1 = require("../utils/time");
+function logMessage(db) {
+    return async (args) => {
+        const now = (0, time_1.localISOString)();
+        const id = (0, uuid_1.v4)();
+        await db.insert(schema_1.messages).values({
+            id,
+            session_id: args.session_id,
+            role: args.role,
+            content: args.content,
+            created_at: now,
+        });
+        await db.update(schema_1.sessions)
+            .set({ updated_at: now })
+            .where((0, drizzle_orm_1.eq)(schema_1.sessions.id, args.session_id));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ message_id: id, created_at: now }) }],
+        };
+    };
+}
+function logExchange(db) {
+    return async (args) => {
+        const userNow = (0, time_1.localISOString)();
+        const userId = (0, uuid_1.v4)();
+        const assistantNow = (0, time_1.localISOString)();
+        const assistantId = (0, uuid_1.v4)();
+        await db.insert(schema_1.messages).values({
+            id: userId,
+            session_id: args.session_id,
+            role: 'user',
+            content: args.user_content,
+            created_at: userNow,
+        });
+        await db.insert(schema_1.messages).values({
+            id: assistantId,
+            session_id: args.session_id,
+            role: 'assistant',
+            content: args.assistant_content,
+            created_at: assistantNow,
+        });
+        await db.update(schema_1.sessions)
+            .set({ updated_at: assistantNow })
+            .where((0, drizzle_orm_1.eq)(schema_1.sessions.id, args.session_id));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        user_message_id: userId,
+                        user_created_at: userNow,
+                        assistant_message_id: assistantId,
+                        assistant_created_at: assistantNow,
+                    }),
+                }],
+        };
+    };
+}

package/dist/tools/sessions.d.ts

@@ -0,0 +1,27 @@
+import type { Db } from '../db/index';
+export declare function startSession(db: Db): (args: {
+    title: string;
+    ai_tool?: string;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function listSessions(db: Db): (args: {
+    limit?: number;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function getSessionHistory(db: Db): (args: {
+    session_id: string;
+    limit?: number;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/sessions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSession = startSession;
+exports.listSessions = listSessions;
+exports.getSessionHistory = getSessionHistory;
+const drizzle_orm_1 = require("drizzle-orm");
+const uuid_1 = require("uuid");
+const schema_1 = require("../db/schema");
+const time_1 = require("../utils/time");
+function startSession(db) {
+    return async (args) => {
+        const existing = await db.select().from(schema_1.sessions).where((0, drizzle_orm_1.eq)(schema_1.sessions.title, args.title));
+        if (existing.length > 0) {
+            const session = existing[0];
+            const now = (0, time_1.localISOString)();
+            const allMessages = await db.select().from(schema_1.messages).where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, session.id));
+            await db.update(schema_1.sessions).set({ updated_at: now }).where((0, drizzle_orm_1.eq)(schema_1.sessions.id, session.id));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ session_id: session.id, created: false, message_count: allMessages.length, ai_tool: session.ai_tool }),
+                    }],
+            };
+        }
+        const now = (0, time_1.localISOString)();
+        const id = (0, uuid_1.v4)();
+        await db.insert(schema_1.sessions).values({
+            id,
+            title: args.title,
+            ai_tool: args.ai_tool ?? null,
+            created_at: now,
+            updated_at: now,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ session_id: id, created: true, message_count: 0, ai_tool: args.ai_tool ?? null }),
+                }],
+        };
+    };
+}
+function listSessions(db) {
+    return async (args) => {
+        const rows = await db.select({
+            id: schema_1.sessions.id,
+            title: schema_1.sessions.title,
+            ai_tool: schema_1.sessions.ai_tool,
+            created_at: schema_1.sessions.created_at,
+            updated_at: schema_1.sessions.updated_at,
+            message_count: (0, drizzle_orm_1.sql) `count(${schema_1.messages.id})`,
+        })
+            .from(schema_1.sessions)
+            .leftJoin(schema_1.messages, (0, drizzle_orm_1.eq)(schema_1.messages.session_id, schema_1.sessions.id))
+            .groupBy(schema_1.sessions.id)
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.sessions.updated_at));
+        const limited = args.limit != null ? rows.slice(0, args.limit) : rows;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ sessions: limited, total: rows.length }),
+                }],
+        };
+    };
+}
+function getSessionHistory(db) {
+    return async (args) => {
+        const all = await db.select().from(schema_1.messages)
+            .where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, args.session_id))
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.messages.created_at));
+        const limited = args.limit != null ? all.slice(-args.limit) : all;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        messages: limited.map(m => ({ role: m.role, content: m.content, created_at: m.created_at })),
+                        total: all.length,
+                    }),
+                }],
+        };
+    };
+}

package/dist/utils/time.d.ts

@@ -0,0 +1 @@
+export declare function localISOString(): string;

package/dist/utils/time.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localISOString = localISOString;
+function localISOString() {
+    const d = new Date();
+    const offsetMin = -d.getTimezoneOffset(); // positive for UTC+, negative for UTC-
+    const sign = offsetMin >= 0 ? '+' : '-';
+    const absMin = Math.abs(offsetMin);
+    const hh = String(Math.floor(absMin / 60)).padStart(2, '0');
+    const mm = String(absMin % 60).padStart(2, '0');
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    const hours = String(d.getHours()).padStart(2, '0');
+    const minutes = String(d.getMinutes()).padStart(2, '0');
+    const seconds = String(d.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${sign}${hh}:${mm}`;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "chron-mcp",
+  "version": "0.1.0",
+  "description": "Audit-grade timestamped logs for every AI conversation",
+  "main": "dist/index.js",
+  "vitest": {
+    "include": ["tests/**/*.test.ts"],
+    "globals": true
+  },
+  "bin": {
+    "chron-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "ai",
+    "audit",
+    "logging",
+    "claude",
+    "cursor"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@libsql/client": "^0.17.3",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "drizzle-orm": "^0.30.10",
+    "express": "^4.18.2",
+    "uuid": "^9.0.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.0",
+    "drizzle-kit": "^0.20.14",
+    "typescript": "^5.4.5",
+    "vitest": "^1.4.0"
+  }
+}

package/skills/chron.skill.md

@@ -0,0 +1,32 @@
+# Chron — AI Audit Log Skill
+
+Chron creates an audit trail of every AI conversation. Every message is logged with a precise local datetime (with timezone offset) to a local SQLite database the user owns.
+
+## Session Start
+
+Call `start_session` with a descriptive title (e.g. "Contract review — 2026-05-08") and set `ai_tool` to your tool name (e.g. "claude", "cursor", "windsurf").
+
+Call `get_session_history` for the returned `session_id`. If prior messages exist, display:
+> "Resuming session: [N messages] since [first_message_date]"
+
+## Every Exchange
+
+1. Call `log_message(session_id, role="user", content=<exact user message>)` → returns T1
+2. Compose your response body (plain text only — no timestamp header)
+3. Call `log_message(session_id, role="assistant", content=<response body>)` → returns T2
+4. Output header + body:
+
+```
+[user: YYYY-MM-DD HH:MM:SS ±HH:MM | assistant: YYYY-MM-DD HH:MM:SS ±HH:MM]
+
+<response body>
+```
+
+T1 and T2 are real server timestamps — T2 − T1 is the actual generation time. The DB stores clean body content without the header.
+
+**Do not use `log_exchange` for live conversations** — it captures both timestamps at the same instant and cannot show a real gap. Use it only for batch imports of historical messages.
+
+## If Chron MCP is unavailable
+
+State once: "Chron is not connected — this conversation will not be logged."
+Continue normally. Do not retry repeatedly.