agent-inspect 4.1.0 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 4.2.0
+
+### Minor Changes
+
+- Add sessions and activity as first-class local concepts (v4.2).
+
+  - Derive session status, timing, last error, and retry counts on enriched `SessionSummary` (builds on v2.4 vocabulary; no timestamp-only causality).
+  - Add `buildActivitySummary` for windowed activity feeds.
+  - Expand CLI: `sessions latest`, `activity`, `show`, `handoffs`, `errors` (bare `sessions` list and `session <id>` unchanged).
+  - Optional SQLite index acceleration for session loading with automatic scan fallback when the index is absent, stale, or corrupt.
+  - Docs: CLI reference update.
+
 ## 4.1.0
 
 ### Minor Changes

package/docs/CLI.md

@@ -42,7 +42,7 @@ Core commands:
 - `timeline` — chronological view of one run (local JSONL)
 - `stats` — local aggregate stats over a trace directory
 - `search` — deterministic local search over traces
-- `sessions` — list workflow sessions from trace metadata
+- `sessions` — list workflow sessions; v4.2+ subcommands: `latest`, `activity`, `show`, `handoffs`, `errors`
 - `session` — inspect one session (handoffs, retries, optional timeline)
 - `what` — concise summary of a single run (local JSONL)
 - `report` — markdown or HTML inspection report for a single run
@@ -681,23 +681,34 @@ npx agent-inspect search --session sess-retry-001 --dir ./.agent-inspect
 
 ### 6.19 `sessions`
 
-List workflow sessions grouped from local trace metadata (`sessionId`, optional `groupId` correlation). Read-only; no network.
+Workflow sessions and activity from local trace metadata. v4.2 adds session status, activity summaries, and optional SQLite index acceleration (falls back to directory scan). Read-only; no network.
 
 ```bash
-agent-inspect sessions [options]
+agent-inspect sessions [options]                    # list sessions (default)
+agent-inspect sessions latest [--json]
+agent-inspect sessions activity [--since 7d] [--json]
+agent-inspect sessions show <session-id> [--timeline] [--json]
+agent-inspect sessions handoffs [--session <id>] [--json]
+agent-inspect sessions errors [--since 7d] [--json]
 ```
 
-Options:
+Shared options:
 
 - `--dir <path>`
 - `--correlate-group` — treat shared `groupId` as a synthetic session when `sessionId` is absent
-- `--json` — `SessionIndex` JSON (`sessions`, `unscopedRunIds`, `warnings`)
+- `--stale-after <duration>` — mark sessions stale after inactivity (e.g. `24h`, `7d`)
+- `--json` — deterministic JSON output
+
+`activity` and `errors` accept `--since <duration>` (e.g. `7d`, `24h`). Session summaries include derived `status`, `lastActivity`, `lastError`, and `retryCount` without changing trace files.
 
 Example:
 
 ```bash
 npx agent-inspect sessions --dir ./.agent-inspect
-npx agent-inspect sessions --json
+npx agent-inspect sessions latest --json
+npx agent-inspect sessions activity --since 7d
+npx agent-inspect sessions handoffs --session sess-handoff-001
+npx agent-inspect sessions errors --since 30d --json
 ```
 
 ### 6.20 `session`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-inspect",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "license": "MIT",
   "type": "module",
   "description": "Trace, check, and safely share TypeScript AI-agent runs locally — no account, no upload, metadata-only by default",

package/packages/cli/dist/{chunk-MT5G7JFO.mjs → chunk-5VSPJEZ7.mjs}

@@ -2714,6 +2714,95 @@ async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
   return metas;
 }
 
