agent-inspect 4.1.0 → 4.3.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 4.3.0
+
+### Minor Changes
+
+- 8a21bce: Add share-safe offline trace bundles (`agent-inspect bundle`) with automatic verify-safe, default share redaction profile, session/since targeting, and folder output for PR-ready evidence.
+
+## 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

@@ -37,12 +37,13 @@ Core commands:
 - `scan` — best-effort local safety scan for trace capture risks
 - `verify-safe` — best-effort local trace safety verification
 - `artifacts` — create safe local CI trace artifact bundles and optional step summaries
+- `bundle` — create share-safe offline trace bundles (redacted copies + verify-safe)
 - `ci-summary` — summarize local reporter artifact manifests for CI
 - `diff` — compare two manual traces (local, read-only)
 - `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 +682,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`
@@ -849,6 +861,38 @@ agent-inspect index sqlite clean [--dir <path>] [--json]
 
 If `@agent-inspect/index-sqlite` is not installed, these subcommands print a short install hint and exit non-zero.
 
+### 6.24 `bundle`
+
+Create a **share-safe offline trace bundle** as a local folder (v4.3+). Bundles are derived copies: original traces are read-only and never mutated. Automatic `verify-safe` runs before write; the command fails on `UNSAFE` unless `--allow-unsafe`. See [BUNDLES.md](BUNDLES.md).
+
+```bash
+agent-inspect bundle <run-id> [options]
+agent-inspect bundle --session <session-id> [options]
+agent-inspect bundle --since <duration> [options]
+```
+
+Options:
+
+- `--dir <path>` — trace directory
+- `--session <session-id>` — bundle all runs in a session
+- `--since <duration>` — bundle runs with activity since a window (e.g. `24h`, `7d`)
+- `--profile <profile>` — `local`, `share` (default), or `strict` redaction for exported copies
+- `--out <path>` — output directory; `.zip` suffix is stripped (folder-first)
+- `--allow-unsafe` — write bundle even when verify-safe reports UNSAFE
+- `--json` — print deterministic JSON manifest
+
+Output includes `trace.html`, `trace.jsonl`, `summary.md`, `metadata.json`, `check-results.json`, `redaction-report.json`, and `assets/runs/` mirrors for multi-run bundles.
+
+Examples:
+
+```bash
+npx agent-inspect bundle minimal-success --dir fixtures/traces --out ./bundle-out
+npx agent-inspect bundle --session sess-handoff-001 --dir ./.agent-inspect --profile strict
+npx agent-inspect bundle --since 24h --dir ./.agent-inspect --json
+```
+
+Recipe: [shareable-bundle-basic](../examples/recipes/shareable-bundle-basic/README.md).
+
 ## 7. Optional TUI behavior
 
 `view --tui` delegates to `@agent-inspect/tui` and requires an interactive terminal. If the package is not installed, the CLI prints a short install hint.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-inspect",
