@xiaolei.shawn/mcp-server 0.2.1 → 0.3.0

package/dist/__tests__/ingest.test.js

@@ -2,7 +2,7 @@
  * Ingest and merge logic tests.
  * Run from mcp-server: pnpm run build && pnpm test
  */
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { describe, it, before, after } from "node:test";
@@ -102,4 +102,43 @@ describe("ingest", () => {
         assert.strictEqual(result.adapter, "codex_jsonl");
         assert.ok(result.inserted > 0);
     });
+    it("merge raw log from different day: time window filters out all raw events", () => {
+        const sessionId = "sess_merge_target_time_window";
+        const sessionStartTs = "2026-03-02T20:55:12.151Z";
+        const sessionEndTs = "2026-03-02T20:57:42.004Z";
+        const sessionLines = [
+            JSON.stringify({
+                id: `${sessionId}:1:aa`,
+                session_id: sessionId,
+                seq: 1,
+                ts: sessionStartTs,
+                kind: "session_start",
+                actor: { type: "agent" },
+                payload: { goal: "Test" },
+                schema_version: 1,
+            }),
+            JSON.stringify({
+                id: `${sessionId}:2:bb`,
+                session_id: sessionId,
+                seq: 2,
+                ts: sessionEndTs,
+                kind: "session_end",
+                actor: { type: "agent" },
+                payload: { outcome: "completed" },
+                schema_version: 1,
+            }),
+        ].join("\n") + "\n";
+        writeFileSync(join(sessionsDir, `${sessionId}.jsonl`), sessionLines, "utf-8");
+        const raw = readFileSync(fixturePath("codex_sample.jsonl"), "utf-8");
+        const result = ingestRawContent(raw, {
+            adapter: "codex_jsonl",
+            merge_session_id: sessionId,
+        });
+        assert.strictEqual(result.session_id, sessionId);
+        assert.strictEqual(result.merge_strategy, "explicit_merge");
+        assert.strictEqual(result.inserted, 0, "no raw events fall in Mar 2 window");
+        assert.ok(result.filtered_out_by_time_window !== undefined && result.filtered_out_by_time_window > 0, "raw events (Feb 24) were filtered out by time window");
+        const eventsAfter = readSessionEvents(sessionId);
+        assert.strictEqual(eventsAfter.length, 2, "session still has only session_start and session_end");
+    });
 });

package/dist/__tests__/local-analysis.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/local-analysis.test.js

@@ -0,0 +1,118 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { deriveIntentTokenBreakdown, generateFollowupArtifacts } from "../local-analysis.js";
+function baseEvent(overrides) {
+    return {
+        id: "e-1",
+        session_id: "sess-test",
+        seq: 1,
+        ts: "2026-03-03T00:00:00.000Z",
+        kind: "intent",
+        actor: { type: "agent" },
+        payload: {},
+        schema_version: 1,
+        ...overrides,
+    };
+}
+describe("local-analysis", () => {
+    it("generates per-intent artifacts with deterministic template", () => {
+        const events = [
+            baseEvent({
+                id: "i1",
+                seq: 1,
+                kind: "intent",
+                scope: { intent_id: "intent_a" },
+                payload: { intent_id: "intent_a", title: "Implement feature A" },
+            }),
+            baseEvent({
+                id: "t1",
+                seq: 2,
+                kind: "tool_call",
+                scope: { intent_id: "intent_a" },
+                payload: { category: "tool", action: "read_file", target: "src/a.ts" },
+            }),
+            baseEvent({
+                id: "t2",
+                seq: 3,
+                kind: "tool_call",
+                scope: { intent_id: "intent_a" },
+                payload: { category: "tool", action: "read_file", target: "src/a.ts" },
+            }),
+            baseEvent({
+                id: "t3",
+                seq: 4,
+                kind: "tool_call",
+                scope: { intent_id: "intent_a" },
+                payload: { category: "tool", action: "read_file", target: "src/a.ts" },
+            }),
+            baseEvent({
+                id: "v1",
+                seq: 5,
+                kind: "verification",
+                scope: { intent_id: "intent_a" },
+                payload: { type: "test", result: "fail" },
+            }),
+            baseEvent({
+                id: "r1",
+                seq: 6,
+                kind: "risk_signal",
+                scope: { intent_id: "intent_a", file: "src/a.ts" },
+                payload: { level: "high", reasons: ["regression risk"] },
+            }),
+        ];
+        const result = generateFollowupArtifacts(events, {
+            mode: "per_intent",
+            strictness: "soft",
+            focus: "risk",
+        });
+        assert.equal(result.artifacts.length, 1);
+        assert.equal(result.artifacts[0].intent_id, "intent_a");
+        assert.equal(result.artifacts[0].rule_template_id, "high_risk_guardrail");
+        assert.ok(result.artifacts[0].value_claims.risk_mitigation.length > 0);
+    });
+    it("derives token breakdown context/output split", () => {
+        const events = [
+            baseEvent({
+                id: "i1",
+                seq: 1,
+                kind: "intent",
+                scope: { intent_id: "intent_a" },
+                payload: { intent_id: "intent_a", title: "Intent A" },
+            }),
+            baseEvent({
+                id: "ctx1",
+                seq: 2,
+                kind: "tool_call",
+                scope: { intent_id: "intent_a" },
+                payload: { category: "search", action: "search_docs", target: "api docs" },
+            }),
+            baseEvent({
+                id: "tok1",
+                seq: 3,
+                kind: "token_usage_checkpoint",
+                scope: { intent_id: "intent_a" },
+                payload: { usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 } },
+            }),
+            baseEvent({
+                id: "out1",
+                seq: 4,
+                kind: "file_op",
+                scope: { intent_id: "intent_a", file: "src/a.ts" },
+                payload: { category: "file", action: "edit", target: "src/a.ts" },
+            }),
+            baseEvent({
+                id: "tok2",
+                seq: 5,
+                kind: "token_usage_checkpoint",
+                scope: { intent_id: "intent_a" },
+                payload: { usage: { total_tokens: 90 } },
+            }),
+        ];
+        const result = deriveIntentTokenBreakdown(events);
+        assert.equal(result.intent_breakdown.length, 1);
+        assert.equal(result.totals.total_tokens, 240);
+        assert.equal(result.intent_breakdown[0].context_tokens +
+            result.intent_breakdown[0].output_tokens +
+            result.intent_breakdown[0].unknown_tokens, 240);
+    });
+});

package/dist/adapters/codex.js

