@swestash/agent-lens 0.5.4 → 0.7.0

package/dist/agent-lens.js

@@ -591,7 +591,7 @@ var CAC = class extends EventEmitter {
 var cac = (name = "") => new CAC(name);
 
 // ../core/dist/schema.js
-var SCHEMA_VERSION = 12;
+var SCHEMA_VERSION = 13;
 var SCHEMA_SQL = (
   /* sql */
   `
@@ -712,7 +712,8 @@ CREATE TABLE IF NOT EXISTS tool_calls (
   workflow_run_id     TEXT,              -- for Workflow: the run id (toolUseResult.runId, e.g. wf_<id>) \u2014 ties the run to its subagents
   workflow_name       TEXT,              -- for Workflow: the workflow name (toolUseResult.workflowName)
   resolved_model      TEXT,
-  status              TEXT,              -- success | error | ...
+  status              TEXT,              -- success | error | ... ('error' when the tool_result had is_error)
+  error_type          TEXT,             -- heuristic bucket for status='error' rows (see errors.ts); NULL otherwise
   total_duration_ms   INTEGER,
   total_tokens        INTEGER,
   total_tool_use_count INTEGER,
@@ -725,6 +726,7 @@ CREATE INDEX IF NOT EXISTS idx_tool_calls_skill ON tool_calls(skill_name);
 CREATE INDEX IF NOT EXISTS idx_tool_calls_skill_id ON tool_calls(skill_id);
 CREATE INDEX IF NOT EXISTS idx_tool_calls_spawned ON tool_calls(spawned_session_id);
 CREATE INDEX IF NOT EXISTS idx_tool_calls_workflow_run ON tool_calls(workflow_run_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_error_type ON tool_calls(error_type);
 
 -- Skill *versions* (content-addressed). A skill firing injects the full SKILL.md body into the
 -- transcript as an isMeta user event (begins "Base directory for this skill: \u2026", then the body,
@@ -945,6 +947,35 @@ var SECURITY_CATEGORIES = [
   }
 ];
 
+// ../core/dist/errors.js
+var ERROR_CLASSIFIER_VERSION = 1;
+var REJECTION_TYPES = /* @__PURE__ */ new Set(["user-rejected", "guardrail-blocked"]);
+function errorKind(type) {
+  return REJECTION_TYPES.has(type) ? "rejection" : "failure";
+}
+var PATTERNS = [
+  // — Rejections / blocks: is_error, but the agent's tool didn't fail — a human or guardrail stopped it.
+  { re: /interrupted by user|tool use was rejected|does(?:n['’]| not)t want to proceed|\bCancelled:/i, type: "user-rejected", kind: "rejection" },
+  { re: /\bBlocked:/i, type: "guardrail-blocked", kind: "rejection" },
+  // — Real tool failures.
+  { re: /String to replace not found/i, type: "string-not-found", kind: "failure" },
+  { re: /exceeds maximum allowed tokens/i, type: "token-limit", kind: "failure" },
+  // A non-zero Bash exit code is a command failure regardless of what its stderr text mentions — check
+  // it before the file-state fs-error patterns, since ENOENT/EISDIR also appear inside command stderr
+  // (e.g. `Exit code 2 npm error ENOENT`). The file-state patterns then catch the Read/Write/Edit
+  // tool_use_errors, which carry no exit code.
+  { re: /\bExit code\b/i, type: "command-failed", kind: "failure" },
+  { re: /has not been read yet|modified since (?:you |it was )?read|File (?:content )?does not exist|\bEISDIR\b|\bENOENT\b/i, type: "file-state", kind: "failure" }
+];
+function classifyToolError(resultSummary) {
+  const s = resultSummary ?? "";
+  for (const p of PATTERNS) {
+    if (p.re.test(s))
+      return { type: p.type, kind: p.kind };
+  }
+  return { type: "other", kind: "failure" };
+}
+
 // ../core/dist/pricing.js
 var PRICE_TABLE = {
   // Opus 4.0 / 4.1 launched at $15/$75; Opus 4.5 cut the Opus tier to $5/$25 and 4.6/4.7/4.8 kept it.
@@ -2041,8 +2072,13 @@ var ClaudeCodeAdapter = class {
           toolResults.push({
             tool_use_id: b.tool_use_id,
             result_summary: isAskUser ? JSON.stringify({ answers: tur.answers, annotations: tur.annotations ?? {} }) : summarizeResult(b.content),
+            // Tool failure is signalled by `is_error` on the tool_result block itself — NOT by
+            // toolUseResult.status (whose values are task/lifecycle states like completed/pending/
+            // async_launched and never "error"). Map is_error → status="error" so the error roll-ups,
+            // the transcript `tool-err` styling, and detect.ts's failed-attempt de-escalation all fire.
+            // Non-error results fall back to the toolUseResult lifecycle status when present.
+            status: b.is_error === true ? "error" : tur ? asString(tur.status) : null,
             ...tur ? {
-              status: asString(tur.status),
               agent_type: asString(tur.agentType),
               // Deterministic link: a Task/Agent subagent's transcript is keyed off its agentId
               // ('agent-'||agentId is the session id assigned by discover()'s filename stem).
@@ -2832,6 +2868,33 @@ function detect(db, dirty) {
   return { count, version: DETECTOR_VERSION };
 }
 
+// ../ingest/dist/errors.js
+function classifyErrors(db, dirty) {
+  const incremental = dirty != null;
+  const scope = incremental ? " AND session_id IN (SELECT id FROM _dirty_err)" : "";
+  if (incremental) {
+    db.exec("DROP TABLE IF EXISTS _dirty_err");
+    db.exec("CREATE TEMP TABLE _dirty_err (id TEXT PRIMARY KEY)");
+    const ins = db.prepare("INSERT OR IGNORE INTO _dirty_err (id) VALUES (?)");
+    db.transaction((ids) => {
+      for (const id of ids)
+        ins.run(id);
+    })(dirty);
+  }
+  const rows = db.prepare(`SELECT id, result_summary FROM tool_calls WHERE status = 'error'${scope}`).all();
+  const update = db.prepare("UPDATE tool_calls SET error_type = ? WHERE id = ?");
+  const tx = db.transaction(() => {
+    db.exec(`UPDATE tool_calls SET error_type = NULL WHERE error_type IS NOT NULL${scope}`);
+    for (const r of rows)
+      update.run(classifyToolError(r.result_summary).type, r.id);
+  });
+  tx();
+  if (incremental)
+    db.exec("DROP TABLE IF EXISTS _dirty_err");
+  const count = db.prepare("SELECT COUNT(*) n FROM tool_calls WHERE error_type IS NOT NULL").get().n;
+  return { count, version: ERROR_CLASSIFIER_VERSION };
+}
+
 // ../ingest/dist/pipeline.js
 import { createHash as createHash2 } from "crypto";
 function newStats() {
@@ -3767,6 +3830,7 @@ function runIngest(argv = process.argv.slice(2)) {
   const expanded = rebuildDerived(db, args.full ? null : dirty);
   const classified = classify(db, args.full ? null : expanded);
   const detected = detect(db, args.full ? null : expanded);
+  classifyErrors(db, args.full ? null : expanded);
   const count = (sql) => db.prepare(sql).get().n;
   const sessions = count("SELECT COUNT(*) n FROM sessions");
   const turns = count("SELECT COUNT(*) n FROM turns");
@@ -3808,8 +3872,9 @@ function runMetrics(argv = process.argv.slice(2)) {
   const db = openDb(dbPath);
   const r = classify(db);
   const d = detect(db);
+  const e = classifyErrors(db);
   db.close();
-  console.log(`agent-lens-metrics: classified=${r.count} classifier_version=${CLASSIFIER_VERSION} findings=${d.count} detector_version=${DETECTOR_VERSION} db=${dbPath}`);
+  console.log(`agent-lens-metrics: classified=${r.count} classifier_version=${CLASSIFIER_VERSION} findings=${d.count} detector_version=${DETECTOR_VERSION} errors_classified=${e.count} error_classifier_version=${e.version} db=${dbPath}`);
 }
 
 // ../server/dist/run.js
@@ -3889,6 +3954,14 @@ function listSessions(db, f) {
     where.push("s.is_sidechain = 0");
   if (f.kind === "subagent")
     where.push("s.is_sidechain = 1");
+  if (f.severity?.length) {
+    where.push(`EXISTS (SELECT 1 FROM findings fd WHERE fd.session_id = s.id AND fd.severity IN (${f.severity.map(() => "?").join(",")}))`);
+    params.push(...f.severity);
+  }
+  if (f.errorType?.length) {
+    where.push(`EXISTS (SELECT 1 FROM tool_calls tc WHERE tc.session_id = s.id AND tc.error_type IN (${f.errorType.map(() => "?").join(",")}))`);
+    params.push(...f.errorType);
+  }
   if (f.model) {
     where.push("EXISTS (SELECT 1 FROM token_usage t WHERE t.session_id = s.id AND t.model = ?)");
     params.push(f.model);
@@ -3904,7 +3977,13 @@ function listSessions(db, f) {
   const total = db.prepare(`SELECT COUNT(*) n FROM sessions s ${whereSql}`).get(...params).n;
   const baseSelect = `SELECT s.id, s.ai_title, s.slug, s.source_id, s.is_sidechain, s.started_at, s.ended_at,
               s.duration_ms, s.event_count, s.turn_count, p.path AS project_path,
-              (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
+              (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models,
+              (SELECT COUNT(*) FROM tool_calls tc WHERE tc.session_id = s.id) AS tool_call_count,
+              (SELECT COUNT(*) FROM tool_calls tc WHERE tc.session_id = s.id AND tc.status = 'error') AS tool_error_count,
+              (SELECT COUNT(*) FROM findings fd WHERE fd.session_id = s.id) AS finding_count,
+              (SELECT fd.severity FROM findings fd WHERE fd.session_id = s.id
+                 ORDER BY CASE fd.severity WHEN 'critical' THEN 4 WHEN 'high' THEN 3 WHEN 'medium' THEN 2 WHEN 'low' THEN 1 WHEN 'info' THEN 0 ELSE -1 END DESC
+                 LIMIT 1) AS worst_severity
        FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
        ${whereSql}`;
   const NATIVE_ORDER = {
@@ -3915,13 +3994,29 @@ function listSessions(db, f) {
   };
   const sortKey = f.sort ?? "started";
   const sqlDir = f.dir === "asc" ? "ASC" : "DESC";
+  const JS_SORT = /* @__PURE__ */ new Set(["tokens", "cost", "errors", "security"]);
   let rows;
-  if (sortKey === "tokens" || sortKey === "cost") {
+  if (JS_SORT.has(sortKey)) {
     const all = db.prepare(baseSelect).all(...params);
     attachSessionCost(db, all);
     const sign = f.dir === "asc" ? 1 : -1;
+    const metric = (r) => {
+      switch (sortKey) {
+        case "tokens":
+          return r.tokens;
+        case "cost":
+          return r.cost;
+        case "errors":
+          return r.tool_error_count ?? 0;
+        // Security: rank by worst severity (info=0 … critical=4; none = -1), finding count as tiebreak.
+        case "security":
+          return (severityRank(r.worst_severity ?? "") + 1) * 1e6 + (r.finding_count ?? 0);
+        default:
+          return 0;
+      }
+    };
     all.sort((a, b) => {
-      const c = (sortKey === "tokens" ? a.tokens - b.tokens : a.cost - b.cost) * sign;
+      const c = (metric(a) - metric(b)) * sign;
       return c !== 0 ? c : String(a.id).localeCompare(String(b.id));
     });
     rows = all.slice(f.offset, f.offset + f.limit);
@@ -3976,7 +4071,7 @@ function getSession(db, id) {
   const eventRows = db.prepare(`SELECT uuid, type, role, timestamp, model, is_sidechain, turn_id, raw_json
        FROM events WHERE session_id = ? ORDER BY timestamp, seq`).all(id);
   const toolRows = db.prepare(`SELECT id, event_uuid, tool_name, skill_name, skill_id, agent_type, spawned_session_id,
-              workflow_run_id, workflow_name, status,
+              workflow_run_id, workflow_name, status, error_type,
               total_duration_ms, total_tokens, input_json, result_summary,
               (SELECT COUNT(*) FROM sessions s WHERE s.workflow_run_id = tool_calls.workflow_run_id) AS workflow_agent_count
        FROM tool_calls WHERE session_id = ?`).all(id);
@@ -4106,6 +4201,10 @@ function getSession(db, id) {
        FROM tool_calls tc LEFT JOIN turns t ON t.id = tc.turn_id
        WHERE tc.session_id = ? AND tc.workflow_run_id IS NOT NULL
        ORDER BY t.seq`).all(id);
+  session.tool_call_count = toolRows.length;
+  session.tool_error_count = toolRows.filter((t) => t.status === "error").length;
+  session.tool_rejection_count = toolRows.filter((t) => t.status === "error" && t.error_type && errorKind(t.error_type) === "rejection").length;
+  session.tool_failure_count = session.tool_error_count - session.tool_rejection_count;
   return { session, turns, events, classification, parent, children, workflow_runs, findings: sessionFindings };
 }
 function xmlTag(text, tag) {
@@ -4388,6 +4487,53 @@ function pct(sorted, p) {
   const rank = Math.ceil(p / 100 * sorted.length) - 1;
   return sorted[Math.min(Math.max(rank, 0), sorted.length - 1)];
 }
+function tableExists2(db, name) {
+  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?").get(name);
+}
+function workflowWhere(f) {
+  const where = [];
+  const params = [];
+  if (f.source)
+    where.push("source_id = ?"), params.push(f.source);
+  if (f.from)
+    where.push("date(started_at) >= date(?)"), params.push(f.from);
+  if (f.to)
+    where.push("date(started_at) <= date(?)"), params.push(f.to);
+  return { sql: where.length ? `WHERE ${where.join(" AND ")}` : "", params };
+}
+function workflowAgg(db, f) {
+  const empty = { total: 0, by_status: [], completed: 0, failed: 0, success_rate: 0, total_tokens: 0, avg_duration_ms: 0 };
+  if (!tableExists2(db, "workflow_results"))
+    return empty;
+  const ww = workflowWhere(f);
+  const rows = db.prepare(`SELECT COALESCE(status, '(unknown)') status, COUNT(*) n,
+              SUM(COALESCE(total_tokens, 0)) tokens,
+              SUM(COALESCE(duration_ms, 0)) dur,
+              SUM(CASE WHEN duration_ms IS NOT NULL THEN 1 ELSE 0 END) dur_n
+       FROM workflow_results ${ww.sql} GROUP BY status ORDER BY n DESC`).all(...ww.params);
+  let total = 0, completed = 0, failed = 0, tokens = 0, durSum = 0, durN = 0;
+  const by_status = rows.map((r) => {
+    total += r.n;
+    if (r.status === "completed")
+      completed += r.n;
+    else if (r.status === "failed")
+      failed += r.n;
+    tokens += r.tokens ?? 0;
+    durSum += r.dur ?? 0;
+    durN += r.dur_n ?? 0;
+    return { status: r.status, n: r.n };
+  });
+  const decided = completed + failed;
+  return {
+    total,
+    by_status,
+    completed,
+    failed,
+    success_rate: decided ? completed / decided : 0,
+    total_tokens: tokens,
+    avg_duration_ms: durN ? Math.round(durSum / durN) : 0
+  };
+}
 function dashboardOverview(db, f) {
   const w = sessionWhere(f);
   const counts = db.prepare(`SELECT
@@ -4414,6 +4560,8 @@ function dashboardOverview(db, f) {
   const totalTokens = tokens.input + tokens.output + tokens.cache_creation + tokens.cache_read;
   const durs = db.prepare(`SELECT tn.duration_ms d FROM turns tn JOIN sessions s ON s.id = tn.session_id
          ${w.sql ? w.sql + " AND" : "WHERE"} tn.duration_ms IS NOT NULL ORDER BY tn.duration_ms`).all(...w.params).map((r) => r.d);
+  const sessDurs = db.prepare(`SELECT s.duration_ms d FROM sessions s
+         ${w.sql ? w.sql + " AND" : "WHERE"} s.is_sidechain = 0 AND s.duration_ms IS NOT NULL ORDER BY s.duration_ms`).all(...w.params).map((r) => r.d);
   return {
     range: { from: f.from ?? null, to: f.to ?? null, source: f.source ?? null },
     sessions: counts.sessions ?? 0,
@@ -4428,7 +4576,9 @@ function dashboardOverview(db, f) {
     cache_read_ratio: totalTokens ? tokens.cache_read / totalTokens : 0,
     cost: Number(cost.toFixed(4)),
     unpriced_models: [...new Set(unpriced)].sort(),
-    turn_duration_ms: { p50: pct(durs, 50), p95: pct(durs, 95), count: durs.length }
+    turn_duration_ms: { p50: pct(durs, 50), p95: pct(durs, 95), count: durs.length },
+    session_duration_ms: { p50: pct(sessDurs, 50), p95: pct(sessDurs, 95), count: sessDurs.length },
+    workflows: workflowAgg(db, f)
   };
 }
 function chooseBucket(db, f) {
@@ -4456,7 +4606,7 @@ function dashboardTimeseries(db, f, bucketParam) {
   const get = (b) => {
     let r = byBucket.get(b);
     if (!r) {
-      r = { bucket: b, ...zeroSplit(), cost: 0, sessions: 0, turns: 0 };
+      r = { bucket: b, ...zeroSplit(), cost: 0, sessions: 0, turns: 0, failures: 0, rejections: 0 };
       byBucket.set(b, r);
     }
     return r;
@@ -4479,6 +4629,16 @@ function dashboardTimeseries(db, f, bucketParam) {
     if (t.b)
       get(t.b).turns = t.n;
   }
+  for (const e of db.prepare(`SELECT ${expr} b, tc.error_type et, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} tc.status = 'error' GROUP BY b, tc.error_type`).all(...w.params)) {
+    if (!e.b)
+      continue;
+    const r = get(e.b);
+    if (e.et && errorKind(e.et) === "rejection")
+      r.rejections += e.n;
+    else
+      r.failures += e.n;
+  }
   const series = [...byBucket.values()].sort((a, b) => a.bucket.localeCompare(b.bucket));
   for (const r of series)
     r.cost = Number(r.cost.toFixed(4));
@@ -4529,7 +4689,20 @@ function dashboardBreakdowns(db, f) {
     max_per_session: counts.length ? Math.max(...counts) : 0,
     avg_per_session: counts.length ? Number((counts.reduce((a, b) => a + b, 0) / counts.length).toFixed(2)) : 0
   };
-  return { by_model: byModel, by_source: bySource, by_category: byCategory, by_complexity: byComplexity, tools, skills, skill_versions: skillVersions, subagent_fanout: subagentFanout };
+  const errorRows = db.prepare(`SELECT COALESCE(tc.error_type, 'other') type, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} tc.status = 'error' GROUP BY tc.error_type ORDER BY n DESC`).all(...w.params);
+  let failures = 0;
+  let rejections = 0;
+  const byType = errorRows.map((r) => {
+    const kind = errorKind(r.type);
+    if (kind === "rejection")
+      rejections += r.n;
+    else
+      failures += r.n;
+    return { type: r.type, kind, n: r.n };
+  });
+  const errorTypes = { by_type: byType, failures, rejections };
+  return { by_model: byModel, by_source: bySource, by_category: byCategory, by_complexity: byComplexity, tools, skills, skill_versions: skillVersions, subagent_fanout: subagentFanout, error_types: errorTypes };
 }
 
 // ../server/dist/refresh.js
@@ -4629,12 +4802,33 @@ function listMutes(db) {
   return db.prepare("SELECT rule_id, scope, scope_id, note, muted_at FROM muted_rules ORDER BY muted_at DESC").all();
 }
 
+// ../server/dist/prefs.js
+var PREFS_SCHEMA_SQL = (
+  /* sql */
+  `
+CREATE TABLE IF NOT EXISTS ui_prefs (
+  key        TEXT PRIMARY KEY,   -- e.g. 'dashboard.charts', 'sessions.columns'
+  value      TEXT NOT NULL,      -- JSON blob, opaque to the server
+  updated_at TEXT NOT NULL
+);
+`
+);
+function getPref(db, key) {
+  const row = db.prepare("SELECT value FROM ui_prefs WHERE key = ?").get(key);
+  return row ? row.value : null;
+}
+function setPref(db, key, value) {
+  db.prepare(`INSERT INTO ui_prefs (key, value, updated_at) VALUES (?, ?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
+}
+
 // ../server/dist/app.js
 async function createApp(db, opts = {}) {
   const app = Fastify({ logger: false });
   let triageDb = null;
   if (opts.triageDbPath) {
     triageDb = openTriage(opts.triageDbPath);
+    triageDb.exec(PREFS_SCHEMA_SQL);
     db.exec(`ATTACH DATABASE '${opts.triageDbPath.replace(/'/g, "''")}' AS triage`);
     app.addHook("onClose", async () => triageDb?.close());
   }
@@ -4681,6 +4875,26 @@ async function createApp(db, opts = {}) {
     return dashboardTimeseries(db, dashFilters(req), q.bucket);
   });
   app.get("/api/dashboard/breakdowns", async (req) => dashboardBreakdowns(db, dashFilters(req)));
+  const PREF_KEY = /^[a-z0-9._-]{1,64}$/i;
+  app.get("/api/prefs/:key", async (req, reply) => {
+    const { key } = req.params;
+    if (!PREF_KEY.test(key))
+      return reply.code(400).send({ error: { code: "BAD_KEY", message: "invalid pref key" } });
+    if (!triageDb)
+      return { value: null };
+    const raw = getPref(triageDb, key);
+    return { value: raw == null ? null : JSON.parse(raw) };
+  });
+  app.put("/api/prefs/:key", async (req, reply) => {
+    const { key } = req.params;
+    if (!PREF_KEY.test(key))
+      return reply.code(400).send({ error: { code: "BAD_KEY", message: "invalid pref key" } });
+    if (!guardWrite(req, reply))
+      return;
+    const body = req.body;
+    setPref(triageDb, key, JSON.stringify(body?.value ?? null));
+    return { ok: true };
+  });
   app.get("/api/sessions", async (req) => {
     const q = req.query;
     return listSessions(db, {
@@ -4691,7 +4905,9 @@ async function createApp(db, opts = {}) {
       from: q.from,
       to: q.to,
       kind: q.kind === "main" || q.kind === "subagent" ? q.kind : void 0,
-      sort: ["started", "title", "turns", "tokens", "cost", "duration"].find((s) => s === q.sort),
+      severity: q.severity ? q.severity.split(",").filter(Boolean) : void 0,
+      errorType: q.error_type ? q.error_type.split(",").filter(Boolean) : void 0,
+      sort: ["started", "title", "turns", "tokens", "cost", "duration", "errors", "security"].find((s) => s === q.sort),
       dir: q.dir === "asc" ? "asc" : q.dir === "desc" ? "desc" : void 0,
       limit: Math.min(Number(q.limit) || 50, 200),
       offset: Number(q.offset) || 0