-  "version": "4.1.0",
+  "version": "4.3.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-BS5LSKZ3.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 };
@@ -3022,12 +3268,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path5 = [];
+  const path6 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path5.push({
+    path6.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -3052,7 +3298,7 @@ function buildCriticalPath(runs, handoffs) {
     const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
     pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
   }
-  return path5;
+  return path6;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -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,190 @@ 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
+// packages/core/src/bundle/resolve.ts
+function parseSinceCutoff(since) {
+  const trimmed = since.trim();
+  if (trimmed === "") {
+    throw new Error("--since requires a non-empty duration (e.g. 24h, 7d).");
+  }
+  return Date.now() - parseDuration(trimmed);
+}
+function runActivityMs(run) {
+  if (run.startedAt !== void 0 && Number.isFinite(run.startedAt)) return run.startedAt;
+  if (run.endedAt !== void 0 && Number.isFinite(run.endedAt)) return run.endedAt;
+  return void 0;
+}
+function runsInSinceWindow(runs, since) {
+  const cutoff = parseSinceCutoff(since);
+  const ids = [];
+  for (const run of runs) {
+    const activity = runActivityMs(run);
+    if (activity !== void 0 && activity >= cutoff) {
+      ids.push(run.runId);
+    }
+  }
+  return ids.sort((a, b) => a.localeCompare(b));
+}
+function findSession(index, sessionId) {
+  return index.sessions.find((session) => session.sessionId === sessionId);
+}
+function resolveBundleRunIds(index, runs, options) {
+  const runId = options.runId?.trim();
+  const sessionId = options.sessionId?.trim();
+  const since = options.since?.trim();
+  const modes = [runId ? 1 : 0, sessionId ? 1 : 0, since ? 1 : 0].reduce((a, b) => a + b, 0);
+  if (modes === 0) {
+    throw new Error(
+      "bundle requires a run id, --session <sessionId>, or --since <duration>."
+    );
+  }
+  if (modes > 1) {
+    throw new Error(
+      "bundle accepts only one target: a run id, --session, or --since (not combined)."
+    );
+  }
+  if (runId) {
+    const known = runs.some((run) => run.runId === runId);
+    if (!known) {
+      throw new Error(`Run "${runId}" was not found in the trace directory.`);
+    }
+    return { runIds: [runId] };
+  }
+  if (sessionId) {
+    const session = findSession(index, sessionId);
+    if (!session) {
+      throw new Error(`Session "${sessionId}" was not found.`);
+    }
+    if (session.runIds.length === 0) {
+      throw new Error(`Session "${sessionId}" has no runs to bundle.`);
+    }
+    return {
+      runIds: [...session.runIds].sort((a, b) => a.localeCompare(b)),
+      sessionId
+    };
+  }
+  const runIds = runsInSinceWindow(runs, since);
+  if (runIds.length === 0) {
+    throw new Error(`No runs matched --since ${since}.`);
+  }
+  return { runIds, since };
+}
+
+// packages/core/src/bundle/safety-status.ts
+function aggregateBundleSafeStatus(statuses) {
+  if (statuses.length === 0) return "UNKNOWN";
+  if (statuses.some((status) => status === "UNSAFE")) return "UNSAFE";
+  if (statuses.some((status) => status === "UNKNOWN")) return "UNKNOWN";
+  if (statuses.some((status) => status === "SAFE WITH WARNINGS")) return "SAFE WITH WARNINGS";
+  return "SAFE";
+}
+function toMetadataSafeStatus(status) {
+  if (status === "SAFE WITH WARNINGS") return "SAFE_WITH_WARNINGS";
+  return status;
+}
+function bundleFailsOnSafety(status, allowUnsafe) {
+  if (allowUnsafe) return false;
+  return status === "UNSAFE" || status === "UNKNOWN";
+}
+
+// packages/core/src/bundle/manifest.ts
+var BUNDLE_NOTE = "Generated locally by AgentInspect. Bundles are derived copies for review \u2014 not compliance or security certification. Review before sharing.";
+var PLACEHOLDER_NOTE = "No eval or performance artifacts were requested for this bundle.";
+function buildBundleMetadata(parts) {
+  const aggregate = aggregateBundleSafeStatus(
+    parts.checks.runs.map((run) => run.status)
+  );
+  return {
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    agentInspectVersion: parts.agentInspectVersion,
+    redactionProfile: parts.profile,
+    sourceTraceCount: parts.resolve.runIds.length,
+    runIds: [...parts.resolve.runIds],
+    safeStatus: toMetadataSafeStatus(aggregate),
+    files: [...parts.files].sort((a, b) => a.localeCompare(b)),
+    note: BUNDLE_NOTE,
+    ...parts.resolve.sessionId !== void 0 ? { sessionId: parts.resolve.sessionId } : {},
+    ...parts.resolve.since !== void 0 ? { since: parts.resolve.since } : {}
+  };
+}
+function buildPlaceholderArtifact() {
+  return {
+    status: "not_requested",
+    note: PLACEHOLDER_NOTE
+  };
+}
+
+// packages/core/src/bundle/summary.ts
+function markdownTable(rows) {
+  const lines = ["| Field | Value |", "| --- | --- |"];
+  for (const [key, value] of rows) {
+    lines.push(`| ${key} | ${value ?? "unknown"} |`);
+  }
+  return lines.join("\n");
+}
+function buildBundleSummaryMarkdown(parts) {
+  const { metadata, checks, redaction } = parts;
+  const lines = [
+    "# AgentInspect trace bundle",
+    "",
+    metadata.note,
+    "",
+    "## Overview",
+    "",
+    markdownTable([
+      ["Created", metadata.createdAt],
+      ["AgentInspect", metadata.agentInspectVersion],
+      ["Redaction profile", metadata.redactionProfile],
+      ["Safe status", metadata.safeStatus],
+      ["Source traces", metadata.sourceTraceCount],
+      ["Runs", metadata.runIds.join(", ")],
+      ...metadata.sessionId ? [["Session", metadata.sessionId]] : [],
+      ...metadata.since ? [["Since", metadata.since]] : []
+    ]),
+    "",
+    "## Safety checks",
+    "",
+    `Aggregate: **${checks.aggregateStatus}**`,
+    ""
+  ];
+  for (const run of checks.runs) {
+    lines.push(
+      `- \`${run.runId}\`: ${run.status} (${run.findings} finding(s), ${run.errors} error(s), ${run.warnings} warning(s))`
+    );
+  }
+  lines.push("", "## Redaction", "", `Total findings: ${redaction.totalFindings}`, "");
+  for (const run of redaction.runs) {
+    const detectors = run.detectors.length > 0 ? run.detectors.join(", ") : "none";
+    lines.push(`- \`${run.runId}\`: ${run.findings} finding(s); detectors: ${detectors}`);
+  }
+  lines.push(
+    "",
+    "## Files",
+    "",
+    ...metadata.files.map((file) => `- \`${file}\``),
+    "",
+    "_Review every generated artifact before sharing outside your team._",
+    ""
+  );
+  return lines.join("\n");
+}
+function normalizeBundleOutputPath(out) {
+  const trimmed = out.trim();
+  if (trimmed === "") {
+    throw new Error("--out requires a non-empty path.");
+  }
+  const resolved = path.resolve(trimmed);
+  if (resolved.toLowerCase().endsWith(".zip")) {
+    return resolved.slice(0, -4);
+  }
+  return resolved;
+}
+function defaultBundleOutputPath(runIds) {
+  const label = runIds.length === 1 ? runIds[0] : `multi-${runIds.length}`;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return path.resolve(`agent-inspect-bundle-${label}-${stamp}`);
+}
+
+export { Redactor, TraceDirectory, __commonJS, __require, __toESM, aggregateBundleSafeStatus, aggregateSessionCheckResults, applyProfileMetadataCaps, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildLocalExplanation, buildPlaceholderArtifact, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, bundleFailsOnSafety, defaultBundleOutputPath, enrichSessionRunRecord, extractCorrelationMetadata, extractMetadata, filterMetasBySessionScope, filterTraces, formatDuration2 as formatDuration, formatTimestamp, getIndent, getTraceFilePath, isAgentInspectTrace, isPersistedInspectEvent, loadSessionRunRecords, loadTraceMetadataList, nanoid, normalizeBundleOutputPath, parseDuration, parseDurationFilter, parseTraceJsonl, persistedInspectEventsToTraceEvents, renderActivitySummaryHuman, renderErrorLine, renderRunWhat, renderStepLine, renderTimeline, renderTraceStats, resolveBundleRunIds, resolveRedactionProfile, resolveTraceDir, searchTraces, source_default, truncateName, truncateStringForProfile, validateEvent };
+//# sourceMappingURL=chunk-BS5LSKZ3.mjs.map
+//# sourceMappingURL=chunk-BS5LSKZ3.mjs.map