context-mode 1.0.158 → 1.0.159

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";
@@ -115,9 +116,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 +178,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 +231,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
@@ -202,6 +236,13 @@ await runHook(async () => {
         } 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 +275,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.
@@ -294,6 +339,11 @@ await runHook(async () => {
         } catch { /* file doesn't exist — skip */ }
       }
 
+      // 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();
 
       // Age-gated lazy cleanup of old plugin cache version dirs (#181).

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.159",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.158",
+  "version": "1.0.159",
   "type": "module",
   "description": "MCP plugin that saves 98% of your context window. Works with Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",