@remixhq/core 0.1.14 → 0.1.16

package/dist/api.d.ts

@@ -1,6 +1,6 @@
 import { CoreConfig } from './config.js';
 import { T as TokenProvider } from './tokenProvider-BWTusyj4.js';
-import { E as TurnUsage } from './contracts-NbV3P_Rl.js';
+import { T as TurnUsage } from './contracts-CHmD-fMj.js';
 import 'zod';
 
 type HistoryImportProvider = "claude_code" | "cursor";

package/dist/collab.d.ts

@@ -1,5 +1,5 @@
-import { C as CollabApiClient, T as TurnUsagePayload, a as CollabFinalizeTurnResult, b as CollabRecordingPreflight, c as CollabApproveMode, d as CollabApproveResult, M as MergeRequestQueue, e as MergeRequest, I as InvitationScopeType, f as CollabMember, J as JsonObject, A as AppDeltaResponse, g as CollabStatus, h as MergeRequestReview } from './contracts-NbV3P_Rl.js';
-export { i as AppHeadResponse, j as AppMember, k as AppMemberRole, l as AppReconcileResponse, m as CollabFinalizeTurnAutoSync, n as CollabFinalizeTurnMode, o as CollabPendingFinalizeState, p as CollabPendingFinalizeSummary, q as CollabRecordingPreflightStatus, r as CollabRepoStateKind, s as CollabStatusBlockedReason, t as CollabStatusRecommendedAction, u as CollabTurn, v as MembershipScopeType, w as MergeRequestStatus, x as ModelCall, O as OrganizationMember, y as OrganizationMemberRole, P as ProjectMember, z as ProjectMemberRole, R as ReconcilePreflightResponse, S as ServerToolUsage, B as SyncLocalResponse, D as SyncUpstreamResponse, E as TurnUsage, F as TurnUsageCaptureSource, G as TurnUsageConfidence, H as TurnUsagePreviousPatch } from './contracts-NbV3P_Rl.js';
+import { C as CollabApiClient, a as TurnUsagePayload, b as CollabFinalizeTurnResult, c as CollabRecordingPreflight, d as CollabApproveMode, e as CollabApproveResult, M as MergeRequestQueue, f as MergeRequest, I as InvitationScopeType, g as CollabMember, J as JsonObject, A as AppDeltaResponse, h as CollabStatus, i as MergeRequestReview } from './contracts-CHmD-fMj.js';
+export { j as AppHeadResponse, k as AppMember, l as AppMemberRole, m as AppReconcileResponse, n as CollabFinalizeTurnAutoSync, o as CollabFinalizeTurnMode, p as CollabPendingFinalizeState, q as CollabPendingFinalizeSummary, r as CollabRecordingPreflightStatus, s as CollabRepoStateKind, t as CollabStatusBlockedReason, u as CollabStatusRecommendedAction, v as CollabTurn, w as MembershipScopeType, x as MergeRequestStatus, y as ModelCall, O as OrganizationMember, z as OrganizationMemberRole, P as ProjectMember, B as ProjectMemberRole, R as ReconcilePreflightResponse, S as ServerToolUsage, D as SyncLocalResponse, E as SyncUpstreamResponse, T as TurnUsage, F as TurnUsageCaptureSource, G as TurnUsageConfidence, H as TurnUsagePreviousPatch } from './contracts-CHmD-fMj.js';
 import { B as BranchBindingMode } from './binding-WiIRI2fl.js';
 
 declare function collabFinalizeTurn(params: {

package/dist/collab.js

@@ -1,3 +1,4 @@
+import "./chunk-HZNEDSRS.js";
 import {
   getCollabBindingPath,
   readCollabBinding,
@@ -8,7 +9,6 @@ import {
   writeCollabBindingSnapshot,
   writeJsonAtomic
 } from "./chunk-YCFLOHJV.js";
-import "./chunk-HZNEDSRS.js";
 import {
   applyUnifiedDiffToWorktree,
   assertRepoSnapshotUnchanged,

package/dist/{contracts-NbV3P_Rl.d.ts → contracts-CHmD-fMj.d.ts}

@@ -674,4 +674,4 @@ type CollabApiClient = {
     }): Promise<unknown>;
 };
 
-export type { AppDeltaResponse as A, SyncLocalResponse as B, CollabApiClient as C, SyncUpstreamResponse as D, TurnUsage as E, TurnUsageCaptureSource as F, TurnUsageConfidence as G, TurnUsagePreviousPatch as H, InvitationScopeType as I, JsonObject as J, MergeRequestQueue as M, OrganizationMember as O, ProjectMember as P, ReconcilePreflightResponse as R, ServerToolUsage as S, TurnUsagePayload as T, CollabFinalizeTurnResult as a, CollabRecordingPreflight as b, CollabApproveMode as c, CollabApproveResult as d, MergeRequest as e, CollabMember as f, CollabStatus as g, MergeRequestReview as h, AppHeadResponse as i, AppMember as j, AppMemberRole as k, AppReconcileResponse as l, CollabFinalizeTurnAutoSync as m, CollabFinalizeTurnMode as n, CollabPendingFinalizeState as o, CollabPendingFinalizeSummary as p, CollabRecordingPreflightStatus as q, CollabRepoStateKind as r, CollabStatusBlockedReason as s, CollabStatusRecommendedAction as t, CollabTurn as u, MembershipScopeType as v, MergeRequestStatus as w, ModelCall as x, OrganizationMemberRole as y, ProjectMemberRole as z };
+export type { AppDeltaResponse as A, ProjectMemberRole as B, CollabApiClient as C, SyncLocalResponse as D, SyncUpstreamResponse as E, TurnUsageCaptureSource as F, TurnUsageConfidence as G, TurnUsagePreviousPatch as H, InvitationScopeType as I, JsonObject as J, MergeRequestQueue as M, OrganizationMember as O, ProjectMember as P, ReconcilePreflightResponse as R, ServerToolUsage as S, TurnUsage as T, TurnUsagePayload as a, CollabFinalizeTurnResult as b, CollabRecordingPreflight as c, CollabApproveMode as d, CollabApproveResult as e, MergeRequest as f, CollabMember as g, CollabStatus as h, MergeRequestReview as i, AppHeadResponse as j, AppMember as k, AppMemberRole as l, AppReconcileResponse as m, CollabFinalizeTurnAutoSync as n, CollabFinalizeTurnMode as o, CollabPendingFinalizeState as p, CollabPendingFinalizeSummary as q, CollabRecordingPreflightStatus as r, CollabRepoStateKind as s, CollabStatusBlockedReason as t, CollabStatusRecommendedAction as u, CollabTurn as v, MembershipScopeType as w, MergeRequestStatus as x, ModelCall as y, OrganizationMemberRole as z };

package/dist/history.d.ts

@@ -0,0 +1,64 @@
+import { T as TurnUsage } from './contracts-CHmD-fMj.js';
+
+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>;
+
+declare const HARVESTER_WARNING_CODES: readonly ["cache_split_unavailable", "unknown_server_tool", "transcript_truncated", "subagent_model_differs", "server_tool_count_mismatch"];
+type HarvesterWarningCode = (typeof HARVESTER_WARNING_CODES)[number];
+type HarvestWarning = {
+    code: HarvesterWarningCode;
+    message: string;
+};
+type HarvestUsageInput = {
+    events: TranscriptEvent[];
+    sessionId: string;
+    promptText: string;
+    submittedAt: string;
+    checkSubsequentEvent?: boolean;
+    nextBoundaryAt?: string | null;
+    agent: {
+        name: "claude-code";
+        version: string | null;
+        sessionId: string | null;
+        turnId: string | null;
+        plan: string | null;
+    };
+    capturedAt: string;
+    extensions: Record<string, unknown> | null;
+};
+type HarvestUsageFailureReason = "no_user_boundary_found" | "no_messages_for_turn";
+type HarvestUsageResult = {
+    ok: true;
+    usage: TurnUsage;
+    boundaryAt: string | null;
+} | {
+    ok: false;
+    reason: HarvestUsageFailureReason;
+};
+declare function harvestClaudeCodeUsage(input: HarvestUsageInput): HarvestUsageResult;
+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 { HARVESTER_WARNING_CODES, type HarvestUsageFailureReason, type HarvestUsageInput, type HarvestUsageResult, type HarvestWarning, type HarvesterWarningCode, type ReadTranscriptResult, type SliceTranscriptInput, type SlicedTurn, type TranscriptEvent, harvestClaudeCodeUsage, readAndParseTranscript, sliceTranscriptIntoTurns };

package/dist/history.js

@@ -0,0 +1,529 @@
+// src/history/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/history/claudeCodeUsageHarvester.ts
+var HARVESTER_WARNING_CODES = [
+  "cache_split_unavailable",
+  "unknown_server_tool",
+  "transcript_truncated",
+  "subagent_model_differs",
+  "server_tool_count_mismatch"
+];
+var BOUNDARY_TIMESTAMP_TOLERANCE_MS = 500;
+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 findBoundary(sessionEvents, promptText, submittedAt, upperMs) {
+  const isWithinUpperBound = (ev) => {
+    if (upperMs === null) return true;
+    const ms = parseTimestamp(ev.timestamp);
+    return ms !== null && ms < upperMs;
+  };
+  let contentMatch = null;
+  for (let i = sessionEvents.length - 1; i >= 0; i--) {
+    const ev = sessionEvents[i];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const text = extractUserContentText(ev.message);
+    if (text !== null && text === promptText) {
+      contentMatch = ev;
+      break;
+    }
+  }
+  if (contentMatch) return { boundary: contentMatch, usedFallback: false };
+  const submittedMs = parseTimestamp(submittedAt);
+  if (submittedMs === null) return { boundary: null, usedFallback: false };
+  for (let i = sessionEvents.length - 1; i >= 0; i--) {
+    const ev = sessionEvents[i];
+    if (!isUserBoundary(ev)) continue;
+    if (!isWithinUpperBound(ev)) continue;
+    const ms = parseTimestamp(ev.timestamp);
+    if (ms === null) continue;
+    if (ms >= submittedMs - BOUNDARY_TIMESTAMP_TOLERANCE_MS) {
+      return { boundary: ev, usedFallback: true };
+    }
+  }
+  return { boundary: null, usedFallback: false };
+}
+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 harvestClaudeCodeUsage(input) {
+  const sessionEvents = input.events.filter((ev) => ev.sessionId === input.sessionId);
+  const upperMs = input.nextBoundaryAt ? parseTimestamp(input.nextBoundaryAt) : null;
+  const { boundary, usedFallback } = findBoundary(
+    sessionEvents,
+    input.promptText,
+    input.submittedAt,
+    upperMs
+  );
+  if (!boundary) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  const boundaryMs = parseTimestamp(boundary.timestamp);
+  if (boundaryMs === null) {
+    return { ok: false, reason: "no_user_boundary_found" };
+  }
+  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 initialWarnings = [];
+  if (usedFallback) {
+    initialWarnings.push({
+      code: "transcript_truncated",
+      message: "Prompt-text equality match failed; used timestamp-tolerance fallback to locate the user boundary."
+    });
+  }
+  const built = buildTurnUsage({
+    sessionEvents,
+    turnEvents,
+    upperMs,
+    initialWarnings,
+    agent: input.agent,
+    capturedAt: input.capturedAt,
+    captureSource: "hook",
+    extensions: input.extensions,
+    checkSubsequentEvent: input.checkSubsequentEvent === true
+  });
+  if (!built.ok) return built;
+  return {
+    ok: true,
+    usage: built.usage,
+    boundaryAt: typeof boundary.timestamp === "string" ? boundary.timestamp : null
+  };
+}
+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 {
+  HARVESTER_WARNING_CODES,
+  harvestClaudeCodeUsage,
+  readAndParseTranscript,
+  sliceTranscriptIntoTurns
+};

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { S as SessionStore, a as StoredSession, c as createStoredSessionTokenPro
 export { createLocalSessionStore, createSupabaseAuthHelpers } from './auth.js';
 export { AgentMemoryItem, AgentMemoryKind, AgentMemorySearchItem, AgentMemorySearchResponse, AgentMemorySummary, AgentMemoryTimelineResponse, ApiClient, AppContext, AppContextAccessPath, AppReconcileResponse, Bundle, BundlePlatform, BundleStatus, ChangeStepDiffResponse, InitiateBundleRequest, InvitationRecord, MergeRequest, MergeRequestReview, MergeRequestStatus, ReconcilePreflightResponse, SyncLocalResponse, SyncUpstreamResponse, createApiClient } from './api.js';
 import 'zod';
-import './contracts-NbV3P_Rl.js';
+import './contracts-CHmD-fMj.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixhq/core",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",
@@ -46,6 +46,10 @@
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
     },
+    "./history": {
+      "types": "./dist/history.d.ts",
+      "import": "./dist/history.js"
+    },
     "./repo": {
       "types": "./dist/repo.d.ts",
       "import": "./dist/repo.js"
@@ -55,7 +59,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/api.ts src/auth.ts src/binding.ts src/collab.ts src/config.ts src/errors.ts src/repo.ts --dts --format esm",
+    "build": "tsup src/index.ts src/api.ts src/auth.ts src/binding.ts src/collab.ts src/config.ts src/errors.ts src/history.ts src/repo.ts --dts --format esm --clean",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "prepack": "npm run build"