@remixhq/claude-plugin 0.1.17 → 0.1.19

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "remix",
   "description": "Remix collaboration workflows for Claude Code",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "author": {
     "name": "Remix"
   },

package/README.md

@@ -14,3 +14,38 @@ Claude Code plugin for Remix collaboration workflows.
 ```bash
 /reload-plugins
 ```
+
+### Subscription tier (plan) capture
+
+When a Stop hook records a turn, the plugin attempts to resolve the user's
+Claude Code subscription tier (e.g. `pro`, `max`, `team`, `enterprise`) and
+attaches it to `agent.plan` on the recorded turn. The dashboard reads this
+field to display "Charged on Max" alongside per-turn cost.
+
+How it's resolved (no permission prompts):
+
+- The plugin spawns `claude auth status --json` and parses
+  `subscriptionType` from the result. Because this command runs as the
+  `claude` binary itself, macOS treats it as the keychain entry's owner
+  and returns the data silently.
+- The result is cached at
+  `${REMIX_COLLAB_STATE_ROOT:-~/.remix/collab-state}/claude-auth-cache.json`
+  for one hour (five minutes on failure), so most Stop hooks read the
+  cache file (~1 ms) rather than spawning `claude` (~150–500 ms).
+- Failure modes (`claude` not on PATH, non-zero exit, malformed JSON,
+  API-key-only auth, logged-out account) all degrade to `agent.plan = null`
+  with no exception thrown.
+
+Privacy posture:
+
+- Only `subscriptionType` is captured. Email, organization, and account
+  IDs are intentionally NOT recorded, because `agent.plan` ships in the
+  per-turn `workspace_metadata` blob that's visible to every collaborator
+  who can view the project's timeline.
+
+Configuration:
+
+- `REMIX_CLAUDE_AUTH_TIMEOUT_MS` — override the spawn timeout (default
+  `5000`).
+- `REMIX_COLLAB_STATE_ROOT` — override the cache directory (default
+  `~/.remix/collab-state`).

package/agents/remix-collab.md

@@ -1,6 +1,6 @@
 ---
 name: remix-collab
-description: Specialized Claude agent for Remix repository collaboration, merge request review, sync, reconcile, and change-step recording workflows.
+description: Specialized Claude agent for Remix repository collaboration, merge request review, sync, reconcile, and queued finalize-turn workflows.
 ---
 
 You are the Remix collaboration specialist.
@@ -15,10 +15,14 @@ Branch model:
 - If the current branch is unbound, initialize or provision that branch lane before continuing. Do not assume another branch's binding is safe to reuse.
 - If status reports a branch mismatch or missing branch binding, stop and resolve the branch state before recording or syncing.
 
+Source-blind recording rule:
+
+Any local content change since the last recorded turn — whether you typed it, the user typed it, a `git commit`, `git pull`, `git merge`, `git rebase`, or `git reset` produced it, or an IDE saved it — is recorded by exactly one `remix_collab_finalize_turn`. Do not pick a different command (`re-anchor`, `sync`, `reconcile`) based on what produced the change. Those commands are only correct when `remix_collab_status.recommendedAction` explicitly names them. `re-anchor` in particular is reserved for the narrow case where no local Remix baseline exists yet for this lane (status reports `re_anchor`); it is not a recovery for "the local content changed."
+
 Operating rules:
 
 1. Start with `remix_collab_status` for repo-bound collaboration tasks whenever the current state is unclear.
-2. In a Remix-bound repo, Remix MCP tools are the required workflow layer for collaboration state and historical reasoning. Raw git mutation commands must not be used for ordinary bound-repo collaboration work. Raw git reads are only acceptable for exact repository facts such as specific commits, blame, ancestry, or raw patch details.
+2. In a Remix-bound repo, Remix MCP tools are the required workflow layer for collaboration state and historical reasoning. Raw git mutations are allowed but never substitute for `remix_collab_finalize_turn`; after raw git mutations, run `remix_collab_status` and follow its `recommendedAction`. Raw git reads are only acceptable for exact repository facts such as specific commits, blame, ancestry, or raw patch details.
 3. Use preview tools before apply tools whenever both exist.
 4. Treat reconcile as a last-resort, high-risk path.
 5. Prefer bounded merge request diffs first, then expand only when necessary.