@@ -4,11 +4,24 @@ function toObject(value) {
         : {};
 }
 function toIso(ts, fallback) {
+    if (ts == null)
+        return fallback;
+    if (typeof ts === "number" && Number.isFinite(ts)) {
+        const parsed = new Date(ts);
+        return Number.isNaN(parsed.getTime()) ? fallback : parsed.toISOString();
+    }
     if (typeof ts !== "string" || ts.trim() === "")
         return fallback;
     const parsed = new Date(ts);
     return Number.isNaN(parsed.getTime()) ? fallback : parsed.toISOString();
 }
+/** Prefer top-level timestamp, then payload.timestamp / payload.created_at. */
+function getRecordTimestamp(record) {
+    if (record.timestamp !== undefined && record.timestamp !== null)
+        return record.timestamp;
+    const payload = toObject(record.payload);
+    return payload.timestamp ?? payload.created_at;
+}
 function short(value, max = 800) {
     if (typeof value !== "string")
         return undefined;
@@ -67,7 +80,7 @@ function parseLines(content) {
 function mapResponseItem(record, intentId, now) {
     const payload = toObject(record.payload);
     const itemType = short(payload.type) ?? "unknown";
-    const ts = toIso(record.timestamp, now);
+    const ts = toIso(getRecordTimestamp(record), now);
     if (itemType === "function_call" || itemType === "custom_tool_call" || itemType === "web_search_call") {
         const action = short(payload.name) ?? short(toObject(payload.action).type) ?? itemType;
         return [
@@ -189,7 +202,7 @@ export const codexJsonlAdapter = {
         }
         const meta = toObject(sessionMeta.payload);
         const sessionId = short(meta.id) ?? `codex_${Date.now()}`;
-        const start = toIso(meta.timestamp, toIso(sessionMeta.timestamp, now));
+        const start = toIso(getRecordTimestamp(sessionMeta) ?? meta.timestamp, now);
         let intentCounter = 0;
         let activeIntentId;
         const events = [];
@@ -216,7 +229,7 @@ export const codexJsonlAdapter = {
                         activeIntentId = `intent_${sessionId}_${intentCounter}`;
                         events.push({
                             kind: "intent",
-                            ts: toIso(record.timestamp, now),
+                            ts: toIso(getRecordTimestamp(record), now),
                             actor: { type: "user", id: "codex-user" },
                             scope: { intent_id: activeIntentId },
                             payload: {
@@ -235,7 +248,7 @@ export const codexJsonlAdapter = {
                     const usage = normalizeTokenUsage(p.info);
                     events.push({
                         kind: "token_usage_checkpoint",
-                        ts: toIso(record.timestamp, now),
+                        ts: toIso(getRecordTimestamp(record), now),
                         actor: { type: "system", id: "codex" },
                         scope: activeIntentId ? { intent_id: activeIntentId, module: "llm" } : { module: "llm" },
                         payload: {
@@ -253,7 +266,7 @@ export const codexJsonlAdapter = {
                     if (reasoning) {
                         events.push({
                             kind: "artifact_created",
-                            ts: toIso(record.timestamp, now),
+                            ts: toIso(getRecordTimestamp(record), now),
                             actor: { type: "agent", id: "codex" },
                             scope: activeIntentId
                                 ? { intent_id: activeIntentId, module: "reasoning" }
@@ -274,7 +287,7 @@ export const codexJsonlAdapter = {
                     if (assistantMessage) {
                         events.push({
                             kind: "artifact_created",
-                            ts: toIso(record.timestamp, now),
+                            ts: toIso(getRecordTimestamp(record), now),
                             actor: { type: "agent", id: "codex" },
                             scope: activeIntentId
                                 ? { intent_id: activeIntentId, module: "assistant_output" }
@@ -295,7 +308,16 @@ export const codexJsonlAdapter = {
                 events.push(...mapResponseItem(record, activeIntentId, now));
             }
         }
-        const endTs = toIso(records[records.length - 1]?.timestamp, now);
+        const lastRecordTs = records.reduce((acc, r) => {
+            const t = getRecordTimestamp(r);
+            const ms = typeof t === "number" && Number.isFinite(t) ? t : (typeof t === "string" ? new Date(t).getTime() : NaN);
+            if (Number.isNaN(ms))
+                return acc;
+            return acc == null ? ms : Math.max(acc, ms);
+        }, null);
+        const endTs = lastRecordTs != null
+            ? new Date(lastRecordTs).toISOString()
+            : toIso(records[records.length - 1]?.timestamp, now);
         events.push({
             kind: "session_end",
             ts: endTs,

package/dist/dashboard.js

@@ -2,10 +2,12 @@ import { createServer } from "node:http";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { extname, join, normalize, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
+import { EVENT_SCHEMA_VERSION } from "./event-envelope.js";
 import { getDashboardHost, getDashboardPort, getDashboardWebappDir, getSessionsDir, isDashboardEnabled, } from "./config.js";
 import { exportSessionJson } from "./store.js";
 import { handleGatewayAct, handleGatewayBeginRun, handleGatewayEndRun } from "./tools.js";
 import { ingestRawContent } from "./ingest.js";
+import { deriveIntentTokenBreakdown, generateFollowupArtifacts, } from "./local-analysis.js";
 const importSets = new Map();
 function json(res, status, payload) {
     res.writeHead(status, {
@@ -170,6 +172,66 @@ function summarizeSessionPayload(payload) {
         event_count: payload.events.length,
     };
 }
+/** Merge multiple session payloads into one: combined events sorted by ts, single session_id, re-sequenced. */
+function mergeSessionPayloads(payloads) {
+    if (payloads.length === 0)
+        throw new Error("No payloads to merge.");
+    if (payloads.length === 1)
+        return payloads[0];
+    const mergedSessionId = `merged_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const expectedTotal = payloads.reduce((sum, p) => sum + p.events.length, 0);
+    const allEvents = [];
+    for (const payload of payloads) {
+        for (const e of payload.events) {
+            allEvents.push({
+                id: e.id,
+                session_id: mergedSessionId,
+                seq: e.seq,
+                ts: e.ts,
+                kind: e.kind,
+                actor: { ...e.actor },
+                scope: e.scope ? { ...e.scope } : undefined,
+                payload: typeof e.payload === "object" && e.payload !== null ? { ...e.payload } : e.payload,
+                derived: e.derived,
+                confidence: e.confidence,
+                visibility: e.visibility,
+                schema_version: e.schema_version ?? EVENT_SCHEMA_VERSION,
+            });
+        }
+    }
+    if (allEvents.length !== expectedTotal) {
+        throw new Error(`Merge event count mismatch: collected ${allEvents.length}, expected ${expectedTotal} from ${payloads.length} payload(s).`);
+    }
+    allEvents.sort((a, b) => {
+        const tsCmp = a.ts.localeCompare(b.ts);
+        if (tsCmp !== 0)
+            return tsCmp;
+        return (a.seq ?? 0) - (b.seq ?? 0);
+    });
+    let seq = 0;
+    const mergedEvents = allEvents.map((e) => {
+        seq += 1;
+        return {
+            ...e,
+            id: `${mergedSessionId}:${seq}:${randomUUID().slice(0, 8)}`,
+            seq,
+            schema_version: e.schema_version ?? EVENT_SCHEMA_VERSION,
+        };
+    });
+    const first = payloads[0];
+    const last = payloads[payloads.length - 1];
+    const firstStart = mergedEvents.find((e) => e.kind === "session_start");
+    const lastEnd = [...mergedEvents].reverse().find((e) => e.kind === "session_end");
+    const startPayload = (firstStart?.payload ?? {});
+    return {
+        session_id: mergedSessionId,
+        goal: typeof startPayload.goal === "string" ? startPayload.goal : first.goal ?? "Merged session",
+        user_prompt: first.user_prompt,
+        started_at: firstStart?.ts ?? first.started_at ?? mergedEvents[0]?.ts,
+        ended_at: lastEnd?.ts ?? last.ended_at,
+        events: mergedEvents,
+    };
+}
 function buildFollowupFromEvents(events, focus) {
     const risks = events.filter((event) => event.kind === "risk_signal");
     const fails = events.filter((event) => event.kind === "verification" && event.payload?.result === "fail");
@@ -475,7 +537,7 @@ async function handleApi(req, res, pathname) {
                 json(res, 400, { error: "Missing `files` array. Provide one or more MCP canonical session logs." });
                 return true;
             }
-            const accepted = [];
+            const acceptedPayloads = [];
             const rejected_files = [];
             for (const item of filesRaw) {
                 const file = item;
@@ -486,13 +548,7 @@ async function handleApi(req, res, pathname) {
                 }
                 try {
                     const payload = parseSessionContent(file.content);
-                    writeCanonicalSession(payload);
-                    const summary = summarizeSessionPayload(payload);
-                    accepted.push({
-                        ...summary,
-                        size_bytes: Buffer.byteLength(file.content, "utf-8"),
-                        updated_at: new Date().toISOString(),
-                    });
+                    acceptedPayloads.push(payload);
                 }
                 catch (error) {
                     rejected_files.push({
@@ -503,24 +559,43 @@ async function handleApi(req, res, pathname) {
                     });
                 }
             }
-            if (accepted.length === 0) {
+            if (acceptedPayloads.length === 0) {
                 json(res, 400, {
                     error: "No canonical MCP session logs were accepted.",
                     rejected_files,
                 });
                 return true;
             }
+            const mergedPayload = acceptedPayloads.length === 1
+                ? acceptedPayloads[0]
+                : mergeSessionPayloads(acceptedPayloads);
+            writeCanonicalSession(mergedPayload);
+            const summary = summarizeSessionPayload(mergedPayload);
+            const accepted = [
+                {
+                    ...summary,
+                    size_bytes: mergedPayload.events.reduce((acc, e) => acc + Buffer.byteLength(JSON.stringify(e), "utf-8"), 0),
+                    updated_at: new Date().toISOString(),
+                },
+            ];
             const import_set_id = `iset_${Date.now()}_${randomUUID().slice(0, 8)}`;
             importSets.set(import_set_id, {
                 import_set_id,
                 created_at: new Date().toISOString(),
-                session_ids: [...new Set(accepted.map((item) => item.session_id))],
+                session_ids: [mergedPayload.session_id],
             });
+            const multipleRejected = filesRaw.length > 1 && rejected_files.length > 0;
             json(res, 200, {
                 import_set_id,
                 sessions: accepted,
                 rejected_files,
-                guidance: "Import only relevant or consecutive sessions from the same thread/conversation to avoid noisy insights.",
+                accepted_file_count: acceptedPayloads.length,
+                total_event_count: mergedPayload.events.length,
+                guidance: multipleRejected
+                    ? `${acceptedPayloads.length} of ${filesRaw.length} files were valid. Fix or remove rejected files to merge all session logs.`
+                    : acceptedPayloads.length > 1
+                        ? "Multiple session logs were merged into one. Raw logs will merge into this combined session."
+                        : "Import only relevant or consecutive sessions from the same thread/conversation to avoid noisy insights.",
             });
         }
         catch (error) {
@@ -584,7 +659,15 @@ async function handleApi(req, res, pathname) {
         try {
             const body = await readJsonBody(req);
             const scope = typeof body.scope === "string" ? body.scope : "session";
-            const focus = typeof body.focus === "string" ? body.focus : "risk";
+            const focus = body.focus === "risk" ||
+                body.focus === "verification_gap" ||
+                body.focus === "hotspot" ||
+                body.focus === "rework_pattern" ||
+                body.focus === "efficiency"
+                ? body.focus
+                : "risk";
+            const mode = body.mode === "session" ? "session" : "per_intent";
+            const strictness = body.strictness === "advisory" || body.strictness === "hard" ? body.strictness : "soft";
             const importSetId = typeof body.import_set_id === "string" ? body.import_set_id : "";
             const sessionId = typeof body.session_id === "string" ? body.session_id : "";
             const summaries = listSessionFiles();
@@ -609,10 +692,16 @@ async function handleApi(req, res, pathname) {
                 json(res, 404, { error: "No events found for requested follow-up scope." });
                 return true;
             }
-            const generated = buildFollowupFromEvents(collectedEvents, focus);
+            const generated = generateFollowupArtifacts(collectedEvents, {
+                focus,
+                mode,
+                strictness,
+            });
             json(res, 200, {
                 scope,
                 focus,
+                mode,
+                strictness,
                 session_ids: scopedSessionIds,
                 generated_at: new Date().toISOString(),
                 ...generated,
@@ -656,6 +745,29 @@ async function handleApi(req, res, pathname) {
             }
             return true;
         }
+        if (key.endsWith("/token-breakdown")) {
+            const rawKey = key.slice(0, -"/token-breakdown".length);
+            const summary = listSessionFiles().find((item) => item.key === rawKey || item.session_id === rawKey);
+            if (!summary) {
+                json(res, 404, { error: "Session not found." });
+                return true;
+            }
+            try {
+                const payload = readSessionFile(summary.absolute_path);
+                const breakdown = deriveIntentTokenBreakdown(payload.events);
+                json(res, 200, {
+                    session_id: summary.session_id,
+                    generated_at: new Date().toISOString(),
+                    ...breakdown,
+                });
+            }
+            catch (error) {
+                json(res, 500, {
+                    error: error instanceof Error ? error.message : "Failed to derive token breakdown.",
+                });
+            }
+            return true;
+        }
         const summary = listSessionFiles().find((item) => item.key === key || item.session_id === key);
         if (!summary) {
             json(res, 404, { error: "Session not found." });

package/dist/ingest.d.ts

@@ -8,6 +8,8 @@ export interface IngestResult {
     adapter: string;
     inserted: number;
     skipped_duplicates: number;
+    /** When merging into an existing session, number of raw events dropped by the time-window filter. */
+    filtered_out_by_time_window?: number;
     session_path: string;
     raw_path: string;
     merge_strategy: "explicit_merge" | "adapted_session_id" | "fingerprint_match" | "new_session";

package/dist/ingest.js

@@ -89,6 +89,59 @@ function toMs(raw) {
     const ms = new Date(raw).getTime();
     return Number.isNaN(ms) ? undefined : ms;
 }
+/** Padding (ms) around session time range when merging. Use 0 so only events strictly inside the session window are kept; raw adapters often synthesize timestamps at "now" which would otherwise fall in session_end+padding. */
+const MERGE_TIME_PADDING_MS = 0;
+/**
+ * Session time range from existing canonical events.
+ * Uses session_start / session_end ts when present, else first/last event ts.
+ */
+function getSessionTimeRange(existing) {
+    if (existing.length === 0) {
+        const now = Date.now();
+        return { startMs: now, endMs: now };
+    }
+    let sessionStartMs;
+    let sessionEndMs;
+    for (const e of existing) {
+        const ms = toMs(e.ts);
+        if (ms == null)
+            continue;
+        if (e.kind === "session_start")
+            sessionStartMs = ms;
+        if (e.kind === "session_end")
+            sessionEndMs = ms;
+    }
+    const firstMs = toMs(existing[0]?.ts);
+    const lastMs = toMs(existing[existing.length - 1]?.ts);
+    return {
+        startMs: sessionStartMs ?? firstMs ?? Date.now(),
+        endMs: sessionEndMs ?? lastMs ?? Date.now(),
+    };
+}
+/**
+ * When merging raw into an existing session, keep only events that fall inside the
+ * session time window (with padding) and drop session_start/session_end from raw.
+ * Events without a parseable ts are excluded. Events on a different calendar day (UTC)
+ * from the session range are always excluded to avoid timezone/clock skew.
+ */
+function filterAdaptedEventsForMerge(events, range, paddingMs, fallbackTs) {
+    const minMs = range.startMs - paddingMs;
+    const maxMs = range.endMs + paddingMs;
+    const startDay = new Date(range.startMs).toISOString().slice(0, 10);
+    const endDay = new Date(range.endMs).toISOString().slice(0, 10);
+    return events.filter((event) => {
+        if (event.kind === "session_start" || event.kind === "session_end")
+            return false;
+        const ts = toIso(event.ts, fallbackTs);
+        const ms = toMs(ts);
+        if (ms == null)
+            return false;
+        const eventDay = new Date(ms).toISOString().slice(0, 10);
+        if (eventDay < startDay || eventDay > endDay)
+            return false;
+        return ms >= minMs && ms <= maxMs;
+    });
+}
 function normalizeFingerprint(value) {
     if (!value)
         return "";
@@ -362,13 +415,21 @@ export function ingestRawContent(raw, options = {}) {
     const doDedupe = options.dedupe ?? true;
     const fallbackTs = new Date().toISOString();
     const isMerge = existing.length > 0;
+    const isExplicitMerge = isMerge && Boolean(options.merge_session_id);
     const existingSemanticKeys = new Set(existing.map((e) => semanticDedupeKey(e)));
     const existingExactKeys = new Set(existing.map((e) => dedupeKey(e)));
+    const range = getSessionTimeRange(existing);
+    const eventsToProcess = isExplicitMerge
+        ? filterAdaptedEventsForMerge(adapted.events, range, MERGE_TIME_PADDING_MS, fallbackTs)
+        : adapted.events;
+    const filteredOutByTimeWindow = isExplicitMerge && adapted.events.length > eventsToProcess.length
+        ? adapted.events.length - eventsToProcess.length
+        : undefined;
     let seq = existing.length > 0 ? Math.max(...existing.map((e) => e.seq)) : 0;
     let inserted = 0;
     let skipped = 0;
     const toInsert = [];
-    for (const event of adapted.events) {
+    for (const event of eventsToProcess) {
         const candidate = buildCanonicalEvent(sessionId, seq + 1, event, fallbackTs);
         if (doDedupe) {
             if (isMerge && existingSemanticKeys.has(semanticDedupeKey(candidate))) {
@@ -402,7 +463,7 @@ export function ingestRawContent(raw, options = {}) {
         sessionPath = writeEventsAppend(sessionId, toInsert);
     }
     const rawPath = writeRawSidecar(sessionId, adapted.source, raw);
-    return {
+    const result = {
         session_id: sessionId,
         adapter: adapted.source,
         inserted,
@@ -412,6 +473,10 @@ export function ingestRawContent(raw, options = {}) {
         merge_strategy: sessionSelection.strategy,
         merge_confidence: sessionSelection.fingerprint_confidence,
     };
+    if (filteredOutByTimeWindow !== undefined) {
+        result.filtered_out_by_time_window = filteredOutByTimeWindow;
+    }
+    return result;
 }
 export function ingestRawFile(filePath, options = {}) {
     const raw = readFileSync(filePath, "utf-8");

package/dist/local-analysis.d.ts

@@ -0,0 +1,91 @@
+import type { CanonicalEvent } from "./event-envelope.js";
+export type FollowupMode = "per_intent" | "session";
+export type FollowupStrictness = "soft" | "advisory" | "hard";
+export type FollowupFocus = "risk" | "verification_gap" | "hotspot" | "rework_pattern" | "efficiency";
+export type RuleTemplateId = "high_risk_guardrail" | "verification_loop_control" | "context_retrieval_limit" | "file_check_dedup" | "hotspot_change_gate";
+export interface ValueClaims {
+    risk_mitigation: string[];
+    efficiency_improvement: string[];
+    quality_standardization: string[];
+}
+export interface EvidenceRef {
+    event_id: string;
+    reason: string;
+    file?: string;
+}
+export interface IntentRuleFeatures {
+    intent_id: string;
+    intent_title: string;
+    risk_score: number;
+    efficiency_waste_score: number;
+    stability_score: number;
+    high_risk_signals: number;
+    verification_fail_count: number;
+    verification_unknown_count: number;
+    hotspot_score: number;
+    repeated_call_count: number;
+    repeated_file_check_count: number;
+    file_ops_count: number;
+    token_total: number;
+}
+export interface FollowupArtifact {
+    intent_id: string;
+    intent_title: string;
+    confidence: number;
+    rule_template_id: RuleTemplateId;
+    features: IntentRuleFeatures;
+    value_claims: ValueClaims;
+    evidence_refs: EvidenceRef[];
+    rule_spec: Record<string, unknown>;
+    skill_draft: string;
+    insufficient_evidence?: boolean;
+}
+export interface FollowupSummary {
+    intent_count: number;
+    high_risk_intents: number;
+    high_efficiency_waste_intents: number;
+    avg_confidence: number;
+}
+export interface FollowupGenerationResult {
+    artifacts: FollowupArtifact[];
+    summary: FollowupSummary;
+    insufficient_evidence: boolean;
+}
+export interface TokenSplitAttribution {
+    checkpoint_event_id: string;
+    total_tokens: number;
+    context_tokens: number;
+    output_tokens: number;
+    unknown_tokens: number;
+    neighbor_event_ids: string[];
+}
+export interface IntentTokenBreakdown {
+    intent_id: string;
+    intent_title: string;
+    total_tokens: number;
+    context_tokens: number;
+    output_tokens: number;
+    unknown_tokens: number;
+    estimated_cost_usd?: number;
+    event_window: {
+        start_seq: number;
+        end_seq: number;
+    };
+    supporting_events: TokenSplitAttribution[];
+}
+export interface TokenBreakdownResult {
+    intent_breakdown: IntentTokenBreakdown[];
+    totals: {
+        total_tokens: number;
+        context_tokens: number;
+        output_tokens: number;
+        unknown_tokens: number;
+        estimated_cost_usd?: number;
+    };
+}
+export declare function generateFollowupArtifacts(events: CanonicalEvent[], input?: {
+    mode?: FollowupMode;
+    strictness?: FollowupStrictness;
+    focus?: FollowupFocus;
+}): FollowupGenerationResult;
+export declare function deriveIntentTokenBreakdown(events: CanonicalEvent[]): TokenBreakdownResult;

package/dist/local-analysis.js

@@ -0,0 +1,517 @@
+const MAX_REPEATED_CHECKS_SOFT = 3;
+const MAX_REPEATED_CALLS_SOFT = 4;
+const TOKEN_NEIGHBORHOOD_RADIUS_SEQ = 5;
+const MIN_RULE_CONFIDENCE = 0.45;
+function toNumber(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : 0;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toStringValue(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function payload(event) {
+    return event.payload ?? {};
+}
+function getIntentId(event) {
+    const p = payload(event);
+    const payloadIntent = toStringValue(p.intent_id);
+    return event.scope?.intent_id ?? payloadIntent;
+}
+function getIntentTitle(event) {
+    const p = payload(event);
+    return toStringValue(p.title) ?? toStringValue(p.description);
+}
+function getFileTarget(event) {
+    if (event.kind !== "file_op")
+        return undefined;
+    const p = payload(event);
+    return toStringValue(p.target) ?? event.scope?.file;
+}
+function getTokenUsage(event) {
+    const p = payload(event);
+    const direct = p.usage;
+    const details = p.details;
+    const nested = details && typeof details === "object" ? details.llm_usage : undefined;
+    const usage = direct && typeof direct === "object"
+        ? direct
+        : nested && typeof nested === "object"
+            ? nested
+            : null;
+    if (!usage)
+        return null;
+    const prompt = toNumber(usage.prompt_tokens);
+    const completion = toNumber(usage.completion_tokens);
+    const totalRaw = toNumber(usage.total_tokens);
+    const total = totalRaw > 0 ? totalRaw : prompt + completion;
+    if (total <= 0)
+        return null;
+    const cost = toNumber(usage.estimated_cost_usd);
+    return {
+        total_tokens: total,
+        estimated_cost_usd: cost > 0 ? cost : undefined,
+    };
+}
+function percentile(values, p) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const idx = Math.max(0, Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p)));
+    return sorted[idx];
+}
+function buildIntentBuckets(eventsRaw) {
+    const events = [...eventsRaw].sort((a, b) => (a.seq === b.seq ? a.ts.localeCompare(b.ts) : a.seq - b.seq));
+    const boundaryEvents = events.filter((event) => event.kind === "intent");
+    const boundaries = boundaryEvents.map((event) => ({
+        intent_id: getIntentId(event) ?? `intent_${event.seq}`,
+        intent_title: getIntentTitle(event) ?? `Intent ${event.seq}`,
+        seq: event.seq,
+    }));
+    const boundaryById = new Map(boundaries.map((item) => [item.intent_id, item.intent_title]));
+    const fallbackId = "intent_fallback";
+    const byIntent = new Map();
+    function inferIntent(event) {
+        const explicit = getIntentId(event);
+        if (explicit)
+            return explicit;
+        let latest;
+        for (const boundary of boundaries) {
+            if (boundary.seq <= event.seq)
+                latest = boundary.intent_id;
+            else
+                break;
+        }
+        return latest ?? fallbackId;
+    }
+    for (const event of events) {
+        if (event.kind === "session_start" || event.kind === "session_end")
+            continue;
+        const intentId = inferIntent(event);
+        const list = byIntent.get(intentId) ?? [];
+        list.push(event);
+        byIntent.set(intentId, list);
+    }
+    const orderedIds = [...new Set([...boundaries.map((item) => item.intent_id), ...byIntent.keys()])];
+    return orderedIds.map((intentId) => {
+        const intentEvents = byIntent.get(intentId) ?? [];
+        const startSeq = intentEvents[0]?.seq ?? 0;
+        const endSeq = intentEvents[intentEvents.length - 1]?.seq ?? startSeq;
+        return {
+            intent_id: intentId,
+            intent_title: boundaryById.get(intentId) ?? (intentId === fallbackId ? "Fallback intent" : intentId),
+            start_seq: startSeq,
+            end_seq: endSeq,
+            events: intentEvents,
+        };
+    });
+}
+function isFileCheckEvent(event) {
+    if (event.kind !== "tool_call")
+        return false;
+    const p = payload(event);
+    const action = (toStringValue(p.action) ?? "").toLowerCase();
+    const target = (toStringValue(p.target) ?? "").toLowerCase();
+    if (!action && !target)
+        return false;
+    const looksCheck = /(read|cat|open|view|inspect|grep|rg|ls|stat)/.test(action);
+    const looksFile = /\/|\\|\.ts$|\.tsx$|\.js$|\.json$|\.md$|\.yml$|\.yaml$/.test(target);
+    return looksCheck || looksFile;
+}
+function isContextEvent(event) {
+    if (event.kind === "tool_call") {
+        const category = toStringValue(payload(event).category);
+        return category === "search" || category === "tool" || category === "execution";
+    }
+    if (event.kind === "artifact_created") {
+        const module = (event.scope?.module ?? "").toLowerCase();
+        const artifactType = (toStringValue(payload(event).artifact_type) ?? "").toLowerCase();
+        return module === "reasoning" || artifactType === "reasoning";
+    }
+    return false;
+}
+function isOutputEvent(event) {
+    if (event.kind === "file_op" || event.kind === "diff_summary")
+        return true;
+    if (event.kind === "artifact_created") {
+        const artifactType = (toStringValue(payload(event).artifact_type) ?? "").toLowerCase();
+        return ["file", "patch", "report", "test", "build", "migration", "pr"].includes(artifactType);
+    }
+    return false;
+}
+function deriveIntentFeatures(bucket, repeatedCallThreshold, repeatedCheckThreshold) {
+    const evidence = [];
+    let highRiskSignals = 0;
+    let verificationFailCount = 0;
+    let verificationUnknownCount = 0;
+    let hotspotScore = 0;
+    let fileOpsCount = 0;
+    let tokenTotal = 0;
+    let tokenCost = 0;
+    const callKeyCount = new Map();
+    const fileCheckCount = new Map();
+    const editedFiles = new Set();
+    let diffSummaryCount = 0;
+    let outputArtifacts = 0;
+    for (const event of bucket.events) {
+        const p = payload(event);
+        if (event.kind === "risk_signal") {
+            const level = toStringValue(p.level) ?? "low";
+            if (level === "high")
+                highRiskSignals += 3;
+            else if (level === "medium")
+                highRiskSignals += 2;
+            else
+                highRiskSignals += 1;
+            evidence.push({ event_id: event.id, reason: `risk_signal:${level}`, file: event.scope?.file });
+        }
+        if (event.kind === "assumption") {
+            const risk = toStringValue(p.risk);
+            if (risk === "high")
+                highRiskSignals += 2;
+            else if (risk === "medium")
+                highRiskSignals += 1;
+        }
+        if (event.kind === "verification") {
+            const result = toStringValue(p.result);
+            if (result === "fail") {
+                verificationFailCount += 1;
+                evidence.push({ event_id: event.id, reason: "verification:fail", file: event.scope?.file });
+            }
+            else if (result === "unknown") {
+                verificationUnknownCount += 1;
+            }
+        }
+        if (event.kind === "hotspot") {
+            const score = toNumber(p.score);
+            hotspotScore += score;
+            evidence.push({ event_id: event.id, reason: `hotspot:${score}`, file: toStringValue(p.file) ?? event.scope?.file });
+        }
+        if (event.kind === "tool_call") {
+            const key = `${toStringValue(p.action) ?? "unknown"}::${toStringValue(p.target) ?? ""}`;
+            callKeyCount.set(key, (callKeyCount.get(key) ?? 0) + 1);
+            if (isFileCheckEvent(event)) {
+                const target = toStringValue(p.target) ?? toStringValue(event.scope?.file) ?? "unknown";
+                fileCheckCount.set(target, (fileCheckCount.get(target) ?? 0) + 1);
+            }
+        }
+        if (event.kind === "file_op") {
+            fileOpsCount += 1;
+            const action = toStringValue(p.action);
+            if (action === "create" || action === "edit" || action === "delete") {
+                const target = getFileTarget(event);
+                if (target)
+                    editedFiles.add(target);
+            }
+        }
+        if (event.kind === "diff_summary")
+            diffSummaryCount += 1;
+        if (event.kind === "artifact_created" && isOutputEvent(event))
+            outputArtifacts += 1;
+        const usage = getTokenUsage(event);
+        if (usage) {
+            tokenTotal += usage.total_tokens;
+            tokenCost += usage.estimated_cost_usd ?? 0;
+        }
+    }
+    const repeatedCallCount = [...callKeyCount.values()].reduce((sum, count) => {
+        return sum + (count > repeatedCallThreshold ? count - repeatedCallThreshold : 0);
+    }, 0);
+    const repeatedFileCheckCount = [...fileCheckCount.entries()].reduce((sum, [target, count]) => {
+        if (count <= repeatedCheckThreshold)
+            return sum;
+        if (editedFiles.has(target))
+            return sum;
+        return sum + (count - repeatedCheckThreshold);
+    }, 0);
+    const deliverableDelta = fileOpsCount + diffSummaryCount + outputArtifacts;
+    const lowDeliverableWithHighToken = tokenTotal > 0 && tokenTotal > 2000 && deliverableDelta <= 1 ? 1 : 0;
+    const verificationLoop = verificationFailCount + verificationUnknownCount >= 3 ? 1 : 0;
+    const riskScoreRaw = highRiskSignals * 12 + verificationFailCount * 16 + Math.min(20, hotspotScore);
+    const efficiencyScoreRaw = repeatedCallCount * 10 + repeatedFileCheckCount * 12 + verificationLoop * 10 + lowDeliverableWithHighToken * 14;
+    const stabilityRaw = 100 - (verificationFailCount * 12 + verificationUnknownCount * 5 + repeatedCallCount * 2);
+    const riskScore = Math.max(0, Math.min(100, Math.round(riskScoreRaw)));
+    const efficiencyWasteScore = Math.max(0, Math.min(100, Math.round(efficiencyScoreRaw)));
+    const stabilityScore = Math.max(0, Math.min(100, Math.round(stabilityRaw)));
+    let template = "context_retrieval_limit";
+    if (riskScore >= 65 || (highRiskSignals >= 3 && verificationFailCount > 0))
+        template = "high_risk_guardrail";
+    else if (verificationLoop)
+        template = "verification_loop_control";
+    else if (repeatedFileCheckCount > 0)
+        template = "file_check_dedup";
+    else if (hotspotScore >= 8)
+        template = "hotspot_change_gate";
+    if (evidence.length === 0) {
+        const fallbackEvent = bucket.events.find((event) => event.kind === "tool_call" || event.kind === "file_op");
+        if (fallbackEvent)
+            evidence.push({ event_id: fallbackEvent.id, reason: "behavioral_pattern", file: fallbackEvent.scope?.file });
+    }
+    return {
+        features: {
+            intent_id: bucket.intent_id,
+            intent_title: bucket.intent_title,
+            risk_score: riskScore,
+            efficiency_waste_score: efficiencyWasteScore,
+            stability_score: stabilityScore,
+            high_risk_signals: highRiskSignals,
+            verification_fail_count: verificationFailCount,
+            verification_unknown_count: verificationUnknownCount,
+            hotspot_score: Number(hotspotScore.toFixed(2)),
+            repeated_call_count: repeatedCallCount,
+            repeated_file_check_count: repeatedFileCheckCount,
+            file_ops_count: fileOpsCount,
+            token_total: tokenTotal,
+        },
+        template,
+        evidence: evidence.slice(0, 12),
+        thresholdHints: {
+            repeated_call_threshold: repeatedCallThreshold,
+            repeated_check_threshold: repeatedCheckThreshold,
+            verification_loop_threshold: 3,
+            low_delta_token_threshold: 2000,
+            estimated_cost_usd: Number(tokenCost.toFixed(6)),
+        },
+    };
+}
+function valueClaimsForTemplate(template, features) {
+    const risk_mitigation = [];
+    const efficiency_improvement = [];
+    const quality_standardization = [];
+    if (template === "high_risk_guardrail" || features.verification_fail_count > 0 || features.high_risk_signals > 0) {
+        risk_mitigation.push("Mitigates high-risk regressions by enforcing stronger verification gates.");
+    }
+    if (template === "file_check_dedup" || template === "context_retrieval_limit" || features.repeated_call_count > 0) {
+        efficiency_improvement.push("Reduces unnecessary repeated calls/checks by applying bounded retrieval guardrails.");
+    }
+    quality_standardization.push("Standardizes intent execution with explicit evidence-based guardrails.");
+    return { risk_mitigation, efficiency_improvement, quality_standardization };
+}
+function buildRuleSpec(template, features, strictness, focus, thresholdHints, evidence) {
+    const softGuardrailAction = strictness === "soft"
+        ? "warn_and_recommend"
+        : strictness === "advisory"
+            ? "recommend_only"
+            : "block_until_ack";
+    return {
+        version: 1,
+        template_id: template,
+        focus,
+        strictness,
+        intent_id: features.intent_id,
+        intent_title: features.intent_title,
+        scores: {
+            risk_score: features.risk_score,
+            efficiency_waste_score: features.efficiency_waste_score,
+            stability_score: features.stability_score,
+        },
+        thresholds: thresholdHints,
+        soft_guardrails: [
+            {
+                trigger: "repeated_file_check_without_edit",
+                threshold: thresholdHints.repeated_check_threshold,
+                action: softGuardrailAction,
+                recommendation: "Consolidate file inspection and defer duplicate checks until meaningful edits occur.",
+            },
+            {
+                trigger: "repeated_tool_call_same_target",
+                threshold: thresholdHints.repeated_call_threshold,
+                action: softGuardrailAction,
+                recommendation: "Cache previously gathered context and avoid repeated identical retrieval calls.",
+            },
+        ],
+        expected_outcomes: {
+            risk_reduction: features.risk_score >= 50 || features.verification_fail_count > 0,
+            efficiency_gain: features.efficiency_waste_score >= 35,
+            reduced_unnecessary_checks: features.repeated_file_check_count > 0 || features.repeated_call_count > 0,
+        },
+        evidence_refs: evidence,
+    };
+}
+function buildSkillDraft(features, template, claims, thresholdHints, evidence) {
+    return [
+        `# Skill: ${features.intent_title} Guardrail`,
+        "",
+        "## Purpose",
+        "Apply deterministic checks that reduce wasteful context gathering and mitigate risk in similar tasks.",
+        "",
+        "## Template",
+        `- ${template}`,
+        "",
+        "## Value",
+        ...(claims.risk_mitigation.length > 0 ? claims.risk_mitigation.map((item) => `- ${item}`) : []),
+        ...(claims.efficiency_improvement.length > 0 ? claims.efficiency_improvement.map((item) => `- ${item}`) : []),
+        ...(claims.quality_standardization.length > 0
+            ? claims.quality_standardization.map((item) => `- ${item}`)
+            : []),
+        "",
+        "## Thresholds",
+        `- Repeated file checks threshold: ${thresholdHints.repeated_check_threshold}`,
+        `- Repeated call threshold: ${thresholdHints.repeated_call_threshold}`,
+        `- Verification loop threshold: ${thresholdHints.verification_loop_threshold}`,
+        "",
+        "## Workflow",
+        "1. Gather context once and cache references.",
+        "2. Avoid repeated retrieval calls for the same target unless state changed.",
+        "3. Prioritize edits and run targeted checks only when needed.",
+        "4. Escalate to full verification for high-risk or failing intents.",
+        "",
+        "## Evidence anchors",
+        ...evidence.map((item) => `- ${item.event_id}${item.file ? ` (${item.file})` : ""}: ${item.reason}`),
+        "",
+    ].join("\n");
+}
+function computeConfidence(features, evidenceCount) {
+    const strongSignals = (features.risk_score >= 55 ? 1 : 0) +
+        (features.efficiency_waste_score >= 45 ? 1 : 0) +
+        (features.verification_fail_count > 0 ? 1 : 0) +
+        (features.repeated_call_count > 0 ? 1 : 0) +
+        (features.repeated_file_check_count > 0 ? 1 : 0);
+    const confidence = 0.28 + strongSignals * 0.12 + Math.min(0.24, evidenceCount * 0.03);
+    return Math.max(0, Math.min(0.96, Number(confidence.toFixed(2))));
+}
+export function generateFollowupArtifacts(events, input = {}) {
+    const mode = input.mode ?? "per_intent";
+    const strictness = input.strictness ?? "soft";
+    const focus = input.focus ?? "risk";
+    const buckets = buildIntentBuckets(events);
+    const repeatedCallBaseline = percentile(buckets.map((bucket) => bucket.events.filter((event) => event.kind === "tool_call").length), 0.75);
+    const repeatedCheckBaseline = percentile(buckets.map((bucket) => bucket.events.filter((event) => isFileCheckEvent(event)).length), 0.75);
+    const repeatedCallThreshold = Math.max(MAX_REPEATED_CALLS_SOFT, Math.round(repeatedCallBaseline));
+    const repeatedCheckThreshold = Math.max(MAX_REPEATED_CHECKS_SOFT, Math.round(repeatedCheckBaseline));
+    const targetBuckets = mode === "session"
+        ? [
+            {
+                intent_id: "session_total",
+                intent_title: "Session aggregate",
+                start_seq: buckets[0]?.start_seq ?? 0,
+                end_seq: buckets[buckets.length - 1]?.end_seq ?? 0,
+                events: buckets.flatMap((bucket) => bucket.events),
+            },
+        ]
+        : buckets;
+    const artifacts = targetBuckets
+        .map((bucket) => {
+        const { features, template, evidence, thresholdHints } = deriveIntentFeatures(bucket, repeatedCallThreshold, repeatedCheckThreshold);
+        const valueClaims = valueClaimsForTemplate(template, features);
+        const confidence = computeConfidence(features, evidence.length);
+        const insufficient = confidence < MIN_RULE_CONFIDENCE;
+        return {
+            intent_id: bucket.intent_id,
+            intent_title: bucket.intent_title,
+            confidence,
+            rule_template_id: template,
+            features,
+            value_claims: valueClaims,
+            evidence_refs: evidence,
+            rule_spec: buildRuleSpec(template, features, strictness, focus, thresholdHints, evidence),
+            skill_draft: buildSkillDraft(features, template, valueClaims, thresholdHints, evidence),
+            insufficient_evidence: insufficient,
+        };
+    })
+        .sort((a, b) => b.features.risk_score + b.features.efficiency_waste_score - (a.features.risk_score + a.features.efficiency_waste_score));
+    const highRiskIntents = artifacts.filter((artifact) => artifact.features.risk_score >= 60).length;
+    const highWasteIntents = artifacts.filter((artifact) => artifact.features.efficiency_waste_score >= 50).length;
+    const avgConfidence = artifacts.length > 0
+        ? Number((artifacts.reduce((sum, artifact) => sum + artifact.confidence, 0) / artifacts.length).toFixed(2))
+        : 0;
+    return {
+        artifacts,
+        summary: {
+            intent_count: artifacts.length,
+            high_risk_intents: highRiskIntents,
+            high_efficiency_waste_intents: highWasteIntents,
+            avg_confidence: avgConfidence,
+        },
+        insufficient_evidence: artifacts.length === 0 || artifacts.every((artifact) => artifact.insufficient_evidence),
+    };
+}
+export function deriveIntentTokenBreakdown(events) {
+    const buckets = buildIntentBuckets(events);
+    const intentBreakdown = [];
+    let totalTokens = 0;
+    let contextTokens = 0;
+    let outputTokens = 0;
+    let unknownTokens = 0;
+    let cost = 0;
+    for (const bucket of buckets) {
+        const supporting = [];
+        let bucketTotal = 0;
+        let bucketContext = 0;
+        let bucketOutput = 0;
+        let bucketUnknown = 0;
+        let bucketCost = 0;
+        const tokenEvents = bucket.events.filter((event) => event.kind === "token_usage_checkpoint");
+        for (const checkpoint of tokenEvents) {
+            const usage = getTokenUsage(checkpoint);
+            if (!usage)
+                continue;
+            const neighbors = bucket.events.filter((event) => event.id !== checkpoint.id &&
+                Math.abs(event.seq - checkpoint.seq) <= TOKEN_NEIGHBORHOOD_RADIUS_SEQ);
+            const contextNeighbor = neighbors.filter((event) => isContextEvent(event));
+            const outputNeighbor = neighbors.filter((event) => isOutputEvent(event));
+            let contextPart = 0;
+            let outputPart = 0;
+            let unknownPart = 0;
+            if (contextNeighbor.length === 0 && outputNeighbor.length === 0) {
+                unknownPart = usage.total_tokens;
+            }
+            else if (contextNeighbor.length > 0 && outputNeighbor.length === 0) {
+                contextPart = usage.total_tokens;
+            }
+            else if (outputNeighbor.length > 0 && contextNeighbor.length === 0) {
+                outputPart = usage.total_tokens;
+            }
+            else {
+                const totalWeight = contextNeighbor.length + outputNeighbor.length;
+                contextPart = Math.round((usage.total_tokens * contextNeighbor.length) / totalWeight);
+                outputPart = usage.total_tokens - contextPart;
+            }
+            supporting.push({
+                checkpoint_event_id: checkpoint.id,
+                total_tokens: usage.total_tokens,
+                context_tokens: contextPart,
+                output_tokens: outputPart,
+                unknown_tokens: unknownPart,
+                neighbor_event_ids: neighbors.slice(0, 8).map((event) => event.id),
+            });
+            bucketTotal += usage.total_tokens;
+            bucketContext += contextPart;
+            bucketOutput += outputPart;
+            bucketUnknown += unknownPart;
+            bucketCost += usage.estimated_cost_usd ?? 0;
+        }
+        intentBreakdown.push({
+            intent_id: bucket.intent_id,
+            intent_title: bucket.intent_title,
+            total_tokens: bucketTotal,
+            context_tokens: bucketContext,
+            output_tokens: bucketOutput,
+            unknown_tokens: bucketUnknown,
+            estimated_cost_usd: bucketCost > 0 ? Number(bucketCost.toFixed(6)) : undefined,
+            event_window: {
+                start_seq: bucket.start_seq,
+                end_seq: bucket.end_seq,
+            },
+            supporting_events: supporting,
+        });
+        totalTokens += bucketTotal;
+        contextTokens += bucketContext;
+        outputTokens += bucketOutput;
+        unknownTokens += bucketUnknown;
+        cost += bucketCost;
+    }
+    return {
+        intent_breakdown: intentBreakdown.sort((a, b) => b.total_tokens - a.total_tokens),
+        totals: {
+            total_tokens: totalTokens,
+            context_tokens: contextTokens,
+            output_tokens: outputTokens,
+            unknown_tokens: unknownTokens,
+            estimated_cost_usd: cost > 0 ? Number(cost.toFixed(6)) : undefined,
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaolei.shawn/mcp-server",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Local-first MCP server for AI agent session auditing, with embedded dashboard.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,19 +16,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "npm run clean && tsc",
-    "start": "node dist/index.js start",
-    "dev": "tsc && node dist/index.js start",
-    "mcp": "node dist/index.js mcp",
-    "ingest": "node dist/index.js ingest",
-    "ingest:auto": "node dist/index.js ingest --adapter auto",
-    "ingest:codex": "node dist/index.js ingest --adapter codex_jsonl",
-    "ingest:cursor": "node dist/index.js ingest --adapter cursor_raw",
-    "test": "npm run build && node --test dist/__tests__/ingest.test.js",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^3.23.0"
@@ -61,5 +48,17 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc",
+    "start": "node dist/index.js start",
+    "dev": "tsc && node dist/index.js start",
+    "mcp": "node dist/index.js mcp",
+    "ingest": "node dist/index.js ingest",
+    "ingest:auto": "node dist/index.js ingest --adapter auto",
+    "ingest:codex": "node dist/index.js ingest --adapter codex_jsonl",
+    "ingest:cursor": "node dist/index.js ingest --adapter cursor_raw",
+    "test": "npm run build && node --test dist/__tests__/*.test.js"
   }
-}
+}