@wrongstack/core 0.309.0 → 0.310.0

package/dist/kernel/events/tool-events.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../../core/context.js';
+import type { AgentContext } from '../../types/context.js';
 import type { ToolOutputMetadata } from '../../types/context-evidence.js';
 import type { PermissionDecision } from '../../types/permission.js';
 import type { RiskTier, Tool, ToolErrorCategory, ToolProgressEvent } from '../../types/tool.js';
@@ -6,6 +6,8 @@ export interface ToolEventMap {
     'tool.started': {
         sessionId?: string | undefined;
         traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
         agentId?: string | undefined;
         agentName?: string | undefined;
         name: string;
@@ -29,6 +31,8 @@ export interface ToolEventMap {
         id: string;
         sessionId: string;
         traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
         agentId: string;
         durationMs: number;
         outputChars: number;
@@ -41,6 +45,8 @@ export interface ToolEventMap {
         id: string;
         sessionId: string;
         traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
         agentId: string;
         durationMs: number;
         category: ToolErrorCategory;
@@ -82,6 +88,8 @@ export interface ToolEventMap {
     'permission.evaluated': {
         sessionId?: string | undefined;
         traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
         agentId?: string | undefined;
         name: string;
         id: string;
@@ -147,7 +155,7 @@ export interface ToolEventMap {
      */
     'tool.loop_detected': {
         sessionId?: string | undefined;
-        ctx: Context;
+        ctx: AgentContext;
         /** Comma-separated tool names involved in the loop, or empty string for pure message loops. */
         tools: string;
         /** Number of repeats detected (consecutive iterations, or identical calls within the window for `scope: 'call'`). */
@@ -184,6 +192,8 @@ export interface ToolEventMap {
     'tool.executed': {
         sessionId?: string | undefined;
         traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
         agentId?: string | undefined;
         agentName?: string | undefined;
         /**

package/dist/observability/index.js

@@ -388,7 +388,7 @@ var SENSITIVE_FLAG_PATTERNS = [
   // redaction function (false positive = cosmetic noise; false negative = leak).
   /(?<![-\w])-(?:password|p|a)(?:[=\s]+)?[^\s,-]+/gi,
   // env var–style secrets: TOKEN=x, API_KEY=y, etc.
-  /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD)\s*[=:]\s*[^\s,]+/gi,
+  /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD|PASSPHRASE)\s*[=:]\s*[^\s,]+/gi,
   // Generic high-entropy look: base64 strings >32 chars or hex strings >32 digits — but only
   // when preceded by a flag name (e.g. --github-token=EyJ...). Global flag so
   // every such flag in the command line is redacted, not just the first.

package/dist/plugin/index.js

@@ -1945,18 +1945,88 @@ var DefaultPluginAPI = class {
       list: () => tr.list()
     };
     const pr = init.providerRegistry;
+    const providerTypesIOwn = /* @__PURE__ */ new Set();
+    const assertCanMutateProvider = (type, op) => {
+      if (isOfficial) return;
+      if (providerTypesIOwn.has(type)) return;
+      if (!pr.has(type)) return;
+      throw new Error(
+        `Plugin "${owner}" may not ${op} provider "${type}" \u2014 it was not registered by this plugin. Replacing an existing provider would route prompts and credentials through plugin code.`
+      );
+    };
     this.providers = {
-      register: (f) => pr.register(f),
-      unregister: (type) => pr.unregister(type),
+      register: (f) => {
+        assertCanMutateProvider(f.type, "replace");
+        pr.register(f);
+        providerTypesIOwn.add(f.type);
+      },
+      unregister: (type) => {
+        assertCanMutateProvider(type, "unregister");
+        providerTypesIOwn.delete(type);
+        return pr.unregister(type);
+      },
       create: (cfg) => pr.create(cfg),
       list: () => pr.list()
     };
-    this.mcp = init.mcpRegistry ?? noopMcp;
+    const mcpRegistry = init.mcpRegistry;
+    if (!mcpRegistry) {
+      this.mcp = noopMcp;
+    } else {
+      const mcpServersIStarted = /* @__PURE__ */ new Set();
+      const assertOwnsMcpServer = (name, op) => {
+        if (isOfficial) return;
+        if (mcpServersIStarted.has(name)) return;
+        if (!mcpRegistry.list().some((s) => s.name === name)) return;
+        throw new Error(
+          `Plugin "${owner}" may not ${op} MCP server "${name}" \u2014 it was not started by this plugin.`
+        );
+      };
+      this.mcp = {
+        start: async (cfg) => {
+          const name = cfg?.name;
+          if (typeof name === "string" && mcpRegistry.list().some((s) => s.name === name)) {
+            assertOwnsMcpServer(name, "start");
+          }
+          await mcpRegistry.start(cfg);
+          if (typeof name === "string") mcpServersIStarted.add(name);
+        },
+        stop: async (name) => {
+          assertOwnsMcpServer(name, "stop");
+          await mcpRegistry.stop(name);
+        },
+        restart: async (name) => {
+          assertOwnsMcpServer(name, "restart");
+          await mcpRegistry.restart(name);
+        },
+        list: () => mcpRegistry.list()
+      };
+    }
     const scr = init.slashCommandRegistry;
     const official = init.official === true;
+    const commandsIOwn = /* @__PURE__ */ new Set();
     this.slashCommands = scr ? {
-      register: (cmd) => scr.register(cmd, owner, { official }),
-      unregister: (name) => scr.unregister(name),
+      register: (cmd) => {
+        scr.register(cmd, owner, { official });
+        for (const key of [cmd.name, ...cmd.aliases ?? []]) {
+          commandsIOwn.add(key);
+          commandsIOwn.add(`${owner}:${key}`);
+        }
+      },
+      unregister: (name) => {
+        if (!official && !commandsIOwn.has(name) && scr.get(name) !== void 0) {
+          throw new Error(
+            `Plugin "${owner}" may not unregister slash command "${name}" \u2014 it was not registered by this plugin.`
+          );
+        }
+        for (const key of [
+          name,
+          `${owner}:${name}`,
+          name.startsWith(`${owner}:`) ? name.slice(owner.length + 1) : name
+        ]) {
+          commandsIOwn.delete(key);
+        }
+        return scr.unregister(name);
+      },
       get: (name) => scr.get(name),
       list: () => scr.list()
     } : noopSlashCommands;
@@ -5089,7 +5159,11 @@ function relationKeys(event) {
   add("attempt", event.correlation.attemptId, "explicit");
   add("decision", event.attributes?.decisionId, "explicit");
   add("network_request", event.attributes?.requestId, "explicit");
-  add("prompt_manifest", event.attributes?.promptManifest?.manifestId, "explicit");
+  add(
+    "prompt_manifest",
+    event.correlation.promptManifestId ?? event.attributes?.promptManifest?.manifestId,
+    "explicit"
+  );
   add("resource_lineage", event.resource?.id, "inferred");
   if (event.eventType === "metrics.rollup" && event.attributes?.signal === "tool.resource.observed") {
     const resources = event.attributes.resources;
@@ -5111,6 +5185,7 @@ function matches(event, query) {
   if (!equal(query.agentId, event.scope.agentId) || !equal(query.taskId, event.scope.taskId)) return false;
   if (!equal(query.providerId, event.runtime?.providerId) || !equal(query.modelId, event.runtime?.modelId)) return false;
   if (!equal(query.traceId, event.correlation.traceId) || !equal(query.logicalRequestId, event.correlation.logicalRequestId)) return false;
+  if (!equal(query.promptManifestId, event.correlation.promptManifestId)) return false;
   if (!equal(query.attemptId, event.correlation.attemptId) || !equal(query.toolCallId, event.correlation.toolCallId)) return false;
   if (!equal(query.resourceKind, event.resource?.kind) || !equal(query.resourceId, event.resource?.id)) return false;
   if (query.path && normalize(event.resource?.path) !== normalize(query.path)) return false;
@@ -5251,6 +5326,7 @@ function isChronicleEvent(value) {
   ]) && typeof value.correlation.traceId === "string" && typeof value.correlation.spanId === "string" && optionalStrings(value.correlation, [
     "parentSpanId",
     "logicalRequestId",
+    "promptManifestId",
     "attemptId",
     "toolCallId"
   ]) && isRuntime(value.runtime) && isResource(value.resource) && (value.attributes === void 0 || isRecord2(value.attributes)) && (value.tags === void 0 || isStringRecord(value.tags));
@@ -5440,7 +5516,7 @@ var ChronicleQuotaManager = class {
 };
 
 // src/chronicle/sqlite-journal-schema.ts
-import { createRequire } from "node:module";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
 
 // src/utils/index.ts
 init_atomic_write();
@@ -5829,25 +5905,47 @@ function withSqliteExperimentalWarningSuppressed(run) {
   }
 }
 
+// src/utils/win32-cmd.ts
+var WIN32_CMD_META = /[&|<>"%\r\n\0]/;
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32CmdArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function assertSafeWin32CmdArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
 // src/chronicle/sqlite-journal-schema.ts
 var CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
 var LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
 var LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
 var LEGACY_JSONL_BOUNDARY_KEY = "legacy-jsonl-v1:boundary";
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
 var Ctor;
 function loadDatabaseSync() {
   if (Ctor) return Ctor;
-  if (Ctor === null) throw new Error("node:sqlite is unavailable in this runtime");
+  if (Ctor === null) throw new Error("SQLite is unavailable in this runtime");
   try {
-    Ctor = withSqliteExperimentalWarningSuppressed(
-      () => createRequire(import.meta.url)("node:sqlite").DatabaseSync
-    );
+    Ctor = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync);
     return Ctor;
   } catch (error) {
     Ctor = null;
     throw new Error(
-      "The Chronicle journal needs Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
+      "The Chronicle journal needs node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
     );
   }
 }
@@ -5862,6 +5960,7 @@ function projectEvent(event) {
     taskId: event.scope.taskId ?? null,
     traceId: event.correlation?.traceId ?? null,
     logicalRequestId: event.correlation?.logicalRequestId ?? null,
+    promptManifestId: event.correlation?.promptManifestId ?? null,
     resourceKind: event.resource?.kind ?? null,
     resourceId: event.resource?.id ?? null,
     resourcePath: event.resource?.path ?? null,
@@ -5886,6 +5985,7 @@ function ensureChronicleSchema(db) {
       task_id            TEXT,
       trace_id           TEXT,
       logical_request_id TEXT,
+      prompt_manifest_id TEXT,
       resource_kind      TEXT,
       resource_id        TEXT,
       resource_path      TEXT,
@@ -5913,6 +6013,10 @@ function ensureChronicleSchema(db) {
   if (version < 2) {
     db.exec("DROP INDEX IF EXISTS events_resource_path");
   }
+  if (version > 0 && version < 3) {
+    db.exec("ALTER TABLE events ADD COLUMN prompt_manifest_id TEXT");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS events_prompt_manifest ON events(prompt_manifest_id)");
   if (version !== SCHEMA_VERSION) {
     db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
   }
@@ -5949,6 +6053,7 @@ function pushDown(query) {
   eq("task_id", query.taskId);
   eq("trace_id", query.traceId);
   eq("logical_request_id", query.logicalRequestId);
+  eq("prompt_manifest_id", query.promptManifestId);
   eq("resource_kind", query.resourceKind);
   eq("resource_id", query.resourceId);
   if (query.eventTypes?.length) {
@@ -6305,6 +6410,7 @@ var ChronicleSqliteJournal = class {
           row.taskId,
           row.traceId,
           row.logicalRequestId,
+          row.promptManifestId,
           row.resourceKind,
           row.resourceId,
           row.resourcePath,
@@ -6464,9 +6570,9 @@ var ChronicleSqliteJournal = class {
     const insert = this.db.prepare(
       `INSERT INTO events (
          day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-         project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+         project_id, session_id, agent_id, task_id, trace_id, logical_request_id, prompt_manifest_id,
          resource_kind, resource_id, resource_path, duration_ns, payload
-       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
     );
     const checkpoint = this.db.prepare(
       `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
@@ -6495,6 +6601,7 @@ var ChronicleSqliteJournal = class {
             row.taskId,
             row.traceId,
             row.logicalRequestId,
+            row.promptManifestId,
             row.resourceKind,
             row.resourceId,
             row.resourcePath,
@@ -6581,9 +6688,9 @@ var ChronicleSqliteJournal = class {
       insert: this.db.prepare(
         `INSERT INTO events (
            day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
-           project_id, session_id, agent_id, task_id, trace_id, logical_request_id,
+           project_id, session_id, agent_id, task_id, trace_id, logical_request_id, prompt_manifest_id,
            resource_kind, resource_id, resource_path, duration_ns, payload
-         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
       ),
       trimBoundary: this.db.prepare(
         "SELECT day, sequence, hash FROM events ORDER BY day, sequence LIMIT 1 OFFSET ?"
@@ -6624,8 +6731,8 @@ var ChronicleSqliteJournal = class {
 };
 
 // src/chronicle/metrics-schema.ts
-import { createRequire as createRequire2 } from "node:module";
-var SCHEMA_VERSION2 = 3;
+import { loadRuntimeDatabaseSync as loadRuntimeDatabaseSync2 } from "@wrongstack/persistence";
+var SCHEMA_VERSION2 = 4;
 var READ_CHUNK_BYTES = 1024 * 1024;
 var SQLITE_SOURCE_PREFIX = "sqlite:";
 var SQLITE_INGEST_BATCH = 2e3;
@@ -6643,16 +6750,14 @@ var EMPTY_FAMILIES = {
 var Ctor2;
 function loadDatabaseSync2() {
   if (Ctor2) return Ctor2;
-  if (Ctor2 === null) throw new Error("node:sqlite is unavailable in this runtime");
+  if (Ctor2 === null) throw new Error("SQLite is unavailable in this runtime");
   try {
-    Ctor2 = withSqliteExperimentalWarningSuppressed(
-      () => createRequire2(import.meta.url)("node:sqlite").DatabaseSync
-    );
+    Ctor2 = withSqliteExperimentalWarningSuppressed(loadRuntimeDatabaseSync2);
     return Ctor2;
   } catch (error) {
     Ctor2 = null;
     throw new Error(
-      "Chronicle metrics need Node's built-in SQLite (node:sqlite, Node >= 22.5): " + (error instanceof Error ? error.message : String(error))
+      "Chronicle metrics need node:sqlite (Node >= 22.5) or bun:sqlite: " + (error instanceof Error ? error.message : String(error))
     );
   }
 }
@@ -6713,6 +6818,9 @@ function ensureMetricsSchema(db) {
       tool_name TEXT NOT NULL DEFAULT '',
       provider_id TEXT NOT NULL DEFAULT '',
       model_id TEXT NOT NULL DEFAULT '',
+      logical_request_id TEXT NOT NULL DEFAULT '',
+      prompt_manifest_id TEXT NOT NULL DEFAULT '',
+      provenance_confidence TEXT NOT NULL DEFAULT 'unknown',
       source TEXT NOT NULL DEFAULT ''
     );
     CREATE INDEX IF NOT EXISTS idx_file_lineage_path ON file_lineage(path_key, occurred_at);
@@ -6805,6 +6913,20 @@ var ChronicleMetricsIngester = class {
   db;
   directory;
   dbPath;
+  /**
+   * Prepared-statement cache for the per-event ingest hot paths. Preparing
+   * the same SQL on every event was the dominant ingest cost; node:sqlite
+   * statements are reusable, so each distinct SQL string is prepared once.
+   */
+  stmtCache = /* @__PURE__ */ new Map();
+  stmt(sql) {
+    let s = this.stmtCache.get(sql);
+    if (!s) {
+      s = this.db.prepare(sql);
+      this.stmtCache.set(sql, s);
+    }
+    return s;
+  }
   async refresh() {
     const result = {
       ingestedEvents: 0,
@@ -6834,7 +6956,7 @@ var ChronicleMetricsIngester = class {
             let base;
             if (!migrated) {
               base = offsets.get(key) ?? 0;
-            } else if (boundary !== null && boundary.has(key)) {
+            } else if (boundary?.has(key)) {
               base = Math.max(offsets.get(key) ?? 0, boundary.get(key));
             } else {
               base = rebuilt ? 0 : offsets.get(key) ?? 0;
@@ -7057,11 +7179,11 @@ var ChronicleMetricsIngester = class {
   }
   ingestDailyCounters(event) {
     const day = eventDay(event);
-    this.db.prepare("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
-    const bump = (sql, ...params) => this.db.prepare(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
+    this.stmt("INSERT OR IGNORE INTO daily_counters (day) VALUES (?)").run(day);
+    const bump = (sql, ...params) => this.stmt(`UPDATE daily_counters SET ${sql} WHERE day = ?`).run(...params, day);
     const family = signalFamily(event);
     const failed = isTerminalFailure(event) ? 1 : 0;
-    this.db.prepare(
+    this.stmt(
       `INSERT INTO family_daily (day, family, count, failure_count) VALUES (?, ?, 1, ?)
        ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
     ).run(day, family, failed);
@@ -7070,12 +7192,15 @@ var ChronicleMetricsIngester = class {
       bump("cancellations = cancellations + 1");
     if (family === "agent") bump("agent_events = agent_events + 1");
     if (event.correlation.logicalRequestId) {
-      this.db.prepare(
+      this.stmt(
         "INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)"
       ).run(day, event.correlation.logicalRequestId);
     }
     if (event.scope.agentId) {
-      this.db.prepare("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(day, event.scope.agentId);
+      this.stmt("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(
+        day,
+        event.scope.agentId
+      );
     }
     const type = event.eventType;
     if (type === "decision.requested") bump("decisions = decisions + 1");
@@ -7097,7 +7222,10 @@ var ChronicleMetricsIngester = class {
     if (event.resource?.kind === "file" || type.startsWith("file.")) {
       bump("file_events_all = file_events_all + 1");
       if (event.resource?.path) {
-        this.db.prepare("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(day, normalizePathKey(event.resource.path));
+        this.stmt("INSERT OR IGNORE INTO file_seen_daily (day, path_key) VALUES (?, ?)").run(
+          day,
+          normalizePathKey(event.resource.path)
+        );
       }
     }
   }
@@ -7106,8 +7234,10 @@ var ChronicleMetricsIngester = class {
     const providerId = event.runtime?.providerId ?? asString(readPath2(event.attributes ?? {}, "from.providerId")) ?? "";
     const modelId = event.runtime?.modelId ?? asString(readPath2(event.attributes ?? {}, "from.model")) ?? "";
     if (!providerId && !modelId) return;
-    this.db.prepare("INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)").run(day, providerId, modelId);
-    const update = (sql, ...params) => this.db.prepare(
+    this.stmt(
+      "INSERT OR IGNORE INTO provider_daily (day, provider_id, model_id) VALUES (?, ?, ?)"
+    ).run(day, providerId, modelId);
+    const update = (sql, ...params) => this.stmt(
       `UPDATE provider_daily SET ${sql} WHERE day = ? AND provider_id = ? AND model_id = ?`
     ).run(...params, day, providerId, modelId);
     const duration = durationMs2(event);
@@ -7148,7 +7278,7 @@ var ChronicleMetricsIngester = class {
     if (typeof cost !== "number" || !Number.isFinite(cost)) return;
     const scopeKey2 = `${event.scope.projectId ?? ""}\0${event.scope.sessionId ?? ""}\0${event.scope.agentId ?? ""}`;
     const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare(
+    this.stmt(
       `INSERT INTO token_cost (scope_key, day, occurred_at, sequence, cost) VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(scope_key) DO UPDATE SET
          day = excluded.day, occurred_at = excluded.occurred_at,
@@ -7162,8 +7292,8 @@ var ChronicleMetricsIngester = class {
     const taskId = event.scope.taskId ?? stringAt(attributes, "taskId");
     if (!taskId) return;
     const occurredAt = event.occurredAt ?? event.observedAt;
-    this.db.prepare("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
-    const set = (sql, ...params) => this.db.prepare(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
+    this.stmt("INSERT OR IGNORE INTO task_outcomes (task_id) VALUES (?)").run(taskId);
+    const set = (sql, ...params) => this.stmt(`UPDATE task_outcomes SET ${sql} WHERE task_id = ?`).run(...params, taskId);
     const lineage = [
       ["run_id", stringAt(attributes, "runId")],
       ["board_id", event.scope.kanbanBoardId ?? stringAt(attributes, "boardId")],
@@ -7210,11 +7340,12 @@ var ChronicleMetricsIngester = class {
     if (!operation || operation === "read") return;
     const filePath = event.resource?.path ?? stringAt(attributes, "filePath");
     if (!filePath) return;
-    this.db.prepare(
+    this.stmt(
       `INSERT OR IGNORE INTO file_lineage
         (event_id, path, path_key, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
-         tool_name, provider_id, model_id, source)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+         tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+         provenance_confidence, source)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(
       event.eventId,
       normalizeKey2(filePath),
@@ -7229,10 +7360,17 @@ var ChronicleMetricsIngester = class {
       stringAt(attributes, "toolName") ?? "",
       event.runtime?.providerId ?? stringAt(attributes, "provider") ?? "",
       event.runtime?.modelId ?? stringAt(attributes, "model") ?? "",
+      event.correlation.logicalRequestId ?? stringAt(attributes, "logicalRequestId") ?? "",
+      event.correlation.promptManifestId ?? stringAt(attributes, "promptManifestId") ?? "",
+      provenanceConfidence(attributes),
       stringAt(attributes, "source") ?? (event.eventType === "file.event" ? "tool" : "external")
     );
   }
 };
+function provenanceConfidence(attributes) {
+  const value = attributes["provenanceConfidence"];
+  return value === "explicit" || value === "correlated" || value === "inferred" ? value : "unknown";
+}
 
 // src/chronicle/metrics-store.ts
 var ChronicleMetricsStore = class _ChronicleMetricsStore {
@@ -7364,7 +7502,8 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
     const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
     params.push(clampLimit(options.limit, 200));
     const projection = `path, operation, occurred_at, session_id, agent_id, task_id, board_id, run_id,
-       tool_name, provider_id, model_id, source`;
+       tool_name, provider_id, model_id, logical_request_id, prompt_manifest_id,
+       provenance_confidence, source`;
     const sql = options.latestPerPath ? `SELECT ${projection} FROM (
            SELECT ${projection}, ROW_NUMBER() OVER (
              PARTITION BY path_key ORDER BY occurred_at DESC, event_id DESC
@@ -7385,6 +7524,9 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
       toolName: row.tool_name,
       providerId: row.provider_id,
       modelId: row.model_id,
+      logicalRequestId: row.logical_request_id,
+      promptManifestId: row.prompt_manifest_id,
+      provenanceConfidence: row.provenance_confidence,
       source: row.source
     }));
   }
@@ -8034,6 +8176,7 @@ function legacyPartitionPath(location) {
 function useSqliteStore() {
   return process.env["WRONGSTACK_CHRONICLE_STORE"] !== "jsonl";
 }
+var MAX_OPEN_JOURNAL_DAYS = 2;
 var InlineChronicleProjectAccess = class {
   constructor(options) {
     this.options = options;
@@ -8142,6 +8285,26 @@ var InlineChronicleProjectAccess = class {
   get chronicleDirectory() {
     return path16.join(this.options.projectDir, "chronicle");
   }
+  /**
+   * Drop journals for days we will not write to again.
+   *
+   * Mirrors the daemon's `pruneJournals` in `project-server.ts`: without a cap
+   * an inline access object that lives across midnight kept one open
+   * `ChronicleJournal` (with its write buffer and file handle) per day, forever.
+   */
+  pruneJournals(currentDay) {
+    if (this.journals.size <= MAX_OPEN_JOURNAL_DAYS) return;
+    const keep = new Set(
+      [...this.journals.keys()].sort().reverse().slice(0, MAX_OPEN_JOURNAL_DAYS)
+    );
+    keep.add(currentDay);
+    for (const [day, journal] of this.journals) {
+      if (keep.has(day)) continue;
+      this.journals.delete(day);
+      void journal.flush().catch(() => {
+      });
+    }
+  }
   journalForToday() {
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
@@ -8158,6 +8321,7 @@ var InlineChronicleProjectAccess = class {
         retentionDays: this.options.retentionDays
       });
       this.journals.set(day, journal);
+      this.pruneJournals(day);
     }
     return journal;
   }
@@ -11600,14 +11764,21 @@ async function openInEditor(filePath, env = process.env) {
       context: { filePath }
     });
   }
-  const child = spawn5(parts[0], [...parts.slice(1), filePath], {
+  const editorArgs = [...parts.slice(1), filePath];
+  const child = shell ? (() => {
+    const inv = buildWin32CmdShimInvocation(parts[0], editorArgs);
+    return spawn5(inv.command, inv.args, {
+      stdio: "ignore",
+      detached: true,
+      windowsVerbatimArguments: inv.windowsVerbatimArguments,
+      // Suppresses the console flash the cmd.exe wrapper would otherwise
+      // show before the editor appears. Repo convention — see
+      // `core/tests/architecture/spawn-convention.test.ts`.
+      windowsHide: true
+    });
+  })() : spawn5(parts[0], editorArgs, {
     stdio: "ignore",
     detached: true,
-    shell,
-    // `shell` routes through cmd.exe on win32, which flashes a console window
-    // before the editor appears. A GUI editor is unaffected by the flag; the
-    // shell wrapper is what it suppresses. Repo convention — see
-    // `core/tests/architecture/spawn-convention.test.ts`.
     windowsHide: true
   });
   child.unref();
@@ -13789,7 +13960,7 @@ function walk2(node, vault, transform) {
   }
   return out;
 }
-var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key|token\b)/i;
+var SECRET_KEY_PATTERN = /(?:api[-_]?key|auth[-_]?token|authorization|proxy-authorization|cookie|bearer|secret|password|passwd|pwd|refresh[-_]?token|session[-_]?key|access[_-]?token|private[_-]?key|token\b)/i;
 var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
 function isSecretField(name) {
   const lc = name.toLowerCase();