token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,462 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CliError,
+  formatCommandError,
+  formatFailedResultText
+} from "./token-goat-chunk-CBIQ7WTD.mjs";
+import {
+  getToolName
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  echoedValue,
+  fencedCommand,
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  displaySafeJson
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// 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)) {
+    const sqliteResult = await (await import("./token-goat-chunk-OBRFJ5O5.mjs")).describeSqliteFile(target, absPath, table, opts?.json === true);
+    if (sqliteResult !== void 0) return sqliteResult;
+  }
+  const avail = SESSION_STORE_TABLES.map((t) => t.name).join(", ");
+  return {
+    exitCode: 1,
+    text: `Unknown table or SQLite file ${echoedValue(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 ${echoedValue(matchedTable.name)} has columns: ${validCols}.`;
+    if (badCol && matchedTable.commonMisnomers && matchedTable.commonMisnomers[badCol]) {
+      advice += ` (For ${echoedValue(badCol)}, use ${matchedTable.commonMisnomers[badCol]}).`;
+    } else if (badCol) {
+      advice += ` (Column ${echoedValue(badCol)} does not exist on ${echoedValue(matchedTable.name)}).`;
+    }
+    advice += ` Run ${fencedCommand("token-goat session-schema " + quotedArg(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 ${echoedValue(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(formatCommandError(new CliError([`Unknown session store table ${echoedValue(opts.table)}. Available tables: ${avail}`, "Run `token-goat session-schema` to see all tables."])) + "\n");
+    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(formatFailedResultText(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 });
+}
+
+export {
+  diagnoseSqlFailure,
+  cmdSessionSchema,
+  cmdDescribe
+};

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

@@ -0,0 +1,111 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/stdin_json.ts
+init_define_import_meta_env();
+var DEFAULT_STDIN_TIMEOUT_MS = 5e3;
+var FIRST_BYTE_GRACE_FACTOR = 4;
+var IDLE_CONFIRM_MS = 50;
+var MAX_STDIN_WALL_MS = 6e4;
+var MAX_STDIN_BYTES = 64 * 1024 * 1024;
+function completeDocument(chunks) {
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return void 0;
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null ? { value } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS, maxBytes = MAX_STDIN_BYTES, firstByteGraceFactor = FIRST_BYTE_GRACE_FACTOR) {
+  return new Promise((resolve, 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();
+    };
+    const confirmSilence = (confirmMs) => {
+      const seen = totalBytes;
+      const armedAt = performance.now();
+      idleTimer = setTimeout(() => {
+        setImmediate(() => {
+          if (totalBytes !== seen) return;
+          if (performance.now() - armedAt > confirmMs * 2) {
+            confirmSilence(confirmMs);
+            return;
+          }
+          finish(() => {
+            const done = completeDocument(chunks);
+            if (done !== void 0) resolve(done.value);
+            else reject(new Error("readStdinJson: timed out waiting for stdin"));
+          });
+        });
+      }, confirmMs);
+    };
+    const armIdle = (ms = timeoutMs) => {
+      const confirmMs = Math.min(IDLE_CONFIRM_MS, Math.floor(ms / 2));
+      return setTimeout(() => confirmSilence(confirmMs), ms - confirmMs);
+    };
+    let idleTimer = armIdle(timeoutMs * firstByteGraceFactor);
+    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 = armIdle();
+      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 {
+          resolve(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/mcp_tool_pattern.ts
+init_define_import_meta_env();
+var MCP_TOOL_PATTERN = "^mcp__";
+
+export {
+  readStdinJson,
+  MCP_TOOL_PATTERN
+};

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

@@ -0,0 +1,40 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  evaluateVerification,
+  exitStatusIsCheckVerdict,
+  isVerificationCommand,
+  noteFailedVerificationRun,
+  noteVerificationRun
+} from "./token-goat-chunk-2WLPWKHV.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import "./token-goat-chunk-KQBLRPBN.mjs";
+import "./token-goat-chunk-4ZBFWLXF.mjs";
+import "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-4GILLLWY.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  evaluateVerification,
+  exitStatusIsCheckVerdict,
+  isVerificationCommand,
+  noteFailedVerificationRun,
+  noteVerificationRun
+};