+// packages/core/src/sessions/activity.ts
+function statusLine(session) {
+  const name = session.workflowId ?? session.correlationId ?? session.sessionId;
+  const status = session.status;
+  if (session.lastError) {
+    return `${name} session ${session.sessionId} failed at ${session.lastError.message}`;
+  }
+  if (session.observationSummary) {
+    return `${name} session ${session.sessionId} ${status} with observation warning`;
+  }
+  return `${name} session ${session.sessionId} ${status}`;
+}
+function parseSinceMs(since, nowMs) {
+  if (!since || since.trim() === "") return nowMs - 7 * 864e5;
+  const trimmed = since.trim().toLowerCase();
+  const match = /^(\d+)([smhd])$/.exec(trimmed);
+  if (!match) return nowMs - 7 * 864e5;
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return nowMs - amount * mult;
+}
+function isFailed(status) {
+  return status === "error";
+}
+function isStale(status) {
+  return status === "stale";
+}
+function guardrailWarnings(session) {
+  const summary = session.checkSummary;
+  if (!summary) return 0;
+  return summary.warn;
+}
+function buildActivitySummary(index, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  const sinceMs = parseSinceMs(options.since, nowMs);
+  const sinceIso = new Date(sinceMs).toISOString();
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 20;
+  const inWindow = index.sessions.filter((session) => {
+    const activityMs2 = Date.parse(session.lastActivity);
+    return Number.isFinite(activityMs2) && activityMs2 >= sinceMs;
+  });
+  const entries = [...inWindow].sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)).slice(0, limit).map((session) => ({
+    sessionId: session.sessionId,
+    status: session.status,
+    summary: statusLine(session),
+    lastActivity: session.lastActivity,
+    runCount: session.runIds.length
+  }));
+  let failed = 0;
+  let stale = 0;
+  let guardrailWarningTotal = 0;
+  for (const session of inWindow) {
+    if (isFailed(session.status)) failed += 1;
+    if (isStale(session.status)) stale += 1;
+    guardrailWarningTotal += guardrailWarnings(session);
+  }
+  return {
+    since: sinceIso,
+    sessions: inWindow.length,
+    failed,
+    stale,
+    guardrailWarnings: guardrailWarningTotal,
+    entries
+  };
+}
+function renderActivitySummaryHuman(summary) {
+  const lines = [];
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  const todayMs = todayStart.getTime();
+  const today = summary.entries.filter(
+    (entry) => Date.parse(entry.lastActivity) >= todayMs
+  );
+  if (today.length > 0) {
+    lines.push("Today");
+    for (const entry of today) {
+      lines.push(`  ${entry.summary}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Since ${summary.since}`);
+  lines.push(`  ${summary.sessions} sessions`);
+  lines.push(`  ${summary.failed} failed`);
+  lines.push(`  ${summary.stale} stale`);
+  lines.push(`  ${summary.guardrailWarnings} guardrail warnings`);
+  return lines.join("\n");
+}
+
 // packages/core/src/sessions/load.ts
 async function enrichSessionRunRecord(meta) {
   let metadata;
@@ -2802,6 +2891,163 @@ function sessionKeyForRun(meta, options) {
   return void 0;
 }
 
+// packages/core/src/sessions/status.ts
+var DEFAULT_STALE_THRESHOLD_MS = 864e5;
+var EXPLICIT_STATUS_PRIORITY = {
+  error: 5,
+  waiting_input: 4,
+  idle: 3,
+  stale: 2,
+  completed: 1
+};
+var EXPLICIT_SESSION_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "waiting_input",
+  "idle",
+  "completed",
+  "error",
+  "stale",
+  "unknown"
+]);
+function isExplicitSessionStatus(value) {
+  return typeof value === "string" && EXPLICIT_SESSION_STATUSES.has(value);
+}
+function activityMs(run) {
+  return run.endedAt ?? run.startedAt ?? 0;
+}
+function latestActivityMs(runs) {
+  let latest = 0;
+  for (const run of runs) {
+    const ms = activityMs(run);
+    if (ms > latest) latest = ms;
+  }
+  return latest;
+}
+function earliestStart(runs) {
+  let earliest;
+  for (const run of runs) {
+    if (run.startedAt === void 0) continue;
+    if (earliest === void 0 || run.startedAt < earliest) {
+      earliest = run.startedAt;
+    }
+  }
+  return earliest;
+}
+function latestEndWhenAllEnded(runs) {
+  if (runs.length === 0) return void 0;
+  let latest;
+  for (const run of runs) {
+    if (run.endedAt === void 0) return void 0;
+    if (latest === void 0 || run.endedAt > latest) latest = run.endedAt;
+  }
+  return latest;
+}
+function pickExplicitStatus(runs) {
+  let best;
+  let bestPriority = 0;
+  for (const run of runs) {
+    const raw = run.metadata?.sessionStatus;
+    if (!isExplicitSessionStatus(raw)) continue;
+    const priority = EXPLICIT_STATUS_PRIORITY[raw] ?? 0;
+    if (priority > bestPriority) {
+      bestPriority = priority;
+      best = raw;
+    }
+  }
+  return best;
+}
+function deriveLastError(runs) {
+  const errorRuns = runs.filter((run) => run.status === "error").sort((a, b) => activityMs(b) - activityMs(a));
+  const latest = errorRuns[0];
+  if (!latest) return void 0;
+  const meta = latest.metadata ?? {};
+  const message = typeof meta.errorMessage === "string" && meta.errorMessage.trim() !== "" ? meta.errorMessage.trim() : latest.name ?? latest.runId;
+  const code = typeof meta.errorCode === "string" && meta.errorCode.trim() !== "" ? meta.errorCode.trim() : void 0;
+  return { runId: latest.runId, message, code };
+}
+function deriveCheckSummary(runs) {
+  let pass = 0;
+  let fail = 0;
+  let warn2 = 0;
+  let found = false;
+  for (const run of runs) {
+    const summary = run.metadata?.checkSummary;
+    if (!summary || typeof summary !== "object") continue;
+    const record = summary;
+    if (typeof record.pass === "number") {
+      pass += record.pass;
+      found = true;
+    }
+    if (typeof record.fail === "number") {
+      fail += record.fail;
+      found = true;
+    }
+    if (typeof record.warn === "number") {
+      warn2 += record.warn;
+      found = true;
+    }
+  }
+  return found ? { pass, fail, warn: warn2 } : void 0;
+}
+function deriveObservationSummary(runs) {
+  for (const run of [...runs].sort((a, b) => activityMs(b) - activityMs(a))) {
+    const value = run.metadata?.observationSummary;
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function deriveSessionStatus(runs, options = {}) {
+  if (runs.length === 0) return "unknown";
+  if (runs.some((run) => run.status === "running")) return "running";
+  const explicit = pickExplicitStatus(runs);
+  if (explicit && explicit !== "running") return explicit;
+  if (runs.some((run) => run.status === "error")) return "error";
+  if (runs.every((run) => run.status === "success")) return "completed";
+  const nowMs = options.nowMs ?? Date.now();
+  const staleThresholdMs = options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+  const lastMs = latestActivityMs(runs);
+  if (lastMs > 0 && nowMs - lastMs > staleThresholdMs) return "stale";
+  return "unknown";
+}
+function enrichSessionSummary(summary, runs, options = {}) {
+  const sessionRuns = runs.filter((run) => summary.runIds.includes(run.runId)).sort((a, b) => a.runId.localeCompare(b.runId));
+  const startedAt = earliestStart(sessionRuns);
+  const endedAt = latestEndWhenAllEnded(sessionRuns);
+  const durationMs = startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0;
+  let correlationId;
+  let jobId;
+  let workflowId;
+  for (const run of sessionRuns) {
+    const meta = extractSessionWorkflowMetadata(run.metadata);
+    if (!correlationId && meta?.correlationId) correlationId = meta.correlationId;
+    if (!jobId && meta?.jobId) jobId = meta.jobId;
+    if (!workflowId && meta?.workflowName) workflowId = meta.workflowName;
+    else if (!workflowId && meta?.workflowStep) workflowId = meta.workflowStep;
+  }
+  const lastMs = latestActivityMs(sessionRuns);
+  const lastActivity = lastMs > 0 ? new Date(lastMs).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+  const retryCount = summary.retries.filter(
+    (retry) => retry.retryOf !== void 0 || (retry.attempt ?? 0) > 1
+  ).length;
+  return {
+    ...summary,
+    status: deriveSessionStatus(sessionRuns, options),
+    startedAt,
+    endedAt,
+    durationMs,
+    correlationId,
+    jobId,
+    workflowId,
+    lastError: deriveLastError(sessionRuns),
+    lastActivity,
+    retryCount,
+    observationSummary: deriveObservationSummary(sessionRuns),
+    checkSummary: deriveCheckSummary(sessionRuns)
+  };
+}
+
 // packages/core/src/sessions/checks.ts
 function emptySummary() {
   return { passed: 0, failed: 0, warnings: 0, errors: 0 };
@@ -3094,14 +3340,21 @@ function buildSessionIndex(inputRuns, options = {}) {
         sessionId
       });
     }
-    return {
-      sessionId,
-      runIds,
-      groups,
-      handoffs,
-      retries,
-      criticalPath
-    };
+    return enrichSessionSummary(
+      {
+        sessionId,
+        runIds,
+        groups,
+        handoffs,
+        retries,
+        criticalPath
+      },
+      runs,
+      {
+        nowMs: options.nowMs,
+        staleThresholdMs: options.staleThresholdMs
+      }
+    );
   });
   if (sessions.length === 0 && runs.length > 0) {
     warnings.push({
@@ -3229,6 +3482,6 @@ async function isAgentInspectTrace(filePath) {
   }
 }
 
-export { Redactor, TraceDirectory, __commonJS, __require, __toESM, aggregateSessionCheckResults, applyProfileMetadataCaps, buildLocalExplanation, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, extractCorrelationMetadata, extractMetadata, filterMetasBySessionScope, filterTraces, formatDuration2 as formatDuration, formatTimestamp, getIndent, getTraceFilePath, isAgentInspectTrace, isPersistedInspectEvent, loadSessionRunRecords, loadTraceMetadataList, nanoid, parseDuration, parseDurationFilter, parseTraceJsonl, persistedInspectEventsToTraceEvents, renderErrorLine, renderRunWhat, renderStepLine, renderTimeline, renderTraceStats, resolveRedactionProfile, resolveTraceDir, searchTraces, source_default, truncateName, truncateStringForProfile, validateEvent };
-//# sourceMappingURL=chunk-MT5G7JFO.mjs.map
-//# sourceMappingURL=chunk-MT5G7JFO.mjs.map
+export { Redactor, TraceDirectory, __commonJS, __require, __toESM, aggregateSessionCheckResults, applyProfileMetadataCaps, buildActivitySummary, buildLocalExplanation, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, enrichSessionRunRecord, extractCorrelationMetadata, extractMetadata, filterMetasBySessionScope, filterTraces, formatDuration2 as formatDuration, formatTimestamp, getIndent, getTraceFilePath, isAgentInspectTrace, isPersistedInspectEvent, loadSessionRunRecords, loadTraceMetadataList, nanoid, parseDuration, parseDurationFilter, parseTraceJsonl, persistedInspectEventsToTraceEvents, renderActivitySummaryHuman, renderErrorLine, renderRunWhat, renderStepLine, renderTimeline, renderTraceStats, resolveRedactionProfile, resolveTraceDir, searchTraces, source_default, truncateName, truncateStringForProfile, validateEvent };
+//# sourceMappingURL=chunk-5VSPJEZ7.mjs.map
+//# sourceMappingURL=chunk-5VSPJEZ7.mjs.map