@swestash/agent-lens 0.5.4 → 0.6.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) {
@@ -4456,7 +4555,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 +4578,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 +4638,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
@@ -4691,7 +4813,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