@nexrall/code-core 1.4.76 → 1.4.77

package/dist/events/recap.d.ts

@@ -0,0 +1,54 @@
+import type { SessionEvent } from './sessionEvents';
+/** Claude Code's cap, and its cut: at a word boundary, never mid-word. */
+export declare const RECAP_MAX_CHARS = 400;
+/**
+ * How many event rows the callers read. A bounded TAIL on purpose: a recap is
+ * "where you left off", and the newest rows are the ones that describe that.
+ */
+export declare const RECAP_EVENT_WINDOW = 500;
+export interface RecapOpts {
+    now: number;
+    /** Tests (and future callers) may lower the cap; the default is CC's 400. */
+    maxChars?: number;
+}
+/** `2h ago` / `just now` — coarse on purpose; the recap is a pointer, not a clock. */
+export declare function agoLabel(ms: number): string;
+/**
+ * The hard cap from the feature spec: over `max`, cut at the LAST space so a
+ * word is never sliced in half, then mark it. The returned string is always
+ * ≤ `max` characters.
+ */
+export declare function capRecap(text: string, max?: number): string;
+/**
+ * One line of "where this session left off", or null when the window holds
+ * nothing worth saying (callers print an honest empty state for `/recap` and
+ * stay silent for the automatic one).
+ *
+ * The shape, fixed so the tests can pin it exactly:
+ *   you asked "…" · 5 turns · 12 tool calls · files: a.ts, b.ts (+2 more) ·
+ *   last action: edit_file src/a.ts · last activity 2h ago
+ *
+ * Rules that matter:
+ *   · the LAST prompt wins ("you asked" means the most recent question);
+ *   · files are the last two UNIQUE paths — where you left off, not where you
+ *     started — with a (+n more) tail so the count is never silently trimmed;
+ *   · malformed rows are ignored, never thrown over (a torn log must not break
+ *     a session start);
+ *   · the finished line goes through capRecap, so the 400-char bound holds
+ *     even for a pathological window.
+ */
+export declare function buildRecap(events: SessionEvent[], opts: RecapOpts): string | null;
+/**
+ * Whether the automatic recap prints after `--resume`/`--continue`.
+ * Default ON (CC parity). The env var decides first — `0`/`false`/`off` force
+ * it off, `1`/`true` force it on — then the `autoRecap` setting in
+ * settings.json. For the SETTING only the off direction needs spellings: any
+ * truthy value means "on", which is also the default, so accepting `false`,
+ * the string `"false"`, `"0"` and `"off"` as off is the user-friendly reading
+ * and cannot surprise anyone who did not touch the key.
+ */
+export declare function resolveAutoRecap(f: {
+    env?: Record<string, string | undefined>;
+    setting?: unknown;
+}): boolean;
+//# sourceMappingURL=recap.d.ts.map

package/dist/events/recap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recap.d.ts","sourceRoot":"","sources":["../../src/events/recap.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,0EAA0E;AAC1E,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAO3C;AAWD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAkB,GAAG,MAAM,CAOpE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAwDjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAQ5G"}

package/dist/events/recap.js

