context-mode 1.0.158 → 1.0.160

package/hooks/posttooluse.mjs

@@ -71,12 +71,23 @@ await runHook(async () => {
         const colonIdx = rejectedData.indexOf(":");
         const rejTool = colonIdx > 0 ? rejectedData.slice(0, colonIdx) : rejectedData;
         const rejReason = colonIdx > 0 ? rejectedData.slice(colonIdx + 1) : "denied";
-        db.insertEvent(sessionId, {
-          type: "rejected",
-          category: "rejected-approach",
-          data: `${rejTool}: ${rejReason}`,
-          priority: 2,
-        }, "PreToolUse");
+        // v1.0.160: route through attributeAndInsertEvents so the bridge wire
+        // receives this event too. db.insertEvent only writes locally — the
+        // dashboard's rejection-rate widget needs the platform row.
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          [{
+            type: "rejected",
+            category: "rejected-approach",
+            data: `${rejTool}: ${rejReason}`,
+            priority: 2,
+          }],
+          input,
+          projectDir,
+          "PreToolUse",
+          resolveProjectAttributions,
+        );
       }
     } catch { /* best-effort */ }
 
@@ -108,17 +119,24 @@ await runHook(async () => {
           const summary = redirectData.slice(i3 + 1);
           const bytesAvoided = Number.parseInt(bytesRaw, 10);
           if (Number.isFinite(bytesAvoided) && bytesAvoided > 0) {
-            db.insertEvent(
+            // v1.0.160: route through wire — context-saving (byte-accounting)
+            // widget on the platform reads category='redirect' rows. event
+            // carries bytes_avoided so the bytesList branch in
+            // attributeAndInsertEvents stamps the column.
+            attributeAndInsertEvents(
+              db,
               sessionId,
-              {
+              [{
                 type,
                 category: "redirect",
                 data: `${tool}: ${summary}`,
                 priority: 2,
-              },
+                bytes_avoided: bytesAvoided,
+              }],
+              input,
+              projectDir,
               "PreToolUse",
-              undefined,
-              { bytesAvoided, bytesReturned: 0 },
+              resolveProjectAttributions,
             );
           }
         }
@@ -140,12 +158,21 @@ await runHook(async () => {
         if (startTime && !isNaN(startTime)) {
           const duration = Date.now() - startTime;
           if (duration > 5000) {
-            db.insertEvent(sessionId, {
-              type: "tool_latency",
-              category: "latency",
-              data: `${toolName}: ${duration}ms`,
-              priority: 3,
-            }, "PostToolUse");
+            // v1.0.160: route through wire — slow-tool insights need this row.
+            attributeAndInsertEvents(
+              db,
+              sessionId,
+              [{
+                type: "tool_latency",
+                category: "latency",
+                data: `${toolName}: ${duration}ms`,
+                priority: 3,
+              }],
+              input,
+              projectDir,
+              "PostToolUse",
+              resolveProjectAttributions,
+            );
           }
         }
       }

package/hooks/precompact.mjs

@@ -17,16 +17,17 @@ await runHook(async () => {
     parseStdin,
     getSessionId,
     getSessionDBPath,
+    getInputProjectDir,
     resolveConfigDir,
   } = await import("./session-helpers.mjs");
-  const { createSessionLoaders } = await import("./session-loaders.mjs");
+  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
   const { appendFileSync } = await import("node:fs");
   const { join, dirname } = await import("node:path");
   const { fileURLToPath } = await import("node:url");
 
   // Resolve absolute path for imports
   const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-  const { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+  const { loadSessionDB, loadSnapshot, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
   const DEBUG_LOG = join(resolveConfigDir(), "context-mode", "precompact-debug.log");
 
   try {
@@ -52,31 +53,37 @@ await runHook(async () => {
       db.upsertResume(sessionId, snapshot, events.length);
       db.incrementCompactCount(sessionId);
 
-      // Write compaction category event for analytics
-      const fileEvents = events.filter(e => e.category === "file");
-      db.insertEvent(sessionId, {
-        type: "compaction_summary",
-        category: "compaction",
-        data: `Session compacted. ${events.length} events, ${fileEvents.length} files touched.`,
-        priority: 1,
-      }, "PreCompact");
-
-      // D2 PRD Phase 6.1: emit snapshot-built event with bytes_avoided=snapshot.length
-      // Snapshot bytes are bytes the model would have re-read on resume but didn't.
+      // v1.0.160: route compaction lifecycle events through wire so
+      // dashboard's compact widget gets per-compaction rows (the engine
+      // joins on category='compaction' to compute snapshot insights).
       try {
-        db.insertEvent(
+        const fileEvents = events.filter(e => e.category === "file");
+        const projectDirCompact = getInputProjectDir(input);
+        const { resolveProjectAttributions } = await loadProjectAttribution();
+        attributeAndInsertEvents(
+          db,
           sessionId,
-          {
-            type: "snapshot-built",
-            category: "compaction",
-            data: `Snapshot built. ${snapshot.length} bytes for ${events.length} events.`,
-            priority: 1,
-          },
+          [
+            {
+              type: "compaction_summary",
+              category: "compaction",
+              data: `Session compacted. ${events.length} events, ${fileEvents.length} files touched.`,
+              priority: 1,
+            },
+            {
+              type: "snapshot-built",
+              category: "compaction",
+              data: `Snapshot built. ${snapshot.length} bytes for ${events.length} events.`,
+              priority: 1,
+              bytes_avoided: snapshot.length,
+            },
+          ],
+          input,
+          projectDirCompact,
           "PreCompact",
-          undefined,
-          { bytesAvoided: snapshot.length, bytesReturned: 0 },
+          resolveProjectAttributions,
         );
-      } catch { /* best-effort */ }
+      } catch { /* best-effort — never block PreCompact */ }
     }
 
     db.close();

package/hooks/session-loaders.mjs

@@ -6,9 +6,10 @@
  * Fallback: if bundles are missing (marketplace installs), try build/session/*.js.
  */
 
-import { join } from "node:path";
+import { join, resolve as resolvePath } from "node:path";
 import { pathToFileURL } from "node:url";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 
 import { hasPlatformConfig, maybeForward } from "./platform-bridge.mjs";
 import { detectPlatformFromEnv } from "./core/platform-detect.mjs";
@@ -82,13 +83,21 @@ export function attributeAndInsertEvents(db, sessionId, events, input, projectDi
   // no event carries a positive value we leave bytesList undefined so
   // SessionDB falls back to its 0-default for bytes_avoided/bytes_returned
   // — preserves backward compat with older callers / tests.
+  // v1.0.160: handle both bytes_avoided (saved) and bytes_returned (resume
+  // snapshot replay) so the snapshot-consumed event from sessionstart.mjs
+  // routes through here without losing the bytes_returned column.
   let bytesList;
-  if (events.some((e) => typeof e?.bytes_avoided === "number" && e.bytes_avoided > 0)) {
-    bytesList = events.map((e) =>
-      typeof e?.bytes_avoided === "number" && e.bytes_avoided > 0
-        ? { bytesAvoided: e.bytes_avoided }
-        : undefined,
-    );
+  const hasBytes = events.some((e) =>
+    (typeof e?.bytes_avoided === "number" && e.bytes_avoided > 0) ||
+    (typeof e?.bytes_returned === "number" && e.bytes_returned > 0),
+  );
+  if (hasBytes) {
+    bytesList = events.map((e) => {
+      const avoided = typeof e?.bytes_avoided === "number" && e.bytes_avoided > 0 ? e.bytes_avoided : 0;
+      const returned = typeof e?.bytes_returned === "number" && e.bytes_returned > 0 ? e.bytes_returned : 0;
+      if (avoided === 0 && returned === 0) return undefined;
+      return { bytesAvoided: avoided, bytesReturned: returned };
+    });
   }
   // Prefer bulk path (single transaction = single WAL commit). Falls back
   // to per-event insert for older SessionDB instances that lack bulkInsertEvents.
@@ -115,9 +124,25 @@ export function attributeAndInsertEvents(db, sessionId, events, input, projectDi
       ? db.getSessionRollup(sessionId)
       : null;
 
+    // v1.0.159: Bash metadata shared across all events from this hook fire.
+    // A single Bash tool call may emit multiple canonical events (a `git
+    // pull` produces type=git AND type=cwd) — they all share the same
+    // command_type / command_tool / exit_code / duration_bucket. Hook
+    // metadata (latency, exit_code) is also per-call, not per-event.
+    const bashMeta = deriveBashMetadata(input);
+    // v1.0.159: latency_ms read from the PreToolUse timestamp stamp.
+    // PreToolUse writes ms-precision Date.now() to a tmp file, PostToolUse
+    // reads + computes delta + cleans up. Failure → undefined (no field
+    // surfaces on the wire; Zod is optional).
+    const latencyMs = readLatencyMs(sessionId, input?.tool_name);
+
     for (let i = 0; i < events.length; i++) {
       const enriched = enrichEventForPlatform(events[i], attributions[i]);
-      const payload = rollup ? { ...enriched, ...rollup } : enriched;
+      const withBash = bashMeta ? { ...enriched, ...bashMeta } : enriched;
+      const withLatency = latencyMs !== undefined
+        ? { ...withBash, latency_ms: latencyMs, duration_bucket: bucketizeDuration(latencyMs) }
+        : withBash;
+      const payload = rollup ? { ...withLatency, ...rollup } : withLatency;
       maybeForward({ ...payload, session_id: sessionId }, platform);
     }
   }
@@ -161,6 +186,15 @@ function enrichEventForPlatform(event, attribution) {
     enriched.error_tool = cls.error_tool;
   }
 
+  // blocker_status: derive from the canonical event TYPE, not lexical
+  // pattern-matching on prose. session-extract already identifies blocker
+  // states semantically (type='blocker' when the agent signals stuck;
+  // type='blocker_resolved' on recovery). Regex on error_message would
+  // false-positive on the millions of error texts in the wild — we let
+  // the extractor's structural judgment be the source of truth.
+  if (event?.type === "blocker") enriched.blocker_status = "open";
+  else if (event?.type === "blocker_resolved") enriched.blocker_status = "resolved";
+
   // Git events: surface commit message + mark has_commit at the event level
   // (rollup-level has_commit comes from the session-wide stamp; both win
   // when set — `{...enriched, ...rollup}` order keeps rollup authoritative
@@ -205,3 +239,192 @@ function classifyError(message) {
   if (/test failed|fail |tests failed|assertion/.test(m)) return { error_category: "test_failed", error_tool: "Bash" };
   return { error_category: "unknown", error_tool: "Bash" };
 }
+
+// ── Bash metadata derivation — algorithmic, not enumerative ──────────────
+//
+// A single Bash tool call may emit MULTIPLE canonical events (a `git pull`
+// produces type='git' AND type='cwd'). The platform's command_metadata
+// describes the BASH CALL, not the per-event derivative — so all events
+// from one PostToolUse fire carry the same shape. Non-Bash tool calls
+// return null and the per-event fields stay undefined (Zod optional drops
+// them silently — no NULL noise on the wire).
+//
+// DESIGN: tool ecosystems contain millions of CLI binaries but converge on
+// a tiny canonical verb set (test/build/install/lint/format/run/start/
+// deploy/...). The classifier scans for these verbs at canonical token
+// positions — agnostic of which package manager / language / framework.
+// New tools without a registry change automatically classify correctly as
+// long as they use the verbs (which is the dominant ecosystem convention).
+// This was originally regex-table enumeration; the table never converges.
+const CANONICAL_VERBS = new Set([
+  "test", "build", "install", "lint", "format", "run", "start",
+  "deploy", "compile", "bundle", "watch", "serve", "publish",
+]);
+// Runners that wrap the actual executable — strip them so command_tool
+// reflects the real binary the user invoked (`bunx pytest` → "pytest",
+// not "bunx"). NODE_ENV=production npm run build → "npm".
+const COMMAND_RUNNERS = new Set([
+  "sudo", "doas", "env", "exec", "time",
+  "npx", "pnpx", "bunx", "pnpm", "yarn", "bun",
+]);
+const ENV_ASSIGN_RE = /^[A-Z_][A-Z0-9_]*=/;
+
+// Tools whose NAME directly implies their type (no subcommand needed).
+// Curated minimum — covers the dominant test/lint/format/build/db/http/
+// deploy invocations across ecosystems. New ecosystem tools land in
+// "other" until added — preferred to a noisy heuristic that misclassifies.
+// Lookup is O(1); contrast with the original regex-table approach which
+// scaled to no boundary and still missed unknowns.
+const CANONICAL_TOOLS = new Map([
+  // test runners
+  ["pytest", "test"], ["jest", "test"], ["vitest", "test"], ["mocha", "test"],
+  ["ava", "test"], ["jasmine", "test"], ["rspec", "test"], ["junit", "test"],
+  ["tap", "test"], ["karma", "test"],
+  // linters
+  ["eslint", "lint"], ["tslint", "lint"], ["ruff", "lint"], ["rubocop", "lint"],
+  ["pylint", "lint"], ["flake8", "lint"], ["clippy", "lint"], ["staticcheck", "lint"],
+  ["mypy", "lint"], ["shellcheck", "lint"],
+  // formatters
+  ["prettier", "format"], ["black", "format"], ["gofmt", "format"], ["rustfmt", "format"],
+  ["autopep8", "format"], ["yapf", "format"],
+  // bundlers / builders
+  ["webpack", "build"], ["vite", "build"], ["rollup", "build"], ["esbuild", "build"],
+  ["parcel", "build"], ["tsc", "build"], ["swc", "build"], ["turbo", "build"],
+  // deploy / infra
+  ["docker", "deploy"], ["kubectl", "deploy"], ["terraform", "deploy"], ["pulumi", "deploy"],
+  ["ansible", "deploy"], ["helm", "deploy"], ["aws", "deploy"], ["gcloud", "deploy"], ["az", "deploy"],
+  // databases
+  ["psql", "database"], ["mysql", "database"], ["sqlite3", "database"],
+  ["redis-cli", "database"], ["mongosh", "database"], ["mongo", "database"],
+  // http
+  ["curl", "http"], ["wget", "http"], ["httpie", "http"], ["http", "http"],
+]);
+
+function deriveBashMetadata(input) {
+  if (input?.tool_name !== "Bash") return null;
+  const cmd = String(input?.tool_input?.command ?? "").trim();
+  if (!cmd) return { command_type: "other", command_tool: "Bash" };
+
+  const tokens = cmd.split(/\s+/);
+  const command_tool = extractCommandTool(tokens);
+  const command_type = classifyCommandType(tokens, command_tool);
+  const exit_code = inferExitCode(input?.tool_response);
+  return { command_type, command_tool, exit_code };
+}
+
+// Strip env-assign prefixes (`FOO=bar`), then strip runner shells,
+// then return the basename of the executable token.
+function extractCommandTool(tokens) {
+  let i = 0;
+  // Skip env assignments
+  while (i < tokens.length && ENV_ASSIGN_RE.test(tokens[i])) i++;
+  // Skip runner shells
+  while (i < tokens.length && COMMAND_RUNNERS.has(tokens[i].toLowerCase())) {
+    i++;
+    // Skip subcommands like `pnpm dlx`, `pnpm exec`, `bun run`
+    if (i < tokens.length && /^(dlx|exec|run|x)$/i.test(tokens[i])) i++;
+  }
+  if (i >= tokens.length) return tokens[0] || "Bash";
+  const exe = tokens[i];
+  // basename of path-like executables (`/usr/local/bin/foo` → "foo")
+  const base = exe.split(/[/\\]/).pop() || "Bash";
+  // Strip shell quoting if present
+  return base.replace(/^['"]|['"]$/g, "");
+}
+
+// Type classification — priority order:
+//   1. Tool name implies type (curated CANONICAL_TOOLS map)
+//   2. Canonical verb at subcommand position (`npm test`, `cargo build`)
+//   3. Argument-shape heuristics (test/ dir, .test.ts suffix, --prod flag)
+//   4. Tool-level fallback (git → git, make → build)
+//   5. "other"
+function classifyCommandType(tokens, command_tool) {
+  const toolLc = (command_tool || "").toLowerCase();
+
+  // 1. Tool name itself names the type
+  const fromTool = CANONICAL_TOOLS.get(toolLc);
+  if (fromTool) return fromTool;
+
+  // Skip env + runners to find subcommand position
+  const lower = tokens.map((t) => t.toLowerCase());
+  let start = 0;
+  while (start < lower.length && ENV_ASSIGN_RE.test(tokens[start])) start++;
+  while (start < lower.length && COMMAND_RUNNERS.has(lower[start])) {
+    start++;
+    if (start < lower.length && /^(dlx|exec|run|x)$/.test(lower[start])) start++;
+  }
+
+  // 2. Canonical verb scan within next 4 tokens
+  const horizon = Math.min(lower.length, start + 4);
+  for (let i = start; i < horizon; i++) {
+    if (CANONICAL_VERBS.has(lower[i])) return lower[i];
+  }
+
+  // 3. Argument-shape heuristics
+  const tail = tokens.slice(start).join(" ");
+  if (/\btests?[/\\]|\bspec[/\\]|__tests__|\.(test|spec)\.[mc]?[jt]sx?\b|test_[\w-]+\.py\b|_test\.go\b/.test(tail)) return "test";
+  if (/--(prod|production|release|optimize)\b/.test(tail)) return "build";
+  if (/\bDockerfile\b|docker-compose/.test(tail)) return "deploy";
+
+  // 4. Tool-level fallback for tools whose mere presence implies the type
+  if (toolLc === "git") return "git";
+  if (toolLc === "make" || toolLc === "ninja" || toolLc === "cmake") return "build";
+
+  return "other";
+}
+
+// Exit code best-effort inference from tool_response. Hook stdin does
+// not carry the actual exit code on CC; we read the shape of the output
+// for signals. Engine treats exit_code as soft signal (Anomaly #3 — no
+// pattern in patterns.ts reads it today), so probabilistic stamps are
+// adequate. Captures named exit code when explicit.
+function inferExitCode(response) {
+  const r = String(response ?? "");
+  if (!r) return 0;
+  // Explicit exit-code marker (some wrappers emit "exit status 137" etc.)
+  const explicit = r.match(/\bexit (?:status|code)\s+(\d+)\b/i);
+  if (explicit) return Number(explicit[1]);
+  // "command not found" → POSIX standard 127
+  if (/^bash:.*: (?:command not found|No such file)/m.test(r)) return 127;
+  // Heuristic non-zero indicators (line-anchored to avoid false positives
+  // inside narrative text from successful commands).
+  if (/^(?:Error: |Traceback|FAIL\b|✗|✘)/m.test(r)) return 1;
+  return 0;
+}
+
+// ── Latency timing — reads PreToolUse marker ────────────────────────────
+//
+// PreToolUse already writes `${tmpdir}/context-mode-latency-${sessionId}-
+// ${toolName}.txt` with the start timestamp (pretooluse.mjs:177). We
+// piggyback on that marker — read + compute delta, do NOT unlink (the
+// downstream slow-tool event emission in posttooluse.mjs:128-152 manages
+// the unlink lifecycle). Failure modes (missing marker, parse error,
+// negative delta, sanity-out-of-range) all return undefined — Zod's
+// optional handling drops the field silently. No NULL noise on the wire.
+function readLatencyMs(sessionId, toolName) {
+  if (!sessionId || !toolName) return undefined;
+  const markerPath = resolvePath(
+    tmpdir(),
+    `context-mode-latency-${sessionId}-${toolName}.txt`,
+  );
+  try {
+    const start = parseInt(readFileSync(markerPath, "utf8").trim(), 10);
+    if (!Number.isFinite(start) || start <= 0) return undefined;
+    const delta = Date.now() - start;
+    if (delta < 0 || delta > 24 * 3600 * 1000) return undefined;
+    return delta;
+  } catch {
+    return undefined;
+  }
+}
+
+// ── Duration bucket ──────────────────────────────────────────────────────
+//
+// Open-string label the platform Zod schema accepts (max 20 chars). Three
+// buckets cover the seed.ts shape: <5s | 5-30s | 30s+.
+function bucketizeDuration(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) return undefined;
+  if (ms < 5_000) return "<5s";
+  if (ms < 30_000) return "5-30s";
+  return "30s+";
+}

package/hooks/sessionstart.mjs

@@ -30,6 +30,7 @@ await runHook(async () => {
     readStdin,
     parseStdin,
     getSessionId,
+    getInputProjectDir,
     getSessionDBPath,
     getSessionEventsPath,
     getCleanupFlagPath,
@@ -38,7 +39,7 @@ await runHook(async () => {
   const { writeSessionEventsFile, buildSessionDirective, getSessionEvents } = await import(
     "./session-directive.mjs"
   );
-  const { createSessionLoaders } = await import("./session-loaders.mjs");
+  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
   const { join, dirname } = await import("node:path");
   const { fileURLToPath } = await import("node:url");
   const { readFileSync, unlinkSync, readdirSync, rmSync, lstatSync } = await import("node:fs");
@@ -49,7 +50,40 @@ await runHook(async () => {
 
   // Resolve absolute path for imports (fileURLToPath for Windows compat)
   const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-  const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+  const { loadSessionDB, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+
+  // Emit a `session_start` canonical event at the boundary of each session
+  // lifecycle transition (startup / resume / compact). The platform's insight
+  // engine joins on `category='session_start'` to compute per-session
+  // aggregates (~60 of 180 patterns depend on this anchor row). Bridge
+  // forwards via attributeAndInsertEvents which also stamps the rollup
+  // snapshot — safe for the FIRST event of a fresh session.
+  async function emitSessionStartLifecycle(db, sessionId, source, projectDir, input) {
+    try {
+      const { resolveProjectAttributions } = await loadProjectAttribution();
+      const lifecycleEvent = {
+        type: "session_start",
+        category: "session_start",
+        data: JSON.stringify({
+          source,
+          project_dir: projectDir,
+          started_at: Math.floor(Date.now() / 1000),
+        }),
+        priority: 1,
+      };
+      attributeAndInsertEvents(
+        db,
+        sessionId,
+        [lifecycleEvent],
+        input,
+        projectDir,
+        "SessionStart",
+        resolveProjectAttributions,
+      );
+    } catch {
+      // Best-effort — lifecycle emission failure MUST NOT block session start.
+    }
+  }
 
   // Self-heal a partial plugin cache install before anything else
   // touches the cache dir. The Algo-D4 boot gate and the #604
@@ -166,42 +200,48 @@ await runHook(async () => {
         // D2 PRD Phase 6.2: emit snapshot-consumed with bytes_returned=snapshot.length.
         // The resumed snapshot bytes ARE returned to the model — that's the whole
         // point of resume — so account them on bytes_returned, not bytes_avoided.
+        // v1.0.160: route through wire — resume metric on the platform reads
+        // category='session-resume' rows. Both snapshot-consumed (bytes
+        // returned) and resume_completed land here so the dashboard sees
+        // every resume boundary.
         try {
           const resumeRow = (resume && resume.snapshot)
             ? resume
             : (db.getResume?.(sessionId) ?? null);
           const snapshotBytes = resumeRow?.snapshot?.length ?? 0;
+          const { resolveProjectAttributions } = await loadProjectAttribution();
+          const projectDirResumeMeta = getInputProjectDir(input);
 
-          db.insertEvent(
+          await attributeAndInsertEvents(
+            db,
             sessionId,
-            {
+            [{
               type: "snapshot-consumed",
               category: "session-resume",
               data: `Session resumed from ${source}. Snapshot ${snapshotBytes} bytes injected.`,
               priority: 1,
-            },
-            "SessionStart",
-            undefined,
-            { bytesAvoided: 0, bytesReturned: snapshotBytes },
-          );
-        } catch { /* best-effort */ }
-
-        // Legacy resume_completed event retained for back-compat with existing
-        // analytics consumers that filter on `type === 'resume_completed'`.
-        try {
-          db.insertEvent(
-            sessionId,
-            {
+              bytes_returned: snapshotBytes,
+            }, {
               type: "resume_completed",
               category: "session-resume",
               data: `Session resumed from ${source}. Prior events loaded.`,
               priority: 1,
-            },
+            }],
+            input,
+            projectDirResumeMeta,
             "SessionStart",
+            resolveProjectAttributions,
           );
         } catch { /* best-effort */ }
       }
 
+      // Emit lifecycle anchor BEFORE close — engine joins on
+      // category='session_start' to compute per-session aggregates.
+      // Cross-platform projectDir via getInputProjectDir (covers cursor's
+      // workspace_roots[], codex/gemini/qwen's *_PROJECT_DIR env vars,
+      // CC's CLAUDE_PROJECT_DIR, falls back to input.cwd and process.cwd).
+      const projectDirCompact = getInputProjectDir(input);
+      await emitSessionStartLifecycle(db, sessionId, "compact", projectDirCompact, input);
       db.close();
     } else if (source === "resume") {
       // User invoked --continue, --resume, or /resume — clear cleanup flag so
@@ -234,6 +274,10 @@ await runHook(async () => {
         }
       }
 
+      const projectDirResume = getInputProjectDir(input);
+      if (sessionId) {
+        await emitSessionStartLifecycle(db, sessionId, "resume", projectDirResume, input);
+      }
       db.close();
     } else if (source === "startup") {
       // Fresh session (no --continue) — clean slate, capture CLAUDE.md rules.
@@ -277,22 +321,47 @@ await runHook(async () => {
       // context at startup, invisible to PostToolUse hooks. We read them from
       // disk so they survive compact/resume via the session events pipeline.
       const sessionId = getSessionId(input);
-      const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+      // v1.0.160: cross-adapter projectDir resolution (was hardcoded CC env).
+      const projectDir = getInputProjectDir(input);
       db.ensureSession(sessionId, projectDir);
       const claudeMdPaths = [
         join(resolveConfigDir(), "CLAUDE.md"),
         join(projectDir, "CLAUDE.md"),
         join(projectDir, ".claude", "CLAUDE.md"),
       ];
+      // v1.0.160: collect rule events into a batch and forward through wire.
+      // Dashboard's "CLAUDE.md adoption" widget COUNTs category='rule' rows on
+      // the platform — without this routing the widget reads 0 no matter how
+      // many CLAUDE.md files actually loaded.
+      const ruleEvents = [];
       for (const p of claudeMdPaths) {
         try {
           const content = readFileSync(p, "utf-8");
           if (content.trim()) {
-            db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
-            db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+            ruleEvents.push({ type: "rule", category: "rule", data: p, priority: 1 });
+            ruleEvents.push({ type: "rule_content", category: "rule", data: content, priority: 1 });
           }
         } catch { /* file doesn't exist — skip */ }
       }
+      if (ruleEvents.length > 0) {
+        try {
+          const { resolveProjectAttributions } = await loadProjectAttribution();
+          attributeAndInsertEvents(
+            db,
+            sessionId,
+            ruleEvents,
+            input,
+            projectDir,
+            "SessionStart",
+            resolveProjectAttributions,
+          );
+        } catch { /* best-effort — rule capture must never block start */ }
+      }
+
+      // Lifecycle anchor for a fresh session — emits BEFORE the CLAUDE.md
+      // rule events have been forwarded so the `session_start` row lands
+      // as the very first row the platform sees for this session.
+      await emitSessionStartLifecycle(db, sessionId, "startup", projectDir, input);
 
       db.close();
 

package/hooks/userpromptsubmit.mjs

@@ -77,8 +77,20 @@ await runHook(async () => {
         workspaceRoots: Array.isArray(input.workspace_roots) ? input.workspace_roots : [],
         lastKnownProjectDir: savedLastKnown || lastKnownProjectDir,
       });
-      for (let i = 0; i < userEvents.length; i++) {
-        db.insertEvent(sessionId, userEvents[i], "UserPromptSubmit", userAttributions[i]);
+      // v1.0.160: route through wire so prompt-derived events (decision /
+       // role / intent / data extractions) reach the platform. Previously
+       // they only landed in local SessionDB → dashboard's prompt-flow
+       // insights stayed at 0.
+      if (userEvents.length > 0) {
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          userEvents,
+          input,
+          projectDir,
+          "UserPromptSubmit",
+          resolveProjectAttributions,
+        );
       }
 
       db.close();

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.158",
+  "version": "1.0.160",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",