token-goat 2.9.13 → 2.9.15

package/dist/token-goat-chunk-OUGNPMDA.mjs

@@ -0,0 +1,959 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  enqueueDirtyPathSafe,
+  getTrackedFiles
+} from "./token-goat-chunk-BL5LNGBG.mjs";
+import {
+  getToolName,
+  indexRecallEntry
+} from "./token-goat-chunk-YQ7WI2CO.mjs";
+import {
+  PARSER_FINGERPRINT
+} from "./token-goat-chunk-NDRP4KJQ.mjs";
+import {
+  getProjectFileEntries
+} from "./token-goat-chunk-2X2EBBC6.mjs";
+import {
+  isBlobStale,
+  loadBlob,
+  redactSecrets,
+  storeBlob
+} from "./token-goat-chunk-IVUQLQWN.mjs";
+import {
+  getDb
+} from "./token-goat-chunk-K7F2BFIK.mjs";
+import {
+  fingerprintFile,
+  getDisplayRoot,
+  shortFingerprint
+} from "./token-goat-chunk-S4XRY446.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  SYMBOL_BODY_CHAR_CAP,
+  countNoun,
+  extractErrorMessage,
+  foldPath,
+  globalDbPath
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  displaySafeJson,
+  normalizePath,
+  resolveIndexPath,
+  toDisplayPath
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  compileGuardedRegex
+} from "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/web_cache.ts
+init_define_import_meta_env();
+var WEB_OUTPUT_SUBDIR = "web_outputs";
+var _byId = /* @__PURE__ */ new Map();
+var _rawById = /* @__PURE__ */ new Map();
+var _urlIndex = /* @__PURE__ */ new Map();
+function cacheIdForUrl(url) {
+  return shortFingerprint(url);
+}
+function storeWebOutput(url, content, dedupKey = url, rawContent) {
+  const cacheId = cacheIdForUrl(dedupKey);
+  const redactedContent = redactSecrets(content).text;
+  _byId.set(cacheId, redactedContent);
+  _urlIndex.set(url, cacheId);
+  const redactedRaw = rawContent !== void 0 && rawContent !== content ? redactSecrets(rawContent).text : void 0;
+  if (redactedRaw !== void 0) _rawById.set(cacheId, redactedRaw);
+  else _rawById.delete(cacheId);
+  storeBlob(WEB_OUTPUT_SUBDIR, cacheId, redactedRaw !== void 0 ? { url, content: redactedContent, raw: redactedRaw } : { url, content: redactedContent });
+  const redactedUrl = redactSecrets(url).text;
+  indexRecallEntry("web", cacheId, redactedUrl, `${redactedUrl}
+${redactedContent}`, Date.now());
+  return cacheId;
+}
+function coerceWebBlob(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o["content"] !== "string") return null;
+  return { url: typeof o["url"] === "string" ? o["url"] : null, content: o["content"], raw: typeof o["raw"] === "string" ? o["raw"] : null };
+}
+function getWebOutput(cacheId) {
+  const hit = _byId.get(cacheId);
+  if (hit !== void 0) return hit;
+  if (isBlobStale(WEB_OUTPUT_SUBDIR, cacheId)) return null;
+  const blob = coerceWebBlob(loadBlob(WEB_OUTPUT_SUBDIR, cacheId));
+  if (blob === null) return null;
+  _byId.set(cacheId, blob.content);
+  if (blob.raw !== null) _rawById.set(cacheId, blob.raw);
+  if (blob.url !== null) _urlIndex.set(blob.url, cacheId);
+  return blob.content;
+}
+function getWebOutputRaw(cacheId) {
+  const cleaned = getWebOutput(cacheId);
+  if (cleaned === null) return null;
+  return _rawById.get(cacheId) ?? cleaned;
+}
+function getWebOutputByUrlFromDisk(url, dedupKey = url) {
+  const cacheId = cacheIdForUrl(dedupKey);
+  const content = getWebOutput(cacheId);
+  if (content === null) return null;
+  return { cacheId, content };
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+  _rawById = /* @__PURE__ */ new Map();
+  _urlIndex = /* @__PURE__ */ new Map();
+});
+
+// src/stdin_json.ts
+init_define_import_meta_env();
+var DEFAULT_STDIN_TIMEOUT_MS = 5e3;
+var MAX_STDIN_WALL_MS = 6e4;
+var MAX_STDIN_BYTES = 64 * 1024 * 1024;
+function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS, maxBytes = MAX_STDIN_BYTES) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let totalBytes = 0;
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(idleTimer);
+      clearTimeout(wallTimer);
+      process.stdin.removeListener("data", onData);
+      process.stdin.removeListener("end", onEnd);
+      process.stdin.removeListener("error", onError);
+      fn();
+    };
+    let idleTimer = setTimeout(() => {
+      finish(() => reject(new Error("readStdinJson: timed out waiting for stdin")));
+    }, timeoutMs);
+    const wallTimer = setTimeout(() => {
+      finish(() => {
+        process.stdin.destroy();
+        reject(new Error(`readStdinJson: stdin took longer than ${MAX_STDIN_WALL_MS} ms`));
+      });
+    }, MAX_STDIN_WALL_MS);
+    const onData = (chunk) => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        finish(() => reject(new Error("readStdinJson: timed out waiting for stdin")));
+      }, timeoutMs);
+      totalBytes += chunk.length;
+      if (totalBytes > maxBytes) {
+        finish(() => {
+          process.stdin.destroy();
+          reject(new Error(`readStdinJson: stdin exceeded ${maxBytes} bytes`));
+        });
+        return;
+      }
+      chunks.push(chunk);
+    };
+    const onEnd = () => {
+      finish(() => {
+        const text = Buffer.concat(chunks).toString("utf8").trim();
+        if (text === "") {
+          reject(new Error("readStdinJson: empty stdin"));
+          return;
+        }
+        try {
+          resolve2(JSON.parse(text));
+        } catch (err) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+    };
+    const onError = (err) => {
+      finish(() => reject(err instanceof Error ? err : new Error(String(err))));
+    };
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+    process.stdin.on("error", onError);
+  });
+}
+
+// src/session_store_schema.ts
+init_define_import_meta_env();
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+var SESSION_STORE_TABLES = [
+  {
+    name: "sessions",
+    kind: "view",
+    source: "both",
+    description: "Session metadata and discovery across projects and agents",
+    keyFields: ["id", "task_id", "cwd", "repository", "branch", "summary", "agent_name", "agent_description", "created_at", "updated_at"],
+    columns: [
+      { name: "id", type: "TEXT", description: "Session UUID (matches .../sessions/<id>)", primaryKey: true, notNull: true },
+      { name: "task_id", type: "TEXT", description: "Task UUID from .../tasks/<id> URL (cloud only)" },
+      { name: "cwd", type: "TEXT", description: "Working directory path where session started" },
+      { name: "repository", type: "TEXT", description: "Repository name or owner/repo slug" },
+      { name: "branch", type: "TEXT", description: "Active git branch name" },
+      { name: "summary", type: "TEXT", description: "Concise summary of session conversation" },
+      { name: "agent_name", type: "TEXT", description: "Exact agent name, e.g. 'Copilot CLI', 'Copilot Coding Agent' (cloud only)" },
+      { name: "agent_description", type: "TEXT", description: "Agent description or specialty (cloud only)" },
+      { name: "created_at", type: "TIMESTAMP", description: "Session start timestamp (UTC)" },
+      { name: "updated_at", type: "TIMESTAMP", description: "Session last active timestamp (UTC)" },
+      { name: "host_type", type: "TEXT", description: "Host environment type (local source only)" }
+    ],
+    notes: [
+      'In local mode (source: "local"), sessions only contains: id, cwd, repository, host_type, branch, summary, created_at, updated_at (no task_id or agent_*).',
+      'Filter exact agent_name values such as "Copilot Code Review", "Copilot Coding Agent", or "Copilot CLI", not summary text.',
+      "Always use LIMIT and filter by repository or time (created_at >= now() - INTERVAL '7 days')."
+    ],
+    commonMisnomers: {
+      title: 'summary (sessions has no "title" column; checkpoints has "title")',
+      role: 'agent_name or agent_description (sessions has no "role" column)',
+      name: "agent_name (for agent identity) or repository (for project name)",
+      user: "user_message in turns table",
+      prompt: "user_message in turns table"
+    }
+  },
+  {
+    name: "turns",
+    kind: "view",
+    source: "both",
+    description: "Conversation messages grouped into user and assistant turns",
+    keyFields: ["session_id", "turn_index", "user_message", "assistant_response", "timestamp"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "turn_index", type: "INTEGER", description: "0-based turn index in conversation", notNull: true },
+      { name: "user_message", type: "TEXT", description: "User input / prompt message" },
+      { name: "assistant_response", type: "TEXT", description: "Assistant generated response" },
+      { name: "timestamp", type: "TIMESTAMP", description: "Turn execution timestamp" }
+    ],
+    notes: [
+      "Never ILIKE-scan turns without narrow time or session_id filters; turns table can exceed 50,000+ rows."
+    ],
+    commonMisnomers: {
+      prompt: "user_message",
+      response: "assistant_response",
+      content: "user_message or assistant_response",
+      text: "user_message or assistant_response"
+    }
+  },
+  {
+    name: "checkpoints",
+    kind: "view",
+    source: "both",
+    description: "Handoff and checkpoint summaries created during sessions",
+    keyFields: ["session_id", "checkpoint_number", "title", "overview", "created_at"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "checkpoint_number", type: "INTEGER", description: "Sequential checkpoint number (1-based)" },
+      { name: "title", type: "TEXT", description: "Checkpoint short title" },
+      { name: "overview", type: "TEXT", description: "Checkpoint narrative markdown summary" },
+      { name: "created_at", type: "TIMESTAMP", description: "Checkpoint creation timestamp" }
+    ],
+    commonMisnomers: {
+      summary: "overview or title",
+      description: "overview",
+      notes: "overview"
+    }
+  },
+  {
+    name: "session_files",
+    kind: "view",
+    source: "both",
+    description: "Files touched, created, or modified during sessions",
+    keyFields: ["session_id", "file_path", "tool_name", "turn_index", "first_seen_at"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "file_path", type: "TEXT", description: "Workspace or absolute file path", notNull: true },
+      { name: "tool_name", type: "TEXT", description: "Tool used to touch file (edit, create, apply_patch)" },
+      { name: "turn_index", type: "INTEGER", description: "Turn index where file was modified" },
+      { name: "first_seen_at", type: "TIMESTAMP", description: "Timestamp file was first modified in session" }
+    ],
+    commonMisnomers: {
+      path: "file_path",
+      filename: "file_path",
+      name: "file_path"
+    }
+  },
+  {
+    name: "session_refs",
+    kind: "view",
+    source: "both",
+    description: "Commit, pull request, and issue references linked to sessions",
+    keyFields: ["session_id", "ref_type", "ref_value", "turn_index", "created_at"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "ref_type", type: "TEXT", description: "Reference type ('commit', 'pr', or 'issue')" },
+      { name: "ref_value", type: "TEXT", description: "Reference value (e.g. git SHA, PR number, or issue number)" },
+      { name: "turn_index", type: "INTEGER", description: "Turn index where reference appeared" },
+      { name: "created_at", type: "TIMESTAMP", description: "Reference creation timestamp" }
+    ],
+    notes: [
+      "Prefer session_refs exact matches for PR/issue lookups over text-scanning turns."
+    ],
+    commonMisnomers: {
+      type: "ref_type",
+      value: "ref_value",
+      ref: "ref_value"
+    }
+  },
+  {
+    name: "session_usage",
+    kind: "view",
+    source: "cloud",
+    description: "Model and token usage aggregated per session and model (cloud only)",
+    keyFields: ["session_id", "usage_model", "api_call_count", "input_tokens", "output_tokens", "cost", "duration", "first_used_at", "last_used_at"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "usage_model", type: "TEXT", description: "LLM model identifier used" },
+      { name: "api_call_count", type: "INTEGER", description: "Total API calls issued to model" },
+      { name: "input_tokens", type: "INTEGER", description: "Total prompt/input tokens" },
+      { name: "output_tokens", type: "INTEGER", description: "Total generated/output tokens" },
+      { name: "cache_read_tokens", type: "INTEGER", description: "Prompt tokens read from cache" },
+      { name: "cache_write_tokens", type: "INTEGER", description: "Prompt tokens written to cache" },
+      { name: "cost", type: "DOUBLE", description: "Sum of model billing multipliers" },
+      { name: "duration", type: "BIGINT", description: "Total duration in milliseconds" },
+      { name: "first_used_at", type: "TIMESTAMP", description: "First usage timestamp" },
+      { name: "last_used_at", type: "TIMESTAMP", description: "Last usage timestamp" }
+    ],
+    notes: [
+      "Filtering last_used_at selects session/model rows whose latest usage falls in the period; rows remain whole-session aggregates."
+    ],
+    commonMisnomers: {
+      model: "usage_model",
+      tokens: "input_tokens or output_tokens"
+    }
+  },
+  {
+    name: "tool_executions",
+    kind: "view",
+    source: "cloud",
+    description: "Completed tool calls and outcomes (cloud only)",
+    keyFields: ["session_id", "tool_call_id", "tool_name", "started_at", "completed_at", "duration_ms", "success", "error_code"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "tool_call_id", type: "TEXT", description: "Unique tool invocation identifier" },
+      { name: "tool_name", type: "TEXT", description: "Tool name executed" },
+      { name: "started_at", type: "TIMESTAMP", description: "Tool start timestamp" },
+      { name: "completed_at", type: "TIMESTAMP", description: "Tool completion timestamp" },
+      { name: "duration_ms", type: "BIGINT", description: "Execution duration in milliseconds" },
+      { name: "success", type: "BOOLEAN", description: "True if tool succeeded, false on error" },
+      { name: "error_code", type: "TEXT", description: "Error code or category on failure" }
+    ],
+    notes: [
+      "To exclude invalid negative durations, filter completed_at >= started_at."
+    ],
+    commonMisnomers: {
+      name: "tool_name",
+      duration: "duration_ms",
+      status: "success (boolean)"
+    }
+  },
+  {
+    name: "tool_requests",
+    kind: "table",
+    source: "cloud",
+    description: "Raw tool request arguments in JSON format (cloud fallback table)",
+    keyFields: ["session_id", "tool_call_id", "name", "arguments_json"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "tool_call_id", type: "TEXT", description: "Tool call identifier" },
+      { name: "name", type: "TEXT", description: "Tool name requested" },
+      { name: "arguments_json", type: "TEXT", description: "Raw JSON arguments payload" }
+    ]
+  },
+  {
+    name: "attachments",
+    kind: "table",
+    source: "cloud",
+    description: "Attachments submitted with user messages (cloud fallback table)",
+    keyFields: ["session_id", "display_name", "path", "type"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "display_name", type: "TEXT", description: "Display name or label" },
+      { name: "path", type: "TEXT", description: "Path to attachment" },
+      { name: "type", type: "TEXT", description: "MIME type or category" }
+    ]
+  },
+  {
+    name: "events",
+    kind: "table",
+    source: "cloud",
+    description: "Underlying raw event stream (~90 columns, large table - filter by session_id and timestamp)",
+    keyFields: ["session_id", "timestamp", "type", "agent_name", "agent_description", "user_content", "assistant_content"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Foreign key to sessions.id", notNull: true },
+      { name: "timestamp", type: "TIMESTAMP", description: "Event timestamp" },
+      { name: "type", type: "TEXT", description: "Event type ('user.message', 'assistant.message', 'tool.execution_complete')" },
+      { name: "agent_name", type: "TEXT", description: "Agent identifier" },
+      { name: "agent_description", type: "TEXT", description: "Agent description" },
+      { name: "user_content", type: "TEXT", description: "User message text" },
+      { name: "assistant_content", type: "TEXT", description: "Assistant message text" },
+      { name: "tool_start_name", type: "TEXT", description: "Tool name at invocation" },
+      { name: "tool_complete_call_id", type: "TEXT", description: "Tool call ID on completion" },
+      { name: "tool_complete_success", type: "BOOLEAN", description: "Success status flag" },
+      { name: "tool_complete_result_content", type: "TEXT", description: "Tool execution result text" },
+      { name: "usage_model", type: "TEXT", description: "Model name" },
+      { name: "usage_input_tokens", type: "INTEGER", description: "Input token count" },
+      { name: "usage_output_tokens", type: "INTEGER", description: "Output token count" }
+    ]
+  },
+  {
+    name: "todos",
+    kind: "session_db",
+    source: "session",
+    description: "Active session SQLite workflow todos (managed via sql tool in session database)",
+    keyFields: ["id", "title", "description", "status", "created_at", "updated_at"],
+    columns: [
+      { name: "id", type: "TEXT", description: "Unique kebab-case todo identifier", primaryKey: true, notNull: true },
+      { name: "title", type: "TEXT", description: 'Gerund action title (e.g. "Creating auth module")', notNull: true },
+      { name: "description", type: "TEXT", description: "Self-contained task description" },
+      { name: "status", type: "TEXT", description: "'pending', 'in_progress', 'done', or 'blocked'", notNull: true },
+      { name: "created_at", type: "TIMESTAMP", description: "Creation timestamp" },
+      { name: "updated_at", type: "TIMESTAMP", description: "Last update timestamp" }
+    ],
+    commonMisnomers: {
+      name: "title or id",
+      task: "title or description",
+      state: "status"
+    }
+  },
+  {
+    name: "todo_deps",
+    kind: "session_db",
+    source: "session",
+    description: "Active session SQLite todo dependencies (managed via sql tool in session database)",
+    keyFields: ["todo_id", "depends_on"],
+    columns: [
+      { name: "todo_id", type: "TEXT", description: "Todo identifier that has a dependency", notNull: true },
+      { name: "depends_on", type: "TEXT", description: "Todo identifier that must be done first", notNull: true }
+    ],
+    commonMisnomers: {
+      parent: "depends_on",
+      child: "todo_id"
+    }
+  },
+  {
+    name: "assistant_usage_events",
+    kind: "table",
+    source: "local",
+    description: 'Local SQLite assistant usage events (source: "local" only)',
+    keyFields: ["session_id", "timestamp", "model", "input_tokens", "output_tokens"],
+    columns: [
+      { name: "session_id", type: "TEXT", description: "Session UUID" },
+      { name: "timestamp", type: "TEXT", description: "Timestamp string" },
+      { name: "model", type: "TEXT", description: "Model identifier" },
+      { name: "input_tokens", type: "INTEGER", description: "Input token count" },
+      { name: "output_tokens", type: "INTEGER", description: "Output token count" }
+    ]
+  },
+  {
+    name: "search_index",
+    kind: "table",
+    source: "local",
+    description: 'Local SQLite FTS5 search index table for MATCH queries (source: "local" only)',
+    keyFields: ["search_index"],
+    columns: [
+      { name: "search_index", type: "FTS5", description: "Full-text indexed search virtual table" }
+    ]
+  }
+];
+function getSessionStoreTable(name) {
+  const norm = name.trim().toLowerCase();
+  return SESSION_STORE_TABLES.find((t) => t.name.toLowerCase() === norm);
+}
+function formatSessionStoreCatalog(opts) {
+  if (opts?.json === true) {
+    return displaySafeJson(SESSION_STORE_TABLES);
+  }
+  const lines = [
+    "# Session Store & Workflow Database Schema Catalog",
+    "",
+    "Available tables and materialized views for `session_store_sql` (DuckDB/SQLite) and `sql` (session SQLite):",
+    ""
+  ];
+  for (const table of SESSION_STORE_TABLES) {
+    const kindTag = table.kind === "session_db" ? "[session sql]" : `[${table.source}]`;
+    const cols = table.columns.map((c) => c.name).join(", ");
+    lines.push(`\u2022 **${table.name}** ${kindTag} \u2014 ${table.description}`);
+    lines.push(`  Columns: ${cols}`);
+    lines.push("");
+  }
+  lines.push("Run `token-goat session-schema <table>` or `token-goat describe <table>` for detailed column specifications.");
+  return lines.join("\n");
+}
+function formatSessionStoreTable(table, opts) {
+  if (opts?.json === true) {
+    return displaySafeJson(table);
+  }
+  const lines = [
+    `# Schema: ${table.name} (${table.kind}, source: ${table.source})`,
+    "",
+    table.description,
+    "",
+    "## Columns",
+    "",
+    "| Column | Type | Description |",
+    "| :--- | :--- | :--- |"
+  ];
+  for (const col of table.columns) {
+    const pk = col.primaryKey === true ? " *(PK)*" : "";
+    const req = col.notNull === true ? " *(not null)*" : "";
+    lines.push(`| \`${col.name}\`${pk}${req} | \`${col.type}\` | ${col.description} |`);
+  }
+  if (table.notes && table.notes.length > 0) {
+    lines.push("", "## Important Notes", "");
+    for (const note of table.notes) {
+      lines.push(`- ${note}`);
+    }
+  }
+  if (table.commonMisnomers && Object.keys(table.commonMisnomers).length > 0) {
+    lines.push("", "## Common Column Misnomers & Pitfalls", "");
+    for (const [bad, good] of Object.entries(table.commonMisnomers)) {
+      lines.push(`- Don't use \`${bad}\` \u2192 use \`${good}\``);
+    }
+  }
+  return lines.join("\n");
+}
+async function describeTarget(target, table, opts) {
+  if (!target || target === "all" || target === "session_store_sql") {
+    return { exitCode: 0, text: formatSessionStoreCatalog(opts) };
+  }
+  const sessionTable = getSessionStoreTable(target);
+  if (sessionTable) {
+    return { exitCode: 0, text: formatSessionStoreTable(sessionTable, opts) };
+  }
+  const absPath = resolve(process.cwd(), target);
+  if (existsSync(absPath)) {
+    try {
+      const { isSqliteFile, getSqliteSchema, formatSqliteSchema } = await import("./token-goat-chunk-4EXFN2AW.mjs");
+      if (isSqliteFile(absPath)) {
+        const schema = getSqliteSchema(absPath);
+        if (table) {
+          const found = schema.tables.find((t) => t.name.toLowerCase() === table.toLowerCase());
+          if (!found) {
+            const avail2 = schema.tables.map((t) => t.name).join(", ");
+            return { exitCode: 1, text: `Table '${table}' not found in SQLite database ${target}. Available tables: ${avail2}` };
+          }
+          if (opts?.json === true) {
+            return { exitCode: 0, text: displaySafeJson(found) };
+          }
+          const lines = [
+            `# SQLite Table: ${found.name} (${found.kind}) in ${target}`,
+            `Row Count: ${found.rowCount ?? "unknown"}`,
+            "",
+            "| Column | Type | Nullable | Default | PK |",
+            "| :--- | :--- | :--- | :--- | :--- |"
+          ];
+          for (const col of found.columns) {
+            lines.push(`| \`${col.name}\` | \`${col.type}\` | ${col.notNull ? "NO" : "YES"} | ${col.defaultValue ?? "NULL"} | ${col.primaryKey ? "YES" : "NO"} |`);
+          }
+          return { exitCode: 0, text: lines.join("\n") };
+        }
+        if (opts?.json === true) {
+          return { exitCode: 0, text: displaySafeJson(schema) };
+        }
+        return { exitCode: 0, text: formatSqliteSchema(schema) };
+      }
+    } catch (err) {
+      return { exitCode: 1, text: `Error reading SQLite database ${target}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+  }
+  const avail = SESSION_STORE_TABLES.map((t) => t.name).join(", ");
+  return {
+    exitCode: 1,
+    text: `Unknown table or SQLite file '${target}'. Available session store tables: ${avail}
+Run 'token-goat session-schema' to see all tables.`
+  };
+}
+function diagnoseSqlFailure(event, errorText) {
+  const toolName = (getToolName(event) || "").toLowerCase();
+  const isSqlTool = toolName === "session_store_sql" || toolName === "sql" || toolName === "sqlite_query" || toolName === "sqlite-query" || /sql/i.test(toolName);
+  const isColumnError = /referenced column\s*["']?([^"'\s]+)["']?\s*not found/i.test(errorText) || /no such column:\s*([^\s,;]+)/i.test(errorText) || /column\s*["']?([^"'\s]+)["']?\s*(?:does not exist|not found)/i.test(errorText) || /has no column named\s*([^\s,;]+)/i.test(errorText);
+  const isTableError = /table\s*["']?([^"'\s]+)["']?\s*(?:does not exist|not found)/i.test(errorText) || /no such table:\s*([^\s,;]+)/i.test(errorText);
+  if (!isColumnError && !isTableError && !isSqlTool) {
+    return null;
+  }
+  const query = typeof event.toolInput["query"] === "string" ? event.toolInput["query"] : typeof event.toolInput["sql"] === "string" ? event.toolInput["sql"] : "";
+  let matchedTable;
+  if (query) {
+    const fromMatch = query.match(/(?:from|join)\s+([a-zA-Z0-9_]+)/i);
+    if (fromMatch && fromMatch[1]) {
+      matchedTable = getSessionStoreTable(fromMatch[1]);
+    }
+  }
+  let badCol;
+  const colMatch = errorText.match(/referenced column\s*["']?([^"'\s]+)["']?\s*not found/i) ?? errorText.match(/no such column:\s*([^\s,;]+)/i) ?? errorText.match(/column\s*["']?([^"'\s]+)["']?\s*(?:does not exist|not found)/i) ?? errorText.match(/has no column named\s*([^\s,;]+)/i);
+  const matchedColName = colMatch?.[1];
+  if (matchedColName) {
+    const raw = matchedColName.trim();
+    if (!raw.startsWith("$") && !raw.includes("{")) {
+      badCol = raw.replace(/^[a-zA-Z0-9_]+\./, "").toLowerCase();
+    }
+  }
+  if (matchedTable) {
+    const validCols = matchedTable.columns.map((c) => c.name).join(", ");
+    let advice = `[token-goat] Table '${matchedTable.name}' has columns: ${validCols}.`;
+    if (badCol && matchedTable.commonMisnomers && matchedTable.commonMisnomers[badCol]) {
+      advice += ` (For '${badCol}', use ${matchedTable.commonMisnomers[badCol]}).`;
+    } else if (badCol) {
+      advice += ` (Column '${badCol}' does not exist on '${matchedTable.name}').`;
+    }
+    advice += ` Run 'token-goat session-schema ${matchedTable.name}' to inspect full table structure.`;
+    return advice;
+  }
+  if (isTableError) {
+    const tableMatch = errorText.match(/table\s*["']?([^"'\s]+)["']?\s*(?:does not exist|not found)/i) ?? errorText.match(/no such table:\s*([^\s,;]+)/i);
+    const badTable = tableMatch ? tableMatch[1] : void 0;
+    if (badTable && (badTable.startsWith("$") || badTable.includes("{"))) {
+      return null;
+    }
+    const knownTables = SESSION_STORE_TABLES.map((t) => t.name).join(", ");
+    return `[token-goat] ${badTable ? `Table '${badTable}' does not exist.` : "Table not found."} Available session store tables: ${knownTables}. Run 'token-goat session-schema' for schema details.`;
+  }
+  return null;
+}
+function runSessionSchema(opts) {
+  if (!opts.table) {
+    process.stdout.write(formatSessionStoreCatalog({ json: opts.json }) + "\n");
+    return 0;
+  }
+  const found = getSessionStoreTable(opts.table);
+  if (!found) {
+    const avail = SESSION_STORE_TABLES.map((t) => t.name).join(", ");
+    process.stderr.write(`Unknown session store table '${opts.table}'. Available tables: ${avail}
+Run 'token-goat session-schema' to see all tables.
+`);
+    return 1;
+  }
+  process.stdout.write(formatSessionStoreTable(found, { json: opts.json }) + "\n");
+  return 0;
+}
+async function runDescribe(opts) {
+  const result = await describeTarget(opts.target, opts.table, { json: opts.json });
+  if (result.exitCode !== 0) {
+    process.stderr.write(result.text + "\n");
+  } else {
+    process.stdout.write(result.text + "\n");
+  }
+  return result.exitCode;
+}
+function cmdSessionSchema(table, opts) {
+  process.exitCode = runSessionSchema({ table, json: opts?.json });
+}
+async function cmdDescribe(target, table, opts) {
+  process.exitCode = await runDescribe({ target, table, json: opts?.json });
+}
+
+// src/types.ts
+init_define_import_meta_env();
+var HOOK_EVENTS = [
+  "pre_tool_use",
+  "post_tool_use",
+  "notification",
+  "stop",
+  "pre_compact",
+  "post_compact",
+  "user_prompt_submit",
+  "subagent_stop",
+  "session_start",
+  "post_tool_use_failure"
+];
+
+// src/cli_commands.ts
+init_define_import_meta_env();
+function toEntry(cmd) {
+  return {
+    name: cmd.name(),
+    description: cmd.description(),
+    aliases: cmd.aliases(),
+    options: cmd.options.map((o) => ({ flags: o.flags, description: o.description })),
+    arguments: cmd.registeredArguments.map((a) => ({ name: a.name(), description: a.description, required: a.required })),
+    subcommands: cmd.commands.filter((sub) => sub.name() !== "help").map(toEntry)
+  };
+}
+function buildCommandManifest(program) {
+  return program.commands.filter((cmd) => cmd.name() !== "help").map(toEntry);
+}
+function flattenCommandNames(manifest) {
+  const names = [];
+  for (const entry of manifest) {
+    names.push(entry.name);
+    for (const sub of entry.subcommands) {
+      names.push(`${entry.name} ${sub.name}`);
+    }
+  }
+  return names;
+}
+function entryMatches(entry, re, pattern) {
+  const haystacks = [entry.name, entry.description, ...entry.aliases];
+  return haystacks.some((h) => re !== null ? re.test(h) : h.includes(pattern));
+}
+function filterCommandManifest(manifest, pattern) {
+  const guarded = compileGuardedRegex(pattern);
+  const re = guarded.ok ? guarded.re : null;
+  const result = [];
+  for (const entry of manifest) {
+    if (entryMatches(entry, re, pattern)) {
+      result.push(entry);
+      continue;
+    }
+    const matchingSubs = entry.subcommands.filter((sub) => entryMatches(sub, re, pattern));
+    if (matchingSubs.length > 0) {
+      result.push({ ...entry, subcommands: matchingSubs });
+    }
+  }
+  return result;
+}
+function formatCommandManifest(manifest) {
+  const lines = [];
+  lines.push("# token-goat commands");
+  lines.push("");
+  for (const entry of manifest) {
+    lines.push(`## ${entry.name}${entry.aliases.length ? " (alias: " + entry.aliases.join(", ") + ")" : ""}${entry.description ? " -- " + entry.description : ""}`);
+    for (const arg of entry.arguments) {
+      lines.push(`  arg: ${arg.name}${arg.required ? "" : " (optional)"}${arg.description ? " -- " + arg.description : ""}`);
+    }
+    for (const opt of entry.options) {
+      lines.push(`  ${opt.flags}${opt.description ? " -- " + opt.description : ""}`);
+    }
+    for (const sub of entry.subcommands) {
+      lines.push(`  ${entry.name} ${sub.name}${sub.description ? " -- " + sub.description : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+// src/symbol_body_probe.ts
+init_define_import_meta_env();
+import * as fs from "fs";
+var OVERSIZED_BODY_PROBE_SQL = `SELECT 1 FROM symbols WHERE LENGTH(body) > ${SYMBOL_BODY_CHAR_CAP} LIMIT 1`;
+function checkSymbolBodySize(dbPath) {
+  if (!fs.existsSync(dbPath)) {
+    return { name: "Symbol body size", status: "ok", message: "no database yet" };
+  }
+  try {
+    const db = getDb(dbPath);
+    const row = db.prepare(OVERSIZED_BODY_PROBE_SQL).get();
+    if (row !== void 0) {
+      return {
+        name: "Symbol body size",
+        status: "warn",
+        message: `one or more stored symbol bodies exceed the ${SYMBOL_BODY_CHAR_CAP}-char cap enforced by boundSymbolBody -- likely a pre-fix leftover from a minified/generated file. A plain 'token-goat reclaim-index' (VACUUM only) CANNOT remove these rows -- it only reclaims freed pages, it never deletes row content. Only 'token-goat reclaim-index --rebuild' drops and re-derives them under the cap (stop the worker first with 'token-goat worker stop', since reclaim-index refuses to run while it's live); --rebuild reparses and re-embeds every indexed file across every project and can take a long time on a large multi-project index`
+      };
+    }
+    return { name: "Symbol body size", status: "ok", message: "no stored symbol body exceeds the cap" };
+  } catch (err) {
+    return {
+      name: "Symbol body size",
+      status: "warn",
+      message: `could not query symbol body size: ${extractErrorMessage(err)}`
+    };
+  }
+}
+
+// src/reconcile.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+var DEFAULT_RECONCILE_BUDGET_MS = 1500;
+function readReconcileCursor(dbPath, root) {
+  try {
+    const row = getDb(dbPath).prepare("SELECT last_scanned_path FROM reconcile_cursor WHERE root = ?").get(root);
+    return row?.last_scanned_path ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeReconcileCursor(dbPath, root, lastScannedPath) {
+  try {
+    getDb(dbPath).prepare(
+      "INSERT INTO reconcile_cursor (root, last_scanned_path, updated_at) VALUES (?, ?, ?) ON CONFLICT(root) DO UPDATE SET last_scanned_path = excluded.last_scanned_path, updated_at = excluded.updated_at"
+    ).run(root, lastScannedPath, Date.now());
+  } catch {
+  }
+}
+function clearReconcileCursor(dbPath, root) {
+  try {
+    getDb(dbPath).prepare("DELETE FROM reconcile_cursor WHERE root = ?").run(root);
+  } catch {
+  }
+}
+function runReconcile(opts = {}) {
+  const raw = reconcileProject(opts);
+  const root = getDisplayRoot(opts.cwd ?? process.cwd());
+  const display = (paths) => paths.map((p) => toDisplayPath(root, p)).sort();
+  const result = {
+    ...raw,
+    changed: display(raw.changed),
+    added: display(raw.added),
+    removed: display(raw.removed)
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${displaySafeJson(result)}
+`);
+    return 0;
+  }
+  const lines = [];
+  if (isReconcileClean(result)) {
+    if (!result.trackedUnavailable) {
+      lines.push(`Index matches disk: ${countNoun(result.scanned, "file")} checked in ${result.elapsedMs}ms.`);
+    }
+  } else {
+    const verb = opts.dryRun === true ? "would reindex" : "queued for reindexing";
+    const dropVerb = opts.dryRun === true ? "would drop from the index" : "queued for removal";
+    if (result.changed.length > 0) lines.push(`${countNoun(result.changed.length, "file")} changed since indexing (${verb}):`);
+    for (const f of result.changed) lines.push(`  ~ ${f}`);
+    if (result.added.length > 0) lines.push(`${countNoun(result.added.length, "file")} not in the index (${verb}):`);
+    for (const f of result.added) lines.push(`  + ${f}`);
+    if (result.removed.length > 0) lines.push(`${countNoun(result.removed.length, "file")} indexed but gone from disk (${dropVerb}):`);
+    for (const f of result.removed) lines.push(`  - ${f}`);
+    lines.push(`Checked ${countNoun(result.scanned, "file")} in ${result.elapsedMs}ms.`);
+  }
+  if (result.mtimeOnly > 0) {
+    lines.push(`${countNoun(result.mtimeOnly, "file")} had a newer timestamp but identical content, so ${result.mtimeOnly === 1 ? "it was" : "they were"} left alone.`);
+  }
+  if (result.parserStale > 0) {
+    const reparseVerb = opts.dryRun === true ? "would reparse" : "queued for reparse";
+    lines.push(`${countNoun(result.parserStale, "file")} of the above ${result.parserStale === 1 ? "was" : "were"} unchanged on disk but indexed by an older parser (${reparseVerb}).`);
+  }
+  if (result.trackedUnavailable) {
+    lines.push("This project has an index but git listed no files in it, so nothing could be compared and no deletions were computed. Run token-goat inside the repository, or reindex with --walk if this directory is deliberately not under git.");
+  }
+  if (result.budgetExhausted) {
+    lines.push(`Stopped at the ${result.elapsedMs}ms budget with ${countNoun(result.unscanned, "file")} unchecked, so there may be more drift; deletions were not computed at all, because an unchecked file is indistinguishable from a deleted one. Raise --budget-ms for a complete sweep.`);
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+function isReconcileClean(r) {
+  return r.changed.length === 0 && r.added.length === 0 && r.removed.length === 0;
+}
+function reconcileProject(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const budgetMs = opts.budgetMs ?? DEFAULT_RECONCILE_BUDGET_MS;
+  const startedAt = Date.now();
+  const dbPath = opts.dbPath ?? globalDbPath();
+  const tracked = getTrackedFiles(cwd);
+  const projectRoot = resolveIndexPath(".", cwd);
+  const indexed = getProjectFileEntries(projectRoot, dbPath);
+  let scanOrder = tracked;
+  const cursorPath = tracked.length > 0 ? readReconcileCursor(dbPath, projectRoot) : null;
+  if (cursorPath !== null) {
+    const cursorFolded = foldPath(normalizePath(cursorPath));
+    const cursorIdx = tracked.findIndex((f) => foldPath(normalizePath(f)) === cursorFolded);
+    if (cursorIdx !== -1) {
+      scanOrder = [...tracked.slice(cursorIdx + 1), ...tracked.slice(0, cursorIdx + 1)];
+    }
+  }
+  const changed = [];
+  const added = [];
+  const seenOnDisk = /* @__PURE__ */ new Set();
+  let mtimeOnly = 0;
+  let parserStale = 0;
+  let scanned = 0;
+  let budgetExhausted = false;
+  let lastScanned = null;
+  for (const file of scanOrder) {
+    if (Date.now() - startedAt > budgetMs) {
+      budgetExhausted = true;
+      break;
+    }
+    scanned++;
+    lastScanned = file;
+    const folded = foldPath(normalizePath(file));
+    seenOnDisk.add(folded);
+    const entry = indexed.get(folded);
+    if (entry === void 0) {
+      added.push(file);
+      continue;
+    }
+    if (entry.parserSha !== PARSER_FINGERPRINT) {
+      changed.push(file);
+      parserStale++;
+      continue;
+    }
+    let mtimeMs;
+    try {
+      mtimeMs = fs2.statSync(file).mtimeMs;
+    } catch {
+      changed.push(file);
+      continue;
+    }
+    if (entry.mtime !== 0 && mtimeMs === entry.mtime) continue;
+    const diskSha = fingerprintFile(file);
+    if (diskSha === null) {
+      changed.push(file);
+      continue;
+    }
+    if (diskSha === entry.sha) {
+      mtimeOnly++;
+      continue;
+    }
+    changed.push(file);
+  }
+  const trackedUnavailable = tracked.length === 0 && indexed.size > 0;
+  const removed = [];
+  if (!budgetExhausted && !trackedUnavailable) {
+    for (const [folded, entry] of indexed) {
+      if (seenOnDisk.has(folded)) continue;
+      if (Date.now() - startedAt > budgetMs) {
+        budgetExhausted = true;
+        removed.length = 0;
+        break;
+      }
+      try {
+        fs2.statSync(entry.filePath);
+      } catch {
+        removed.push(entry.filePath);
+      }
+    }
+  }
+  let enqueued = 0;
+  if (opts.dryRun !== true) {
+    for (const p of [...changed, ...added, ...removed]) {
+      enqueueDirtyPathSafe(resolveIndexPath(p, cwd), { alreadyResolved: true });
+      enqueued++;
+    }
+    if (budgetExhausted) {
+      if (lastScanned !== null) writeReconcileCursor(dbPath, projectRoot, lastScanned);
+    } else if (tracked.length > 0) {
+      clearReconcileCursor(dbPath, projectRoot);
+    }
+  }
+  return {
+    scanned,
+    changed,
+    added,
+    removed,
+    mtimeOnly,
+    parserStale,
+    budgetExhausted,
+    trackedUnavailable,
+    unscanned: Math.max(0, tracked.length - scanned),
+    enqueued,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+
+export {
+  checkSymbolBodySize,
+  WEB_OUTPUT_SUBDIR,
+  storeWebOutput,
+  getWebOutput,
+  getWebOutputRaw,
+  getWebOutputByUrlFromDisk,
+  DEFAULT_RECONCILE_BUDGET_MS,
+  runReconcile,
+  isReconcileClean,
+  reconcileProject,
+  MAX_STDIN_BYTES,
+  readStdinJson,
+  diagnoseSqlFailure,
+  cmdSessionSchema,
+  cmdDescribe,
+  HOOK_EVENTS,
+  buildCommandManifest,
+  flattenCommandNames,
+  filterCommandManifest,
+  formatCommandManifest
+};