@wrongstack/core 0.313.0 → 0.316.1

package/dist/types/multi-agent.d.ts

@@ -82,6 +82,24 @@ export interface SubagentConfig {
      * caller input so a model cannot forge a shallower depth or larger budget.
      */
     spawnLineage?: SubagentSpawnLineage | undefined;
+    /**
+     * The conversation that ASKED for this spawn.
+     *
+     * The coordinator otherwise stamps a new worker with "which session is the
+     * host on right now", read from the host's own writer. In a single-session
+     * CLI those are the same answer. With four WebUI tabs sharing one process
+     * they are not: the host writer stays pinned to the boot tab, so every
+     * worker spawned from tabs 2-4 was filed under tab 1 — its lifecycle,
+     * budget and context events surfaced in the wrong roster, its spend was
+     * charged to the wrong conversation, and `stopSession` could not find it
+     * because nothing recorded who it belonged to.
+     *
+     * Set by the tools that spawn on an agent's behalf, from the run-pinned
+     * session of the caller. Absent (a host spawning for itself) the
+     * coordinator's live reading stands, which is what single-session hosts
+     * have always used.
+     */
+    originSessionId?: string | undefined;
     /**
      * Working directory for this subagent's tools. Defaults to the factory's
      * cwd. Goal sets this to a per-phase git worktree so parallel phases
@@ -116,6 +134,21 @@ export interface SubagentConfig {
      * → the factory's own default fallback behavior (usually the leader's config).
      */
     fallbackModels?: string[] | undefined;
+    /**
+     * Deterministic model tier for this subagent ('budget' | 'standard' |
+     * 'premium', or any user-defined level). Resolved at spawn time into a
+     * fallback profile, a budget, and runtime overrides. A tier only FILLS IN
+     * fields left unset — an explicit provider/model always wins over it.
+     */
+    tier?: string | undefined;
+    /**
+     * Budget field names the CALLER pinned explicitly (e.g. `delegate({ maxCostUsd })`).
+     * The tier layer never touches a pinned field: a number the user typed is a
+     * decision, while a roster default is just a default. Without this marker the
+     * two are indistinguishable at spawn time, because `applyRosterBudget` has
+     * already populated every budget field by then.
+     */
+    budgetPins?: readonly string[] | undefined;
     /**
      * Named live fallback profile for this subagent. Unlike `fallbackModels`, the
      * factory re-resolves this profile from ConfigStore on every provider attempt,
@@ -493,6 +526,16 @@ export interface SubagentRunContext {
     config: SubagentConfig;
     budget: SubagentBudget;
     signal: AbortSignal;
+    /**
+     * The session that spawned this subagent, fixed at spawn time.
+     *
+     * A worker belongs to one session for its whole life. Runners must stamp
+     * their events with THIS rather than re-reading the host's current session:
+     * with four tabs live, the host's session moves whenever the user switches
+     * tabs, and a late-firing event would then be filed under whichever tab
+     * happened to be in front.
+     */
+    sessionId?: string | undefined;
     /** Null until `setSubagentBridge` is called for this subagent. */
     bridge: AgentBridge | null;
     /** Publish a bounded in-memory snapshot that survives timeout races. */

package/dist/types/plugin.d.ts

@@ -1,7 +1,7 @@
 import type { Mailbox } from '../coordination/mailbox-types.js';
 import type { Notifier } from '../notifications/notifier.js';
 export type { Notifier };
-import type { ToolCallPipelinePayload } from '../core/agent.js';
+import type { ToolCallPipelinePayload } from '../core/agent-types.js';
 import type { AgentContext } from './context.js';
 import type { ExtensionRegistry } from '../extension/registry.js';
 import type { Container } from '../kernel/container.js';

package/dist/types/provider-runner.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderModelStatusTracker } from '../coordination/provider-status-tracker.js';
 import type { EventBus } from '../kernel/events.js';
 import type { AgentContext } from './context.js';
 import type { Logger } from './logger.js';