@@ -32,19 +36,24 @@ Operating rules:
 9. Clearly explain local mutation risk before using tools that can modify the local repo.
 10. In a bound repo, Remix MCP tools are the required workflow layer for ordinary collaboration work.
 11. In a bound repo, exactly one final `remix_collab_finalize_turn` is required before the final user-facing response.
-12. The final recording call must use the exact user prompt and your final assistant response.
-13. Do not finish the turn before recording. Do not make additional repo mutations after the final turn-recording call unless you intend to record again.
-14. Do not duplicate core business logic in reasoning. Use the MCP tools to inspect and execute the workflow.
+12. `remix_collab_finalize_turn` is queued only. A remote change step does not exist yet until the finalize queue drains successfully.
+13. The final recording call must use the exact user prompt and your final assistant response.
+14. If `remix_collab_status` reports `await_finalize`, use `remix_collab_drain_finalize_queue`, then re-check status before merge-related or recovery flows that depend on a remote recorded turn.
+15. Do not finish the turn before recording. Do not make additional repo mutations after the final turn-recording call unless you intend to record again.
+16. Do not duplicate core business logic in reasoning. Use the MCP tools to inspect and execute the workflow.
 
 When appropriate:
 
 - use `remix_collab_init` to bind the current repo
 - use `remix_collab_remix` to start from an existing app lineage
 - use `remix_collab_checkout` to continue work on an existing app id without creating a fork
+- when the user asks for any URL, link, dashboard, or web address of a Remix-bound repo or app (e.g. "what's the URL of this repo on Remix", "the link to this app", "where can I see this on the dashboard"), use `remix_collab_status` and answer with `binding.dashboardUrl` (already in the canonical `https://dashboard.remix.one/apps/<appId>` form). Do NOT answer with `binding.remoteUrl` — that is the git remote, not the Remix dashboard. If `binding.dashboardUrl` is null but `binding.currentAppId` is set, fall back to `https://dashboard.remix.one/apps/<currentAppId>`. Do not require an additional tool call beyond `remix_collab_status`.
 - when helping the user choose an app, prefer scoped or membership-oriented discovery first: use `organizationId` / `projectId` when known, or use `ownership` with `accessScope="explicit_member"` when the user means “apps I can work on”
 - reserve `accessScope="all_readable"` for explicit public or broad readable discovery, not as the default work-oriented app picker
 - use memory summary/search/timeline tools before repo inspection when historical context or reasoning is needed
 - use the explicit change-step diff tool only after you already know which `changeStepId` matters
 - use `remix_collab_finalize_turn` as the final turn recorder
+- treat `remix_collab_finalize_turn` as local capture plus queueing, not immediate remote materialization
+- use `remix_collab_drain_finalize_queue` and `remix_collab_status` when the workflow is blocked on `await_finalize`
 - use `remix_collab_review_queue` for reviewable merge requests, `remix_collab_my_merge_requests` for authored requests, and `remix_collab_list_app_merge_requests` for app-scoped MR flows with required `queue` set to `app_reviewable`, `app_outgoing`, or `app_related_visible`
 - use merge request tools for review and approval flows

package/dist/historical.d.ts

@@ -0,0 +1,31 @@
+import { TurnUsage } from '@remixhq/core/collab';
+
+type TranscriptEvent = Record<string, unknown>;
+type ReadTranscriptResult = {
+    ok: true;
+    events: TranscriptEvent[];
+} | {
+    ok: false;
+    reason: "transcript_not_found" | "transcript_unreadable";
+};
+declare function readAndParseTranscript(transcriptPath: string): Promise<ReadTranscriptResult>;
+
+type SlicedTurn = {
+    sessionId: string;
+    promptId: string | null;
+    promptText: string | null;
+    assistantText: string | null;
+    occurredAt: string;
+    gitBranch: string | null;
+    cwd: string | null;
+    usage: TurnUsage;
+};
+type SliceTranscriptInput = {
+    events: TranscriptEvent[];
+    sessionId: string;
+    capturedAt: string;
+    extensions?: Record<string, unknown> | null;
+};
+declare function sliceTranscriptIntoTurns(input: SliceTranscriptInput): SlicedTurn[];
+
+export { type ReadTranscriptResult, type SliceTranscriptInput, type SlicedTurn, type TranscriptEvent, readAndParseTranscript, sliceTranscriptIntoTurns };