@@ -0,0 +1,161 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/recap.ts, 2026-10-04): the VS Code
+// panel rebuilds the same recap from the same event log.
+// S19a — `/recap` and the automatic recap when a session is resumed.
+//
+// Claude Code parity (2.1.x): returning to a session shows a short recap of
+// where it left off, capped at 400 characters on a word boundary, and `/recap`
+// prints it on demand. Ours is rebuilt from the §92 event log we already write
+// — no model call, no cost — and it cannot invent anything that did not happen:
+// the prompt it reads back is the one the log recorded, the counts are counts.
+//
+// Pure (no console, no fs) so the composition and capping rules are unit-
+// testable — see test/recap.test.ts. The callers own the I/O: chat.ts reads
+// the tail of the session's log and prints the line.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECAP_EVENT_WINDOW = exports.RECAP_MAX_CHARS = void 0;
+exports.agoLabel = agoLabel;
+exports.capRecap = capRecap;
+exports.buildRecap = buildRecap;
+exports.resolveAutoRecap = resolveAutoRecap;
+/** Claude Code's cap, and its cut: at a word boundary, never mid-word. */
+exports.RECAP_MAX_CHARS = 400;
+/**
+ * How many event rows the callers read. A bounded TAIL on purpose: a recap is
+ * "where you left off", and the newest rows are the ones that describe that.
+ */
+exports.RECAP_EVENT_WINDOW = 500;
+/** `2h ago` / `just now` — coarse on purpose; the recap is a pointer, not a clock. */
+function agoLabel(ms) {
+    if (!Number.isFinite(ms) || ms < 60000)
+        return 'just now';
+    const m = Math.floor(ms / 60000);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+/** Collapse whitespace and cut to `max` at a word boundary (an ellipsis marks the cut). */
+function clipWords(text, max) {
+    const t = text.replace(/\s+/g, ' ').trim();
+    if (t.length <= max)
+        return t;
+    const cut = t.slice(0, Math.max(1, max - 1));
+    const sp = cut.lastIndexOf(' ');
+    return (sp > 0 ? cut.slice(0, sp) : cut).replace(/[ ,;:·]+$/, '') + '…';
+}
+/**
+ * The hard cap from the feature spec: over `max`, cut at the LAST space so a
+ * word is never sliced in half, then mark it. The returned string is always
+ * ≤ `max` characters.
+ */
+function capRecap(text, max = exports.RECAP_MAX_CHARS) {
+    if (max <= 0)
+        return '';
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max - 1);
+    const sp = cut.lastIndexOf(' ');
+    const body = (sp > 0 ? cut.slice(0, sp) : cut).replace(/[ ,;:·]+$/, '');
+    return body + '…';
+}
+/**
+ * One line of "where this session left off", or null when the window holds
+ * nothing worth saying (callers print an honest empty state for `/recap` and
+ * stay silent for the automatic one).
+ *
+ * The shape, fixed so the tests can pin it exactly:
+ *   you asked "…" · 5 turns · 12 tool calls · files: a.ts, b.ts (+2 more) ·
+ *   last action: edit_file src/a.ts · last activity 2h ago
+ *
+ * Rules that matter:
+ *   · the LAST prompt wins ("you asked" means the most recent question);
+ *   · files are the last two UNIQUE paths — where you left off, not where you
+ *     started — with a (+n more) tail so the count is never silently trimmed;
+ *   · malformed rows are ignored, never thrown over (a torn log must not break
+ *     a session start);
+ *   · the finished line goes through capRecap, so the 400-char bound holds
+ *     even for a pathological window.
+ */
+function buildRecap(events, opts) {
+    let prompt = null;
+    let turns = 0;
+    let tools = 0;
+    let lastTool = null;
+    const files = [];
+    let lastTs = null;
+    for (const ev of events) {
+        if (typeof ev?.ts === 'number' && Number.isFinite(ev.ts)) {
+            lastTs = lastTs === null ? ev.ts : Math.max(lastTs, ev.ts);
+        }
+        switch (ev?.type) {
+            case 'message.started':
+                if (typeof ev.text === 'string' && ev.text.trim())
+                    prompt = ev.text.trim();
+                break;
+            case 'message.completed':
+                turns++;
+                break;
+            case 'tool.started': {
+                tools++;
+                const name = typeof ev.name === 'string' && ev.name.trim() ? ev.name.trim() : 'tool';
+                const target = typeof ev.target === 'string' && ev.target.trim() ? ev.target.trim() : null;
+                lastTool = { name, target };
+                break;
+            }
+            case 'file.changed': {
+                const p = typeof ev.path === 'string' ? ev.path.trim() : '';
+                if (p && !files.includes(p))
+                    files.push(p);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (!prompt && turns === 0 && tools === 0)
+        return null;
+    const segments = [];
+    if (prompt)
+        segments.push(`you asked "${clipWords(prompt, 140)}"`);
+    if (turns > 0 || tools > 0) {
+        segments.push(`${turns} turn${turns === 1 ? '' : 's'}`, `${tools} tool call${tools === 1 ? '' : 's'}`);
+    }
+    if (files.length) {
+        const shown = files.slice(-2).join(', ');
+        const more = files.length > 2 ? ` (+${files.length - 2} more)` : '';
+        segments.push(`files: ${shown}${more}`);
+    }
+    if (lastTool) {
+        const t = lastTool;
+        segments.push(`last action: ${t.target ? `${t.name} ${clipWords(t.target, 60)}` : t.name}`);
+    }
+    if (lastTs !== null) {
+        segments.push(`last activity ${agoLabel(opts.now - lastTs)}`);
+    }
+    return capRecap(segments.join(' · '), opts.maxChars ?? exports.RECAP_MAX_CHARS);
+}
+/**
+ * Whether the automatic recap prints after `--resume`/`--continue`.
+ * Default ON (CC parity). The env var decides first — `0`/`false`/`off` force
+ * it off, `1`/`true` force it on — then the `autoRecap` setting in
+ * settings.json. For the SETTING only the off direction needs spellings: any
+ * truthy value means "on", which is also the default, so accepting `false`,
+ * the string `"false"`, `"0"` and `"off"` as off is the user-friendly reading
+ * and cannot surprise anyone who did not touch the key.
+ */
+function resolveAutoRecap(f) {
+    const raw = (f.env ?? {}).NEXRALL_AUTO_RECAP;
+    const v = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (v === '0' || v === 'false' || v === 'off')
+        return false;
+    if (v === '1' || v === 'true')
+        return true;
+    const s = f.setting;
+    if (s === false || s === 'false' || s === '0' || s === 'off')
+        return false;
+    return true;
+}
+//# sourceMappingURL=recap.js.map

package/dist/events/sessionEvents.d.ts

@@ -0,0 +1,54 @@
+export declare const EVENTS_VERSION = 1;
+/** Once the file crosses this, it is trimmed to KEEP_ON_TRIM lines (checked once per process). */
+export declare const MAX_EVENTS_BYTES: number;
+export declare const KEEP_ON_TRIM = 1000;
+export declare const CLIP_TEXT = 240;
+/** A codemod can touch hundreds of files; the stream keeps the first N and stops. */
+export declare const MAX_FILE_EVENTS = 20;
+/** The event vocabulary from the spec (§92), verbatim. */
+export declare const EVENT_TYPES: readonly ["session.started", "session.resumed", "agent.started", "agent.completed", "agent.failed", "message.started", "message.delta", "message.completed", "tool.started", "tool.output", "tool.completed", "file.changed", "permission.requested", "permission.granted", "permission.denied", "task.started", "task.completed", "task.failed", "checkpoint.created", "checkpoint.restored", "context.compacted", "session.completed"];
+export type EventType = (typeof EVENT_TYPES)[number];
+export interface SessionEvent {
+    v: typeof EVENTS_VERSION;
+    ts: number;
+    type: EventType;
+    [key: string]: unknown;
+}
+/** NEXRALL_EVENTS=off (or 0/false) turns the whole protocol off for a run. */
+export declare function eventsEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function eventsDir(env?: NodeJS.ProcessEnv): string;
+/** File-name-safe id: anything outside [A-Za-z0-9._-] is dropped (ids are hex, but bundles import untrusted ones). */
+export declare function safeId(id: string): string;
+export declare function eventsPath(id: string, env?: NodeJS.ProcessEnv): string;
+export declare function clipText(text: string, max?: number): string;
+export declare function redactValue(key: string, value: unknown): unknown;
+export declare function buildEvent(type: EventType, data?: Record<string, unknown>, now?: number): SessionEvent;
+/** What a tool call acted on, in one clipped line — the useful half of a `tool.started`. */
+export declare function toolTarget(name: string, input: Record<string, unknown>): string;
+export declare function trimEventsFile(file: string): void;
+export declare class EventLog {
+    private readonly id;
+    private readonly opts;
+    private _count;
+    private checked;
+    constructor(id: string, opts?: {
+        file?: string;
+        enabled?: boolean;
+    });
+    get file(): string;
+    get count(): number;
+    /** Append one event. Returns the written event, or null when disabled/failed — never throws. */
+    emit(type: EventType, data?: Record<string, unknown>): SessionEvent | null;
+}
+/** Parse a log file, tolerating a torn last line (kill -9 mid-append). `last` keeps the tail. */
+export declare function readEvents(id: string, opts?: {
+    last?: number;
+    file?: string;
+}): SessionEvent[];
+/** Replace a log file wholesale — used when importing a bundle from another machine. */
+export declare function writeEvents(id: string, events: SessionEvent[], opts?: {
+    file?: string;
+}): number;
+/** One human line for `nex sessions --events` — the same shape a web client would render. */
+export declare function summarizeEvent(ev: SessionEvent): string;
+//# sourceMappingURL=sessionEvents.d.ts.map

package/dist/events/sessionEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionEvents.d.ts","sourceRoot":"","sources":["../../src/events/sessionEvents.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,QAAkB,CAAC;AAChD,eAAO,MAAM,YAAY,OAAO,CAAC;AACjC,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,qFAAqF;AACrF,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,0DAA0D;AAC1D,eAAO,MAAM,WAAW,0aAuBd,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,OAAO,cAAc,CAAC;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AASD,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAG3E;AAED,wBAAgB,SAAS,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAEtE;AAED,sHAAsH;AACtH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAEnF;AAWD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAY,GAAG,MAAM,CAG9D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CA+BhE;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAClC,GAAG,GAAE,MAAmB,GACvB,YAAY,CAOd;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAG/E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAMjD;AAED,qBAAa,QAAQ;IAIjB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJvB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;gBAEL,EAAE,EAAE,MAAM,EACV,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO;IAGlE,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,gGAAgG;IAChG,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,YAAY,GAAG,IAAI;CAoB/E;AAED,iGAAiG;AACjG,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,YAAY,EAAE,CAmBlG;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CASpG;AAUD,6FAA6F;AAC7F,wBAAgB,cAAc,CAAC,EAAE,EAAE,YAAY,GAAG,MAAM,CAkDvD"}

package/dist/events/sessionEvents.js

@@ -0,0 +1,324 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLog = exports.EVENT_TYPES = exports.MAX_FILE_EVENTS = exports.CLIP_TEXT = exports.KEEP_ON_TRIM = exports.MAX_EVENTS_BYTES = exports.EVENTS_VERSION = void 0;
+exports.eventsEnabled = eventsEnabled;
+exports.eventsDir = eventsDir;
+exports.safeId = safeId;
+exports.eventsPath = eventsPath;
+exports.clipText = clipText;
+exports.redactValue = redactValue;
+exports.buildEvent = buildEvent;
+exports.toolTarget = toolTarget;
+exports.trimEventsFile = trimEventsFile;
+exports.readEvents = readEvents;
+exports.writeEvents = writeEvents;
+exports.summarizeEvent = summarizeEvent;
+// Spec §92 — JSON event protocol.
+//
+// One append-only JSONL file per session (`<sessions-root>/events/<id>.jsonl`), written as
+// the agent works. This is the record other clients (web, VS Code, mobile) can follow to
+// mirror a terminal session — the foundation §93 (terminal-to-web continuity) and §94
+// (resume elsewhere) build on.
+//
+// Deliberate limits, so the log stays cheap and safe:
+//   · `message.delta` is NOT emitted — a line per streamed token would dominate the file,
+//     and `message.completed` already carries what the turn produced.
+//   · `tool.output` is NOT emitted — full output lives in the session transcript; the
+//     event stream carries started/completed with timing instead.
+//   · Values under secret-looking keys are dropped and long strings are clipped, because
+//     this file is meant to be exported and read by other tools.
+//   · Every write is best-effort: an event log must never fail a turn.
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// Lives in core (moved from the CLI's sessionEvents.ts, 2026-10-04) so the VS
+// Code panel writes the SAME per-session event log /recap and /stats read;
+// the CLI module is a re-export shim.
+exports.EVENTS_VERSION = 1;
+/** Once the file crosses this, it is trimmed to KEEP_ON_TRIM lines (checked once per process). */
+exports.MAX_EVENTS_BYTES = 2 * 1024 * 1024;
+exports.KEEP_ON_TRIM = 1000;
+exports.CLIP_TEXT = 240;
+/** A codemod can touch hundreds of files; the stream keeps the first N and stops. */
+exports.MAX_FILE_EVENTS = 20;
+/** The event vocabulary from the spec (§92), verbatim. */
+exports.EVENT_TYPES = [
+    'session.started',
+    'session.resumed',
+    'agent.started',
+    'agent.completed',
+    'agent.failed',
+    'message.started',
+    'message.delta',
+    'message.completed',
+    'tool.started',
+    'tool.output',
+    'tool.completed',
+    'file.changed',
+    'permission.requested',
+    'permission.granted',
+    'permission.denied',
+    'task.started',
+    'task.completed',
+    'task.failed',
+    'checkpoint.created',
+    'checkpoint.restored',
+    'context.compacted',
+    'session.completed',
+];
+// Same root as commands/sessions.ts, resolved here independently so neither module has to
+// import the other (a cycle between storage and telemetry would be a runtime landmine for
+// no benefit). NEXRALL_CLI_SESSIONS_DIR keeps tests off the real ~/.nexrall directory.
+function sessionsRoot(env) {
+    return env.NEXRALL_CLI_SESSIONS_DIR || path.join(os.homedir(), '.nexrall', 'cli-sessions');
+}
+/** NEXRALL_EVENTS=off (or 0/false) turns the whole protocol off for a run. */
+function eventsEnabled(env = process.env) {
+    const raw = (env.NEXRALL_EVENTS ?? '').trim().toLowerCase();
+    return !(raw === 'off' || raw === '0' || raw === 'false');
+}
+function eventsDir(env = process.env) {
+    return path.join(sessionsRoot(env), 'events');
+}
+/** File-name-safe id: anything outside [A-Za-z0-9._-] is dropped (ids are hex, but bundles import untrusted ones). */
+function safeId(id) {
+    return id.replace(/[^A-Za-z0-9._-]/g, '');
+}
+function eventsPath(id, env = process.env) {
+    return path.join(eventsDir(env), `${safeId(id)}.jsonl`);
+}
+const SECRET_KEY_RE = /(token|secret|password|passwd|authorization|api[-_]?key|credential)/i;
+/** A secret is a string (or a blob). A NUMBER under a secret-adjacent key is a tally —
+ * `tokens` matches /token/i, and redacting it would blank the very usage counts this
+ * stream exists to carry. */
+function secretMustDrop(value) {
+    return typeof value === 'string' || (value !== null && typeof value === 'object');
+}
+function clipText(text, max = exports.CLIP_TEXT) {
+    if (max <= 0)
+        return '';
+    return text.length > max ? text.slice(0, max - 1) + '…' : text;
+}
+function redactValue(key, value) {
+    if (SECRET_KEY_RE.test(key) && secretMustDrop(value))
+        return '[redacted]';
+    if (typeof value === 'string')
+        return clipText(value);
+    if (Array.isArray(value)) {
+        return value
+            .slice(0, 20)
+            .map((v) => typeof v === 'string'
+            ? clipText(v)
+            : typeof v === 'number' || typeof v === 'boolean' || v === null
+                ? v
+                : '[object]');
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (SECRET_KEY_RE.test(k) && secretMustDrop(v)) {
+                out[k] = '[redacted]';
+                continue;
+            }
+            out[k] =
+                typeof v === 'string'
+                    ? clipText(v)
+                    : typeof v === 'number' || typeof v === 'boolean' || v === null
+                        ? v
+                        : '[object]';
+        }
+        return out;
+    }
+    return value;
+}
+function buildEvent(type, data = {}, now = Date.now()) {
+    const ev = { v: exports.EVENTS_VERSION, ts: now, type };
+    for (const [k, val] of Object.entries(data)) {
+        if (val === undefined)
+            continue;
+        ev[k] = redactValue(k, val);
+    }
+    return ev;
+}
+/** What a tool call acted on, in one clipped line — the useful half of a `tool.started`. */
+function toolTarget(name, input) {
+    const pick = input.command ?? input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.url;
+    return typeof pick === 'string' && pick.trim() ? clipText(pick.trim(), 120) : name;
+}
+function trimEventsFile(file) {
+    const lines = fs
+        .readFileSync(file, 'utf-8')
+        .split('\n')
+        .filter((l) => l.trim());
+    fs.writeFileSync(file, lines.slice(-exports.KEEP_ON_TRIM).join('\n') + '\n', 'utf-8');
+}
+class EventLog {
+    constructor(id, opts = {}) {
+        this.id = id;
+        this.opts = opts;
+        this._count = 0;
+        this.checked = false;
+    }
+    get file() {
+        return this.opts.file ?? eventsPath(this.id);
+    }
+    get count() {
+        return this._count;
+    }
+    /** Append one event. Returns the written event, or null when disabled/failed — never throws. */
+    emit(type, data = {}) {
+        if (this.opts.enabled === false)
+            return null;
+        const ev = buildEvent(type, data);
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            if (!this.checked) {
+                this.checked = true;
+                try {
+                    if (fs.statSync(this.file).size > exports.MAX_EVENTS_BYTES)
+                        trimEventsFile(this.file);
+                }
+                catch {
+                    /* first write */
+                }
+            }
+            fs.appendFileSync(this.file, JSON.stringify(ev) + '\n', 'utf-8');
+            this._count++;
+            return ev;
+        }
+        catch {
+            return null; // telemetry never breaks a turn
+        }
+    }
+}
+exports.EventLog = EventLog;
+/** Parse a log file, tolerating a torn last line (kill -9 mid-append). `last` keeps the tail. */
+function readEvents(id, opts = {}) {
+    const file = opts.file ?? eventsPath(id);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            /* torn line */
+        }
+    }
+    const last = opts.last ?? 0;
+    return last > 0 ? out.slice(-last) : out;
+}
+/** Replace a log file wholesale — used when importing a bundle from another machine. */
+function writeEvents(id, events, opts = {}) {
+    const file = opts.file ?? eventsPath(id);
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, events.map((e) => JSON.stringify(e)).join('\n') + (events.length ? '\n' : ''), 'utf-8');
+        return events.length;
+    }
+    catch {
+        return 0;
+    }
+}
+function num(v) {
+    return typeof v === 'number' ? String(v) : '?';
+}
+function fmtMs(v) {
+    if (typeof v !== 'number')
+        return '';
+    return v >= 1000 ? `${Math.round(v / 1000)}s` : `${v}ms`;
+}
+/** One human line for `nex sessions --events` — the same shape a web client would render. */
+function summarizeEvent(ev) {
+    const at = new Date(ev.ts).toTimeString().slice(0, 8);
+    let body;
+    switch (ev.type) {
+        case 'session.started':
+            body = `session ${String(ev.id ?? '')} started${ev.forkOf ? ` (fork of ${String(ev.forkOf)})` : ''}`;
+            break;
+        case 'session.resumed':
+            body = `session ${String(ev.id ?? '')} resumed`;
+            break;
+        case 'session.completed':
+            body = `session ended (${String(ev.reason ?? 'exit')})`;
+            break;
+        case 'message.started':
+            body = `prompt: ${String(ev.text ?? '')}`;
+            break;
+        case 'message.completed':
+            body = `turn ${String(ev.outcome ?? 'ok')} · ${num(ev.tokens)} tokens · ${fmtMs(ev.ms)}`;
+            break;
+        case 'tool.started':
+            body = `→ ${String(ev.name ?? 'tool')}${ev.target ? ` ${String(ev.target)}` : ''}`;
+            break;
+        case 'tool.completed':
+            body = `${ev.ok === false ? '✗' : '✓'} ${String(ev.name ?? 'tool')}${fmtMs(ev.ms) ? ` (${fmtMs(ev.ms)})` : ''}`;
+            break;
+        case 'file.changed':
+            body = `changed ${String(ev.path ?? '')}`;
+            break;
+        case 'permission.requested':
+            body = `permission requested: ${String(ev.what ?? '')}`;
+            break;
+        case 'permission.granted':
+            body = `permission granted${ev.tool ? `: ${String(ev.tool)}` : ''}`;
+            break;
+        case 'permission.denied':
+            body = `permission denied${ev.tool ? `: ${String(ev.tool)}` : ''}`;
+            break;
+        case 'checkpoint.created':
+            body = `checkpoint saved · ${num(ev.turns)} turn(s)`;
+            break;
+        case 'checkpoint.restored':
+            body = `rewound to #${num(ev.id)} (${num(ev.files)} file(s))`;
+            break;
+        case 'context.compacted':
+            body = `compacted ${num(ev.before)} → ${num(ev.after)} messages${ev.where ? ` (${String(ev.where)})` : ''}`;
+            break;
+        default:
+            body = ev.type;
+    }
+    return `${at}  ${body.length > 100 ? body.slice(0, 99) + '…' : body}`;
+}
+//# sourceMappingURL=sessionEvents.js.map