@@ -18,6 +19,13 @@ export interface RunProviderOptions {
     retry: RetryPolicy;
     logger: Logger;
     tracer?: Tracer | undefined;
+    /**
+     * Shared provider/model waiting room. A runner that honours it must refuse
+     * to call a quarantined (provider, model) pair and must report the wire
+     * outcome back — this funnel is the last line of defence that keeps a
+     * quota-exhausted route off the wire no matter which extensions are loaded.
+     */
+    statusTracker?: ProviderModelStatusTracker | undefined;
 }
 /**
  * A replaceable service for calling a provider with retry logic,

package/dist/types/provider.d.ts

@@ -103,6 +103,21 @@ export interface Usage {
 export declare function effectiveInputTokens(usage: Usage): number;
 /** Prompt tokens that were not served by a cache read. */
 export declare function freshInputTokens(usage: Usage): number;
+/**
+ * Every token this request moved — the complete prompt the model loaded plus
+ * what it generated.
+ *
+ * The single definition of `SessionSummary.tokenTotal`. Three call sites
+ * compute that field (the live writer's tracker, the disk-rebuild summary
+ * builder, and the SQLite catalog's transcript summarizer) and they had
+ * drifted: two summed only `input + output` while the third also counted the
+ * cache buckets. With prompt caching on, `cacheRead` is the bulk of a real
+ * prompt, so the narrow reading under-reported long sessions by more than an
+ * order of magnitude — one measured session listed 118,719 tokens against an
+ * actual 2,466,978. Route every tokenTotal through here so the three cannot
+ * disagree again.
+ */
+export declare function totalUsageTokens(usage: Usage): number;
 /**
  * Cache-read share of the complete prompt context, normalized to [0, 1].
  *

package/dist/types/runtime-capability-manifest.d.ts

@@ -69,7 +69,7 @@ export declare const RUNTIME_CAPABILITY_MANIFEST: readonly [{
     readonly id: 'coordination.mailbox';
     readonly pack: 'fleet';
     readonly exposure: 'direct';
-    readonly tools: readonly ["mailbox", "mail_send", "mail_inbox", "fleet_status"];
+    readonly tools: readonly ["mailbox", "mail_send", "mail_inbox", "fleet_status", "session_note"];
 }, {
     readonly id: 'fleet.delegate';
     readonly pack: 'fleet';

package/dist/types/secret-scrubber.d.ts

@@ -1,5 +1,20 @@
 export interface SecretScrubber {
     scrub(text: string): string;
     scrubObject<T>(obj: T): T;
+    /**
+     * Same redaction as {@link scrubObject}, but the result MAY SHARE structure
+     * with the input: any subtree that needed no redaction is returned by
+     * reference instead of being rebuilt.
+     *
+     * Only call this on a graph you exclusively own and will not mutate — a
+     * freshly `JSON.parse`d journal line, say. On anything still referenced
+     * elsewhere (a live conversation message queued for an async write), the
+     * shared subtrees would alias state that can still change underneath the
+     * consumer; use {@link scrubObject} there.
+     *
+     * Optional so existing implementations (and the object literals tests hand
+     * in) stay valid; callers fall back to {@link scrubObject}.
+     */
+    scrubObjectShared?<T>(obj: T): T;
 }
 //# sourceMappingURL=secret-scrubber.d.ts.map

package/dist/types/session-markers.d.ts

@@ -31,9 +31,40 @@ export interface SessionMarker {
     source: SessionEvent['type'];
     level: SessionMarkerLevel;
     text: string;
-    /** Set only for the `agent_*` sources. */
+    /** Set only for the `agent_*` and `delegate_*` sources. */
     agentId?: string | undefined;
+    /**
+     * The source event's own fields, for the sources a surface renders as
+     * something richer than a line of text.
+     *
+     * `text` stays the fallback every surface can always use. But the TUI draws
+     * a delegation as a labelled subagent row with its own icon, colour and
+     * compact stat line, and the WebUI as a two-line assistant message — both
+     * built from the structured payload, live. Handing replay only the rendered
+     * sentence would have forced those surfaces to show something they never
+     * showed while running, which is the exact divergence this module exists to
+     * prevent. Kept to the few sources that need it, and JSON-serializable so it
+     * survives the wire alongside the rest of the marker.
+     */
+    detail?: SessionMarkerDetail | undefined;
 }