package/dist/historical.js

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+
+// src/usage/claudeCodeTranscript.ts
+import fs from "fs/promises";
+async function readAndParseTranscript(transcriptPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(transcriptPath, "utf8");
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : null;
+    if (code === "ENOENT") {
+      return { ok: false, reason: "transcript_not_found" };
+    }
+    return { ok: false, reason: "transcript_unreadable" };
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return { ok: true, events };
+}
+
+// src/usage/claudeCodeUsageHarvester.ts
+function parseTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function extractUserContentText(message) {
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const textBlocks = content.filter((block) => Boolean(block) && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text);
+    if (textBlocks.length === 0) return null;
+    return textBlocks.join("\n");
+  }
+  return null;
+}
+function isUserBoundary(event) {
+  return event.type === "user" && event.isMeta !== true && event.isSidechain !== true;
+}
+function extractAssistantContentText(turnEvents) {
+  const chunks = [];
+  for (const ev of turnEvents) {
+    if (ev.type !== "assistant") continue;
+    const text = extractUserContentText(ev.message);
+    if (text && text.length > 0) chunks.push(text);
+  }
+  if (chunks.length === 0) return null;
+  const deduped = [];
+  for (const chunk of chunks) {
+    if (deduped[deduped.length - 1] !== chunk) deduped.push(chunk);
+  }
+  return deduped.join("\n");
+}
+function asNumberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function extractAssistantMessage(event) {
+  const message = event.message;
+  if (!message || typeof message !== "object") return null;
+  const msg = message;
+  if (msg.role !== "assistant" && msg.role !== void 0) {
+  }
+  const content = Array.isArray(msg.content) ? msg.content : [];
+  const usage = msg.usage && typeof msg.usage === "object" ? msg.usage : null;
+  return {
+    id: asStringOrNull(msg.id),
+    model: asStringOrNull(msg.model),
+    content,
+    usage
+  };
+}
+function usageIsComplete(usage) {
+  if (!usage) return false;
+  const hasInput = typeof usage.input_tokens === "number";
+  const hasOutput = typeof usage.output_tokens === "number";
+  const hasCacheRead = typeof usage.cache_read_input_tokens === "number";
+  return hasInput && hasOutput && hasCacheRead;
+}
+function buildModelCall(event, msg) {
+  const usage = msg.usage ?? {};
+  const cacheCreation = usage.cache_creation && typeof usage.cache_creation === "object" ? usage.cache_creation : null;
+  const has5m = cacheCreation && typeof cacheCreation.ephemeral_5m_input_tokens === "number";
+  const has1h = cacheCreation && typeof cacheCreation.ephemeral_1h_input_tokens === "number";
+  const cacheWrite5mTokens = has5m ? cacheCreation.ephemeral_5m_input_tokens : null;
+  const cacheWrite1hTokens = has1h ? cacheCreation.ephemeral_1h_input_tokens : null;
+  const splitAvailable = has5m || has1h;
+  const cacheWriteTokens = splitAvailable ? null : asNumberOrNull(usage.cache_creation_input_tokens);
+  return {
+    provider: "anthropic",
+    model: msg.model,
+    tier: asStringOrNull(usage.service_tier),
+    requestId: asStringOrNull(event.requestId),
+    timestamp: asStringOrNull(event.timestamp),
+    isSidechain: event.isSidechain === true,
+    inputTokens: asNumberOrNull(usage.input_tokens),
+    outputTokens: asNumberOrNull(usage.output_tokens),
+    cacheReadTokens: asNumberOrNull(usage.cache_read_input_tokens),
+    cacheWriteTokens,
+    cacheWrite5mTokens,
+    cacheWrite1hTokens,
+    reasoningTokens: null,
+    audioInputTokens: null,
+    imageInputTokens: null
+  };
+}
+function scanServerToolUses(content) {
+  const uses = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    const id = b.id;
+    if (typeof id !== "string" || !id.startsWith("srvtoolu_")) continue;
+    const name = typeof b.name === "string" ? b.name : "";
+    switch (name) {
+      case "web_search":
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "web_fetch":
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id, source: "direct" });
+        break;
+      case "code_execution":
+        uses.push({ tool: "code_execution", unit: "invocation", isKnown: true, id, source: "direct" });
+        break;
+      default:
+        uses.push({ tool: name || "unknown", unit: "invocation", isKnown: false, id, source: "direct" });
+        break;
+    }
+  }
+  return uses;
+}
+function buildClientToolNameMap(turnEvents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const ev of turnEvents) {
+    if (ev.type !== "assistant") continue;
+    const msg = ev.message;
+    if (!msg || typeof msg !== "object") continue;
+    const content = msg.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type !== "tool_use") continue;
+      const id = b.id;
+      const name = b.name;
+      if (typeof id !== "string" || typeof name !== "string") continue;
+      if (!id.startsWith("toolu_")) continue;
+      map.set(id, name);
+    }
+  }
+  return map;
+}
+function scanEmbeddedServerToolUses(turnEvents, clientToolNames) {
+  const uses = [];
+  for (const ev of turnEvents) {
+    if (ev.type !== "user") continue;
+    const tur = ev.toolUseResult;
+    if (!tur || typeof tur !== "object") continue;
+    const results = tur.results;
+    if (!Array.isArray(results)) continue;
+    let parentToolName = "";
+    const userMsg = ev.message;
+    if (userMsg && typeof userMsg === "object") {
+      const userContent = userMsg.content;
+      if (Array.isArray(userContent)) {
+        for (const block of userContent) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_result") continue;
+          const parentId = b.tool_use_id;
+          if (typeof parentId === "string") {
+            parentToolName = clientToolNames.get(parentId) ?? "";
+            break;
+          }
+        }
+      }
+    }
+    for (const entry of results) {
+      if (!entry || typeof entry !== "object") continue;
+      const srvId = entry.tool_use_id;
+      if (typeof srvId !== "string" || !srvId.startsWith("srvtoolu_")) continue;
+      if (parentToolName === "WebFetch") {
+        uses.push({ tool: "web_fetch", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      } else {
+        uses.push({ tool: "web_search", unit: "per_request", isKnown: true, id: srvId, source: "embedded" });
+      }
+    }
+  }
+  return uses;
+}
+function dedupeByServerToolId(records) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const existing = seen.get(r.id);
+    if (!existing) {
+      seen.set(r.id, r);
+      continue;
+    }
+    if (existing.source === "embedded" && r.source === "direct") {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+function aggregateServerTools(uses) {
+  const map = /* @__PURE__ */ new Map();
+  let sawUnknown = false;
+  let sawEmbedded = false;
+  for (const use of uses) {
+    if (!use.isKnown) sawUnknown = true;
+    if (use.source === "embedded") sawEmbedded = true;
+    const key = `anthropic|${use.tool}|${use.unit}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.quantity += 1;
+    } else {
+      map.set(key, { provider: "anthropic", tool: use.tool, unit: use.unit, quantity: 1 });
+    }
+  }
+  return { serverTools: Array.from(map.values()), sawUnknown, sawEmbedded };
+}
+function sumCrossCheckCounts(usageBlocks) {
+  const totals = /* @__PURE__ */ new Map();
+  const keyFor = (raw) => {
+    if (raw === "web_search_requests") return "web_search";
+    if (raw === "web_fetch_requests") return "web_fetch";
+    return null;
+  };
+  for (const usage of usageBlocks) {
+    const stu = usage.server_tool_use;
+    if (!stu || typeof stu !== "object") continue;
+    for (const [rawKey, rawVal] of Object.entries(stu)) {
+      const mapped = keyFor(rawKey);
+      if (!mapped) continue;
+      if (typeof rawVal !== "number" || !Number.isFinite(rawVal)) continue;
+      totals.set(mapped, (totals.get(mapped) ?? 0) + rawVal);
+    }
+  }
+  return totals;
+}
+function primaryToolCounts(serverTools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of serverTools) {
+    map.set(entry.tool, (map.get(entry.tool) ?? 0) + entry.quantity);
+  }
+  return map;
+}
+function resolveVersion(events) {
+  for (const ev of events) {
+    if (typeof ev.version === "string" && ev.version.trim()) return ev.version.trim();
+  }
+  return null;
+}
+function buildTurnUsage(args) {
+  const assistantEvents = args.turnEvents.filter((ev) => ev.type === "assistant");
+  if (assistantEvents.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  const warnings = [...args.initialWarnings];
+  const calls = [];
+  const usageBlocks = [];
+  let anyIncomplete = false;
+  let anyComplete = false;
+  let sawLumpSumFallback = false;
+  const collectedServerToolUses = [];
+  const mainModels = /* @__PURE__ */ new Set();
+  const sidechainModels = /* @__PURE__ */ new Set();
+  for (const ev of assistantEvents) {
+    const msg = extractAssistantMessage(ev);
+    if (!msg) continue;
+    if (usageIsComplete(msg.usage)) {
+      anyComplete = true;
+    } else {
+      anyIncomplete = true;
+    }
+    if (msg.usage) usageBlocks.push(msg.usage);
+    const call = buildModelCall(ev, msg);
+    calls.push(call);
+    if (call.cacheWrite5mTokens === null && call.cacheWrite1hTokens === null && call.cacheWriteTokens !== null) {
+      sawLumpSumFallback = true;
+    }
+    collectedServerToolUses.push(...scanServerToolUses(msg.content));
+    if (call.model) {
+      if (call.isSidechain) sidechainModels.add(call.model);
+      else mainModels.add(call.model);
+    }
+  }
+  if (calls.length === 0) {
+    return { ok: false, reason: "no_messages_for_turn" };
+  }
+  if (sawLumpSumFallback) {
+    warnings.push({
+      code: "cache_split_unavailable",
+      message: "Assistant message reported lump-sum cache_creation_input_tokens without the 5m/1h split."
+    });
+  }
+  const clientToolNames = buildClientToolNameMap(args.turnEvents);
+  const embeddedUses = scanEmbeddedServerToolUses(args.turnEvents, clientToolNames);
+  const merged = dedupeByServerToolId([...collectedServerToolUses, ...embeddedUses]);
+  const { serverTools, sawUnknown, sawEmbedded } = aggregateServerTools(merged);
+  if (sawUnknown) {
+    warnings.push({
+      code: "unknown_server_tool",
+      message: "Encountered a server tool whose name is not in the known list (web_search, web_fetch, code_execution)."
+    });
+  }
+  const crossCheck = sumCrossCheckCounts(usageBlocks);
+  const primary = primaryToolCounts(serverTools);
+  const allTools = /* @__PURE__ */ new Set([...crossCheck.keys(), ...primary.keys()]);
+  for (const tool of allTools) {
+    const crossVal = crossCheck.get(tool) ?? 0;
+    const primVal = primary.get(tool) ?? 0;
+    if (crossVal === primVal) continue;
+    if (sawEmbedded && crossVal === 0) continue;
+    warnings.push({
+      code: "server_tool_count_mismatch",
+      message: `Server-tool ${tool} count mismatch: srvtoolu_ scan=${primVal}, usage.server_tool_use=${crossVal}. Trusting srvtoolu_ count.`
+    });
+    break;
+  }
+  const subagentMismatch = mainModels.size > 0 && sidechainModels.size > 0 && [...sidechainModels].some((m) => !mainModels.has(m));
+  if (subagentMismatch) {
+    warnings.push({
+      code: "subagent_model_differs",
+      message: "At least one sidechain ModelCall uses a model different from the main-chain model in this turn."
+    });
+  }
+  let confidence;
+  if (!anyComplete && anyIncomplete) confidence = "unknown";
+  else if (anyIncomplete) confidence = "partial";
+  else if (anyComplete) confidence = "exact";
+  else confidence = "unknown";
+  if (args.checkSubsequentEvent) {
+    const lastAssistantMs = (() => {
+      const msList = assistantEvents.map((ev) => parseTimestamp(ev.timestamp)).filter((ms) => ms !== null);
+      return msList.length ? Math.max(...msList) : null;
+    })();
+    const hasSubsequent = lastAssistantMs !== null && args.sessionEvents.some((ev) => {
+      const ms = parseTimestamp(ev.timestamp);
+      if (ms === null || ms <= lastAssistantMs) return false;
+      if (args.upperMs !== null && ms >= args.upperMs) return false;
+      return true;
+    });
+    if (!hasSubsequent && confidence === "exact") {
+      confidence = "partial";
+      warnings.push({
+        code: "transcript_truncated",
+        message: "Previous turn has no subsequent event after its last assistant message; transcript may be truncated."
+      });
+    }
+  }
+  const resolvedVersion = args.agent.version ?? resolveVersion(args.turnEvents) ?? resolveVersion(args.sessionEvents);
+  const usage = {
+    schemaVersion: 1,
+    capturedAt: args.capturedAt,
+    captureSource: args.captureSource,
+    confidence,
+    agent: {
+      name: args.agent.name,
+      version: resolvedVersion,
+      sessionId: args.agent.sessionId,
+      turnId: args.agent.turnId,
+      plan: args.agent.plan
+    },
+    calls,
+    serverTools,
+    warnings,
+    extensions: args.extensions
+  };
+  return { ok: true, usage };
+}
+function sliceTranscriptIntoTurns(input) {
+  const sessionEvents = input.events.filter((ev) => ev.sessionId === input.sessionId);
+  const boundaries = sessionEvents.filter(isUserBoundary);
+  const result = [];
+  for (let i = 0; i < boundaries.length; i++) {
+    const boundary = boundaries[i];
+    const nextBoundary = boundaries[i + 1] ?? null;
+    const boundaryMs = parseTimestamp(boundary.timestamp);
+    if (boundaryMs === null) continue;
+    const occurredAt = asStringOrNull(boundary.timestamp);
+    if (occurredAt === null) continue;
+    const upperMs = nextBoundary ? parseTimestamp(nextBoundary.timestamp) : null;
+    const turnEvents = sessionEvents.filter((ev) => {
+      const ms = parseTimestamp(ev.timestamp);
+      if (ms === null || ms <= boundaryMs) return false;
+      if (upperMs !== null && ms >= upperMs) return false;
+      return true;
+    });
+    const promptId = asStringOrNull(boundary.promptId);
+    const promptText = extractUserContentText(boundary.message);
+    const assistantText = extractAssistantContentText(turnEvents);
+    const gitBranch = asStringOrNull(boundary.gitBranch);
+    const cwd = asStringOrNull(boundary.cwd);
+    const built = buildTurnUsage({
+      sessionEvents,
+      turnEvents,
+      upperMs,
+      initialWarnings: [],
+      agent: {
+        name: "claude-code",
+        version: null,
+        sessionId: input.sessionId,
+        turnId: promptId,
+        plan: null
+      },
+      capturedAt: input.capturedAt,
+      captureSource: "historical_import",
+      extensions: input.extensions ?? null,
+      checkSubsequentEvent: false
+    });
+    if (!built.ok) continue;
+    result.push({
+      sessionId: input.sessionId,
+      promptId,
+      promptText,
+      assistantText,
+      occurredAt,
+      gitBranch,
+      cwd,
+      usage: built.usage
+    });
+  }
+  return result;
+}
+export {
+  readAndParseTranscript,
+  sliceTranscriptIntoTurns
+};
+//# sourceMappingURL=historical.js.map