+/** Structured payload for the marker sources whose surfaces render richly. */
+export type SessionMarkerDetail = {
+    kind: 'delegate_started';
+    target: string;
+    task: string;
+} | {
+    kind: 'delegate_completed';
+    target: string;
+    task: string;
+    ok: boolean;
+    status?: string | undefined;
+    summary: string;
+    durationMs: number;
+    iterations: number;
+    toolCalls: number;
+    costUsd?: number | undefined;
+};
 /**
  * Every event type that projects to a marker. Conversation-bearing events
  * (`user_input`, `llm_response`, `tool_*`) are deliberately excluded — those
@@ -41,15 +72,6 @@ export interface SessionMarker {
  * `message_appended` journal replay identically.
  */
 export declare const SESSION_MARKER_EVENT_TYPES: ReadonlySet<SessionEvent['type']>;
-/**
- * The subset chat-shaped surfaces (WebUI, SimpleUI, HQ Live Console) render.
- *
- * `checkpoint` is excluded: one is written per user prompt
- * (`agent-loop.ts` → `writeCheckpoint`), so in a chat transcript it would be a
- * line restating the user message immediately next to it. Dense timeline
- * surfaces like the TUI use {@link SESSION_MARKER_EVENT_TYPES} instead, where
- * the checkpoint marker doubles as a `/rewind` target hint.
- */
 export declare const CHAT_MARKER_SOURCES: ReadonlySet<SessionEvent['type']>;
 /**
  * Project one session event to a marker, or `null` when the event carries no
@@ -69,6 +91,11 @@ export declare function projectSessionMarkers(events: readonly SessionEvent[], s
  * as `user`/`system`-role messages by the agent loop at runtime (mailbox,
  * fleet pulse, loop detector, resume validation notices) but should NOT appear
  * in the human-facing chat history on session resume/replay.
+ *
+ * Also covers routing-noise error bubbles that the WebUI client has already
+ * swallowed live (`handleError` drops them) but that earlier turns may have
+ * persisted to the on-disk transcript — replay must not resurrect them into
+ * the human-visible chat.
  */
 export declare const SYSTEM_INJECTION_PREFIXES: readonly string[];
 /**

package/dist/types/session-markers.js

@@ -1,147 +1,11 @@
-// src/types/session-markers.ts
-var SESSION_MARKER_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "mode_changed",
-  "compaction",
-  "checkpoint",
-  "skill_activated",
-  "skill_deactivated",
-  "agent_spawned",
-  "agent_stopped",
-  "agent_error",
-  "error",
-  "provider_retry",
-  "provider_error",
-  "message_truncated"
-]);
-var CHAT_MARKER_SOURCES = new Set(
-  [...SESSION_MARKER_EVENT_TYPES].filter((type) => type !== "checkpoint")
-);
-function sessionEventToMarker(ev) {
-  switch (ev.type) {
-    case "compaction": {
-      const before = (ev.before / 1e3).toFixed(0);
-      const after = (ev.after / 1e3).toFixed(0);
-      const level = ev.level ? ` (${ev.level})` : "";
-      const reductions = ev.reductions && ev.reductions.length > 0 ? ` [${ev.reductions.map((r) => `${r.phase}: \u2212${r.saved}`).join(", ")}]` : "";
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `\u27F2 context compacted${level}: ${before}K \u2192 ${after}K tokens${reductions}`
-      };
-    }
-    case "error":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "error",
-        text: ev.phase ? `[${ev.phase}] ${ev.message}` : ev.message
-      };
-    case "provider_retry": {
-      const secs = (ev.delayMs / 1e3).toFixed(ev.delayMs >= 1e3 ? 1 : 2);
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "warn",
-        text: ev.status ? `\u27F3 retry ${ev.attempt} (HTTP ${ev.status}) after ${secs}s \u2014 ${ev.description}` : `\u27F3 retry ${ev.attempt} after ${secs}s \u2014 ${ev.description}`
-      };
-    }
-    case "provider_error":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "error",
-        text: ev.status ? `provider error (HTTP ${ev.status}, ${ev.retryable ? "retryable" : "fatal"}): ${ev.description}` : `provider error (${ev.retryable ? "retryable" : "fatal"}): ${ev.description}`
-      };
-    case "checkpoint":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `\u2713 checkpoint #${ev.promptIndex}: "${ev.promptPreview.slice(0, 60)}"`
-      };
-    case "agent_spawned":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `spawned as ${ev.role}`,
-        agentId: ev.agentId
-      };
-    case "agent_stopped":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: "stopped",
-        agentId: ev.agentId
-      };
-    case "agent_error":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "error",
-        text: `error: ${ev.error.slice(0, 80)}`,
-        agentId: ev.agentId
-      };
-    case "mode_changed":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `mode: ${ev.from} \u2192 ${ev.to}`
-      };
-    case "skill_activated":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `skill activated: ${ev.skillName}`
-      };
-    case "skill_deactivated":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "info",
-        text: `skill deactivated: ${ev.skillName}`
-      };
-    case "message_truncated":
-      return {
-        ts: ev.ts,
-        source: ev.type,
-        level: "warn",
-        text: ev.after < ev.before ? `message truncated: ${ev.before} \u2192 ${ev.after} tokens` : `message truncated at ${ev.after} tokens`
-      };
-    default:
-      return null;
-  }
-}
-function projectSessionMarkers(events, sources = SESSION_MARKER_EVENT_TYPES) {
-  const markers = [];
-  for (const ev of events) {
-    if (!sources.has(ev.type)) continue;
-    const marker = sessionEventToMarker(ev);
-    if (marker) markers.push(marker);
-  }
-  return markers;
-}
-var SYSTEM_INJECTION_PREFIXES = [
-  "[MAILBOX]",
-  "[MAILBOX BTW]",
-  "[BY THE WAY \u2014",
-  "[QUEUED MESSAGES \u2014",
-  "[FLEET PULSE]",
-  "[loop-detector]",
-  "[SESSION RESUME FILE VALIDATION]",
-  "[SESSION RESUME INTERRUPTED WORK]"
-];
-function isSystemInjectedMessage(text) {
-  const trimmed = text.trimStart();
-  for (const prefix of SYSTEM_INJECTION_PREFIXES) {
-    if (trimmed.startsWith(prefix)) return true;
-  }
-  return false;
-}
+import {
+  CHAT_MARKER_SOURCES,
+  SESSION_MARKER_EVENT_TYPES,
+  SYSTEM_INJECTION_PREFIXES,
+  isSystemInjectedMessage,
+  projectSessionMarkers,
+  sessionEventToMarker
+} from "../chunk-ULMAQV3T.js";
 export {
   CHAT_MARKER_SOURCES,
   SESSION_MARKER_EVENT_TYPES,

package/dist/types/session-timeline.d.ts

@@ -0,0 +1,197 @@
+import type { Message } from './messages.js';
+import { type SessionMarker, type SessionMarkerDetail } from './session-markers.js';
+import type { SessionEvent } from './session.js';
+/** An image the user attached to a prompt, as it survives in the journal. */
+export interface SessionTimelineImage {
+    mediaType?: string | undefined;
+    /** Base64 payload, when the block carried one. */
+    data?: string | undefined;
+    /** Remote URL, when the block referenced one instead. */
+    url?: string | undefined;
+}
+/**
+ * Tool-call metadata that lives in `tool_call_end` events rather than in the
+ * conversation.
+ *
+ * The message journal records WHICH tool ran with WHICH arguments and WHAT it
+ * returned; how long it took and how much it produced is audit detail, in a
+ * separate event keyed by the same `tool_use` id. The TUI reads both because
+ * it holds the raw event array; the browser surfaces are handed a projection
+ * over the wire, so this is the shape that projection carries.
+ */
+export interface SessionToolMeta {
+    /** The `tool_use` id this describes. */
+    id: string;
+    name?: string | undefined;
+    durationMs?: number | undefined;
+    outputBytes?: number | undefined;
+    outputTokens?: number | undefined;
+    outputLines?: number | undefined;
+    ok?: boolean | undefined;
+    /** Subagent that ran the tool; absent = the session's leader. */
+    agentId?: string | undefined;
+}
+interface TimelineEntryBase {
+    ts: string;
+}
+export interface SessionTimelineUserEntry extends TimelineEntryBase {
+    kind: 'user';
+    text: string;
+    /** Present only when the prompt carried image blocks. */
+    images?: SessionTimelineImage[] | undefined;
+}
+export interface SessionTimelineAssistantEntry extends TimelineEntryBase {
+    kind: 'assistant';
+    text: string;
+    /**
+     * True when this prose ended its turn. A message carrying a `tool_use` block
+     * stopped for a tool call, so its text is mid-turn — the surfaces use this to
+     * decide whether a `<nextsteps>` panel may appear.
+     */
+    final: boolean;
+}
+/** A conversation message with `role: 'system'` — resume notices and the like. */
+export interface SessionTimelineSystemEntry extends TimelineEntryBase {
+    kind: 'system';
+    text: string;
+}
+export interface SessionTimelineThinkingEntry extends TimelineEntryBase {
+    kind: 'thinking';
+    text: string;
+    /** 1-based ordinal across the whole timeline; surfaces label iterations with it. */
+    index: number;
+}
+export interface SessionTimelineToolEntry extends TimelineEntryBase {
+    kind: 'tool';
+    /** The provider's `tool_use` id, or the `tool_result`'s id for an orphan result. */
+    toolUseId: string;
+    name: string;
+    input?: unknown;
+    /** Untruncated result body. Surfaces decide their own preview length. */
+    output?: string | undefined;
+    /**
+     * `undefined` while a call has no result in the journal — the run was still
+     * executing it when the process stopped. A surface renders that as "running"
+     * or "interrupted"; it is NOT a failure, and reporting it as one is what the
+     * SimpleUI replay used to do.
+     */
+    ok?: boolean | undefined;
+    durationMs?: number | undefined;
+    outputBytes?: number | undefined;
+    outputTokens?: number | undefined;
+    outputLines?: number | undefined;
+    agentId?: string | undefined;
+}
+export interface SessionTimelineMarkerEntry extends TimelineEntryBase {
+    kind: 'marker';
+    source: SessionEvent['type'];
+    level: SessionMarker['level'];
+    text: string;
+    agentId?: string | undefined;
+    /** See {@link SessionMarker.detail} — structured fields for rich sources. */
+    detail?: SessionMarkerDetail | undefined;
+}
+export type SessionTimelineEntry = SessionTimelineUserEntry | SessionTimelineAssistantEntry | SessionTimelineSystemEntry | SessionTimelineThinkingEntry | SessionTimelineToolEntry | SessionTimelineMarkerEntry;
+/**
+ * Where a message's thinking blocks land relative to its prose.
+ *
+ * Not a style choice — it is what the surface did LIVE, and resume has to
+ * match the surface it is resuming into:
+ *
+ * - `'inline'` — one entry per thinking block, before the prose, in provider
+ *   block order. The TUI and SimpleUI stream thinking as it arrives and leave
+ *   it where it fell.
+ * - `'merged-after'` — one entry per message, carrying every thinking block
+ *   joined, emitted after that message's prose and tool calls. The WebUI keeps
+ *   a transient thinking bubble during a run and only commits the archived log
+ *   when the iteration completes, which is after the prose is on screen.
+ */
+export type ThinkingPlacement = 'inline' | 'merged-after';
+/**
+ * How a message's text blocks relate to the tool calls between them.
+ *
+ * Again a record of what the surface did LIVE, not a preference:
+ *
+ * - `'split'` — a text run becomes its own entry wherever a tool interrupts
+ *   it, so prose that followed a tool stays after that tool. The TUI and the
+ *   WebUI render a fresh bubble per run.
+ * - `'join'` — every text block of a message becomes ONE entry, emitted before
+ *   the message's tool entries. The SimpleUI streams a whole iteration into a
+ *   single bubble and lists tool calls beside it, so splitting would invent
+ *   bubbles that were never on screen.
+ */
+export type TextBlockMode = 'split' | 'join';
+export interface ProjectSessionTimelineInput {
+    /** The reconstructed conversation, as `SessionStore.load()` rebuilds it. */
+    messages: readonly Message[];
+    /**
+     * Raw journal events. Callers holding the JSONL (the TUI, the servers) pass
+     * this and markers/toolMeta are projected from it.
+     */
+    events?: readonly SessionEvent[] | undefined;
+    /** Pre-projected markers, for callers that received them over the wire. */
+    markers?: readonly SessionMarker[] | undefined;
+    /** Pre-projected tool metadata, for callers that received it over the wire. */
+    toolMeta?: readonly SessionToolMeta[] | undefined;
+    /**
+     * Which event types project to markers. Defaults to the dense
+     * {@link SESSION_MARKER_EVENT_TYPES}; chat-shaped surfaces pass
+     * `CHAT_MARKER_SOURCES`. Ignored when `markers` is supplied — the sender
+     * already applied its own set.
+     */
+    markerSources?: ReadonlySet<SessionEvent['type']> | undefined;
+    /** See {@link ThinkingPlacement}. Defaults to `'inline'`. */
+    thinkingPlacement?: ThinkingPlacement | undefined;
+    /** See {@link TextBlockMode}. Defaults to `'split'`. */
+    textBlocks?: TextBlockMode | undefined;
+    /**
+     * Glue between adjacent text blocks of one run. Defaults to `''` — the
+     * provider already streamed them as one continuous body, and inserting a
+     * separator would put a break where the live render had none.
+     */
+    textSeparator?: string | undefined;
+    /**
+     * Drop conversation messages the agent loop injected for the model's benefit
+     * (mailbox, fleet pulse, loop detector, resume notices). Defaults to true —
+     * every surface hides them, and a surface that wants the raw journal should
+     * read the events instead.
+     */
+    hideSystemInjections?: boolean | undefined;
+}
+/** Project the `tool_call_end` records of an event stream, keyed by tool id. */
+export declare function projectSessionToolMeta(events: Iterable<SessionEvent>): SessionToolMeta[];
+/**
+ * Size of the LAST prompt this session sent, from its journal.
+ *
+ * This is the number the context-fill bar means: how full the window was when
+ * the conversation last went to the model. Live, `ctx.lastRequestTokens` holds
+ * exactly that (the pre-flight total). Every resume path instead reached for
+ * `SessionData.usage.input`, which is the SUM of every request the session has
+ * ever made — so a long session came back claiming a nine-million-token
+ * context on a one-million-token model. Cumulative totals belong in the cost
+ * and usage readouts; they are never a fill source.
+ *
+ * The last `llm_response` carries that request's own usage, and its prompt is
+ * everything the provider counted on the way in: fresh input plus whatever it
+ * served or wrote through the cache — `effectiveInputTokens` in `provider.ts`,
+ * inlined here because this module must stay importable from a browser bundle
+ * and that one pulls a value chain behind it. Scanned from the end, so a 100k-
+ * event journal costs one step. Returns `undefined` when the session never reached
+ * the model — the caller must then leave the estimate unset rather than
+ * publish a zero, which reads as "0% full" instead of "not known yet".
+ */
+export declare function projectLastRequestTokens(events: readonly SessionEvent[] | undefined): number | undefined;
+/**
+ * Merge a session's conversation and audit streams into one ordered timeline.
+ *
+ * Ordering is a two-pointer merge of two sequences that are each already
+ * chronological — the message backbone by construction, the markers by journal
+ * order — so the conversation is never reordered: markers are only inserted
+ * between existing turns, and a tie keeps the backbone entry first. That is
+ * deliberately NOT a sort over the union: message timestamps repeat (every
+ * block of one message shares its `ts`), and sorting a repeated key moves tool
+ * calls away from the prose they belong to.
+ */
+export declare function projectSessionTimeline(input: ProjectSessionTimelineInput): SessionTimelineEntry[];
+export {};
+//# sourceMappingURL=session-timeline.d.ts.map

package/dist/types/session-timeline.js

@@ -0,0 +1,12 @@
+import {
+  projectLastRequestTokens,
+  projectSessionTimeline,
+  projectSessionToolMeta
+} from "../chunk-3BDV7RL3.js";
+import "../chunk-ULMAQV3T.js";
+export {
+  projectLastRequestTokens,
+  projectSessionTimeline,
+  projectSessionToolMeta
+};
+//# sourceMappingURL=session-timeline.js.map