@chinhae/codex-connect-linux-arm64 0.11.0 → 0.12.1

package/app/plugins/claude-code/plugin.mjs

@@ -776,10 +776,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1188,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -1339,16 +1339,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path14 = []) => {
+  const processError = (error53, path15 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1375,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path14 = []) => {
+  const processError = (error53, path15 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1417,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -4646,8 +4646,8 @@ function az_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -6725,8 +6725,8 @@ function hu_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count3, one, many) {
+  return Math.abs(count3) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -7648,8 +7648,8 @@ function ko_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -8854,8 +8854,8 @@ function ro_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -14110,13 +14110,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14632,6 +14632,304 @@ var hostTurnIdSchema = opaqueIdSchema.brand();
 var hostItemIdSchema = opaqueIdSchema.brand();
 var hostInteractionIdSchema = opaqueIdSchema.brand();
 
+// ../../shared-contracts/dist/harness-plugins.js
+var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
+var HARNESS_PLUGIN_ICON_MAX_BYTES = 128 * 1024;
+var HARNESS_PLUGIN_LIMIT = 128;
+var harnessPluginIdSchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u).refine((id) => id !== "codex", "The official Codex identity is reserved").pipe(harnessIdSchema);
+var relativeResourceSchema = external_exports.string().min(1).max(512).refine((value) => !/[\\\u0000:#?]/u.test(value) && !value.startsWith("/") && !value.split("/").some((part) => part === ".." || part === ""), "Plugin resources must be relative paths inside the plugin");
+var documentationUrlSchema = external_exports.url().refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Plugin documentation links must be credential-free HTTPS URLs");
+var pluginPresentationShape = {
+  id: harnessPluginIdSchema,
+  name: external_exports.string().trim().min(1).max(128),
+  version: external_exports.string().min(1).max(128),
+  /** The factory accepts a persisted local entrypoint through its construction context. */
+  launchCommand: external_exports.literal(true).optional(),
+  links: external_exports.object({
+    documentation: documentationUrlSchema.optional(),
+    installation: documentationUrlSchema.optional()
+  }).strict().optional()
+};
+var harnessPluginManifestSchema = external_exports.object({
+  manifestVersion: external_exports.literal(1),
+  ...pluginPresentationShape,
+  adapterApiVersion: external_exports.number().int().positive(),
+  entry: relativeResourceSchema,
+  icon: relativeResourceSchema.optional()
+}).strict();
+var harnessPluginIconSchema = external_exports.string().max(Math.ceil(HARNESS_PLUGIN_ICON_MAX_BYTES / 3) * 4 + 64).regex(/^data:image\/(?:png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/u);
+var harnessPluginDescriptorSchema = external_exports.object({
+  ...pluginPresentationShape,
+  icon: harnessPluginIconSchema.optional()
+}).strict();
+var harnessPluginListParamsSchema = external_exports.object({}).strict();
+var harnessPluginListResultSchema = external_exports.object({
+  plugins: external_exports.array(harnessPluginDescriptorSchema).max(HARNESS_PLUGIN_LIMIT)
+}).strict();
+var harnessPluginConfigurationSchema = external_exports.object({
+  version: external_exports.literal(1),
+  enabled: external_exports.array(harnessPluginIdSchema).max(HARNESS_PLUGIN_LIMIT)
+}).strict().refine((value) => new Set(value.enabled).size === value.enabled.length, {
+  message: "Enabled plugin IDs must be unique",
+  path: ["enabled"]
+});
+
+// ../../shared-contracts/dist/local-usage.js
+var LOCAL_USAGE_CUSTOM_RANGE_MAX_DAYS = 3660;
+var LOCAL_USAGE_DAILY_MAX_LENGTH = LOCAL_USAGE_CUSTOM_RANGE_MAX_DAYS + 1;
+var LOCAL_USAGE_HARNESS_MAX_LENGTH = 128;
+var LOCAL_USAGE_HARNESS_NAME_MAX_LENGTH = 128;
+var LOCAL_USAGE_PROVIDER_MAX_LENGTH = 128;
+var LOCAL_USAGE_PROVIDER_NAME_MAX_LENGTH = 1024;
+var LOCAL_USAGE_PROJECT_MAX_LENGTH = 1e3;
+var LOCAL_USAGE_PROJECT_NAME_MAX_LENGTH = 1024;
+var LOCAL_USAGE_TIME_ZONE_MAX_LENGTH = 64;
+var DAY_MS = 864e5;
+function dateValue(value) {
+  return Date.parse(`${value}T00:00:00.000Z`);
+}
+var localUsageDateSchema = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/u).refine((value) => {
+  const time3 = dateValue(value);
+  return Number.isFinite(time3) && new Date(time3).toISOString().slice(0, 10) === value;
+}, "Invalid calendar date");
+var timeZoneSchema = external_exports.string().min(1).max(LOCAL_USAGE_TIME_ZONE_MAX_LENGTH).refine((value) => {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}, "Unknown time zone");
+var localUsagePeriodSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("day") }),
+  // Weeks start on Monday.
+  external_exports.strictObject({ kind: external_exports.literal("week") }),
+  external_exports.strictObject({ kind: external_exports.literal("month") }),
+  // The first day of the month 23 months ago through today.
+  external_exports.strictObject({ kind: external_exports.literal("total") }),
+  external_exports.strictObject({
+    kind: external_exports.literal("custom"),
+    from: localUsageDateSchema,
+    to: localUsageDateSchema
+  }).superRefine((period, context) => {
+    const days = (dateValue(period.to) - dateValue(period.from)) / DAY_MS;
+    if (days < 0) {
+      context.addIssue({ code: "custom", path: ["to"], message: "Range ends before it starts" });
+    } else if (days >= LOCAL_USAGE_CUSTOM_RANGE_MAX_DAYS) {
+      context.addIssue({ code: "custom", path: ["to"], message: "Range is too long" });
+    }
+  })
+]);
+var localUsageQueryParamsSchema = external_exports.strictObject({
+  period: localUsagePeriodSchema,
+  /** IANA zone used to assign usage to calendar days. */
+  timeZone: timeZoneSchema,
+  /** Read new native records before answering; otherwise reuse this Host's last read. */
+  refresh: external_exports.boolean()
+});
+var countSchema = external_exports.number().int().nonnegative().safe();
+var tokenTotalsShape = {
+  total: countSchema,
+  /** Input tokens excluding cache reads and writes. */
+  input: countSchema,
+  cacheRead: countSchema,
+  cacheWrite: countSchema,
+  output: countSchema,
+  reasoning: countSchema
+};
+var usageHarnessIdSchema = external_exports.union([external_exports.literal("codex"), harnessPluginIdSchema]);
+var localUsageViewSchema = external_exports.strictObject({
+  status: external_exports.literal("ready"),
+  range: external_exports.strictObject({ from: localUsageDateSchema, to: localUsageDateSchema }),
+  totals: external_exports.strictObject({ ...tokenTotalsShape, conversations: countSchema }).refine((totals) => totals.total === totals.input + totals.cacheRead + totals.cacheWrite + totals.output + totals.reasoning, { path: ["total"], message: "Total must equal its parts" }),
+  /**
+   * Estimated Cost of the range in USD: Harness-reported cost where present, otherwise public
+   * model prices applied when queried. Models without a price add 0.
+   */
+  estimatedCostUsd: external_exports.number().nonnegative().finite(),
+  /** Distinct Models with usage in the range, across Harnesses. */
+  models: countSchema,
+  harnesses: external_exports.array(external_exports.strictObject({
+    harnessId: usageHarnessIdSchema,
+    name: external_exports.string().trim().min(1).max(LOCAL_USAGE_HARNESS_NAME_MAX_LENGTH),
+    totalTokens: countSchema,
+    models: countSchema,
+    /** Providers the Harness recorded, by usage; empty when it records none. */
+    providers: external_exports.array(external_exports.strictObject({
+      provider: external_exports.string().min(1).max(LOCAL_USAGE_PROVIDER_NAME_MAX_LENGTH),
+      totalTokens: countSchema,
+      models: countSchema
+    })).max(LOCAL_USAGE_PROVIDER_MAX_LENGTH)
+  }).refine((harness) => harness.providers.reduce((sum, provider) => sum + provider.totalTokens, 0) <= harness.totalTokens, { path: ["providers"], message: "Providers are part of their Harness" })).max(LOCAL_USAGE_HARNESS_MAX_LENGTH),
+  /** Days with usage, newest first. `cacheRead` is the daily cache column. */
+  daily: external_exports.array(external_exports.strictObject({
+    date: localUsageDateSchema,
+    total: countSchema,
+    input: countSchema,
+    output: countSchema,
+    cacheRead: countSchema,
+    reasoning: countSchema,
+    conversations: countSchema
+  })).max(LOCAL_USAGE_DAILY_MAX_LENGTH),
+  /**
+   * Usage with a known working directory, by project, most used first: `owner/repo` from the Git
+   * remote, otherwise the folder name. Only the most used projects are listed.
+   */
+  projects: external_exports.array(external_exports.strictObject({
+    project: external_exports.string().min(1).max(LOCAL_USAGE_PROJECT_NAME_MAX_LENGTH),
+    totalTokens: countSchema,
+    /** Harnesses used in the project, most used first. */
+    harnessIds: external_exports.array(usageHarnessIdSchema).min(1).max(LOCAL_USAGE_HARNESS_MAX_LENGTH)
+  })).max(LOCAL_USAGE_PROJECT_MAX_LENGTH),
+  /** Harnesses whose last read failed; their totals are from their last successful read. */
+  failures: external_exports.array(external_exports.strictObject({
+    harnessId: usageHarnessIdSchema,
+    name: external_exports.string().trim().min(1).max(LOCAL_USAGE_HARNESS_NAME_MAX_LENGTH)
+  })).max(LOCAL_USAGE_HARNESS_MAX_LENGTH),
+  /**
+   * Independent of the selected period. Windows end today; an active day has tokens.
+   * `dailyAverage` is the last 30 days' total over their active days, rounded.
+   */
+  stats: external_exports.strictObject({
+    last7Days: countSchema,
+    last30Days: countSchema,
+    dailyAverage: countSchema,
+    /** Active days across all counted history, not only the "total" period. */
+    activeDays: countSchema,
+    firstActiveDate: localUsageDateSchema.nullable()
+  }).superRefine((stats, context) => {
+    if (stats.firstActiveDate === null !== (stats.activeDays === 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["firstActiveDate"],
+        message: "First active date exists exactly when there are active days"
+      });
+    }
+    if (stats.last7Days > stats.last30Days) {
+      context.addIssue({
+        code: "custom",
+        path: ["last7Days"],
+        message: "The last 7 days are part of the last 30 days"
+      });
+    }
+  })
+});
+var localUsageReadingSchema = external_exports.strictObject({
+  status: external_exports.literal("reading"),
+  /** Native record files read so far by the sources that report progress. */
+  progress: external_exports.strictObject({ processed: countSchema, total: countSchema }).refine((progress) => progress.processed <= progress.total, {
+    path: ["processed"],
+    message: "Processed files are part of the total"
+  })
+});
+var localUsageQueryResultSchema = external_exports.discriminatedUnion("status", [
+  localUsageReadingSchema,
+  localUsageViewSchema
+]);
+
+// ../../shared-contracts/dist/harness-session-import.js
+var HARNESS_SESSION_IMPORT_ID_MAX_LENGTH = 1024;
+var HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH = 16384;
+var HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH = 4096;
+var HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH = 1e3;
+var HARNESS_SESSION_IMPORT_UPDATED_AT_MAX = 864e13;
+var nonBlankTextSchema = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
+var harnessSessionImportIdSchema = nonBlankTextSchema.max(HARNESS_SESSION_IMPORT_ID_MAX_LENGTH);
+var harnessSessionImportCandidateSchema = external_exports.object({
+  nativeSessionId: harnessSessionImportIdSchema,
+  title: nonBlankTextSchema.max(HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH).nullable(),
+  updatedAt: external_exports.number().int().nonnegative().max(HARNESS_SESSION_IMPORT_UPDATED_AT_MAX),
+  cwd: nonBlankTextSchema.max(HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH),
+  // Native file discovery cannot reliably observe another process's activity.
+  running: external_exports.boolean().nullable()
+}).strict();
+var harnessSessionImportSourcesParamsSchema = external_exports.object({}).strict();
+var harnessSessionImportSourcesResultSchema = external_exports.object({
+  harnesses: external_exports.array(external_exports.object({
+    harnessId: harnessPluginIdSchema,
+    name: nonBlankTextSchema.max(128)
+  }).strict()).max(128)
+}).strict();
+var harnessSessionListParamsSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema,
+  query: external_exports.string().trim().max(4096).refine((value) => !value.includes("\0")).optional(),
+  offset: external_exports.number().int().nonnegative().safe().optional(),
+  limit: external_exports.number().int().min(1).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH).optional()
+}).strict();
+var harnessSessionListResultSchema = external_exports.object({
+  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH),
+  total: external_exports.number().int().nonnegative().safe()
+}).strict();
+var harnessSessionImportParamsSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema,
+  nativeSessionId: harnessSessionImportIdSchema
+}).strict();
+var harnessSessionImportResultSchema = external_exports.object({
+  threadId: nonBlankTextSchema.max(1024).pipe(hostThreadIdSchema)
+}).strict();
+
+// ../../shared-contracts/dist/local-sessions.js
+var LOCAL_SESSIONS_MAX_LENGTH = 1e5;
+var LOCAL_SESSIONS_MODEL_MAX_LENGTH = 1024;
+var LOCAL_SESSIONS_RESUME_COMMAND_MAX_LENGTH = 256;
+var LOCAL_SESSIONS_RESUME_COMMAND_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 ._:=/-]*$/u;
+var countSchema2 = external_exports.number().int().nonnegative().safe();
+var timeSchema = countSchema2;
+var sessionHarnessIdSchema = external_exports.union([external_exports.literal("codex"), harnessPluginIdSchema]);
+var harnessNameSchema = external_exports.string().trim().min(1).max(LOCAL_USAGE_HARNESS_NAME_MAX_LENGTH);
+var localSessionsQueryParamsSchema = external_exports.strictObject({
+  /** Read native records added since the last read before answering. */
+  refresh: external_exports.boolean()
+});
+var localSessionSchema = external_exports.strictObject({
+  harnessId: sessionHarnessIdSchema,
+  nativeSessionId: harnessSessionImportIdSchema,
+  /** The Harness's own name for the Session; null shows the project instead. */
+  title: external_exports.string().min(1).max(HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH).nullable(),
+  /** Working directory, used to copy the project path or a resume command. */
+  cwd: external_exports.string().min(1).max(HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH).nullable(),
+  /** `owner/repo` from the Git remote, otherwise the folder name. */
+  project: external_exports.string().min(1).max(LOCAL_USAGE_PROJECT_NAME_MAX_LENGTH).nullable(),
+  model: external_exports.string().min(1).max(LOCAL_SESSIONS_MODEL_MAX_LENGTH).nullable(),
+  startedAt: timeSchema.nullable(),
+  lastActivityAt: timeSchema,
+  /** Null for Sessions known only from Session import, which has no native usage. */
+  activeMs: countSchema2.nullable(),
+  usage: external_exports.strictObject({
+    /** Includes folded subagents. */
+    totalTokens: countSchema2,
+    estimatedCostUsd: external_exports.number().nonnegative().finite()
+  }).nullable(),
+  turns: countSchema2.nullable(),
+  edits: countSchema2.nullable(),
+  /** Subagent and child Sessions folded into this one. */
+  subagents: countSchema2,
+  /** The Thread this Session is already mapped to. */
+  threadId: hostThreadIdSchema.nullable(),
+  /** Whether Resume can open it as a Thread. */
+  resumable: external_exports.boolean(),
+  /** Null when the Harness cannot tell whether another client is running it. */
+  running: external_exports.boolean().nullable(),
+  /**
+   * Resumes the Session in its Harness's own CLI when run from `cwd`; null when the Harness has
+   * no such command or the Session ID is not safe to paste into a terminal.
+   */
+  resumeCommand: external_exports.string().max(LOCAL_SESSIONS_RESUME_COMMAND_MAX_LENGTH).regex(LOCAL_SESSIONS_RESUME_COMMAND_PATTERN).nullable()
+});
+var localSessionsViewSchema = external_exports.strictObject({
+  status: external_exports.literal("ready"),
+  /** Most recently active first. */
+  sessions: external_exports.array(localSessionSchema).max(LOCAL_SESSIONS_MAX_LENGTH),
+  /** Harnesses with listed Sessions, by name. */
+  harnesses: external_exports.array(external_exports.strictObject({ harnessId: sessionHarnessIdSchema, name: harnessNameSchema })).max(LOCAL_USAGE_HARNESS_MAX_LENGTH),
+  /** Sources whose last read failed; their Sessions are from their last successful read. */
+  failures: external_exports.array(external_exports.strictObject({ harnessId: sessionHarnessIdSchema, name: harnessNameSchema })).max(LOCAL_USAGE_HARNESS_MAX_LENGTH)
+});
+var localSessionsQueryResultSchema = external_exports.discriminatedUnion("status", [
+  localUsageReadingSchema,
+  localSessionsViewSchema
+]);
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -14695,10 +14993,18 @@ var accountCreditsProductUsageSchema = external_exports.object({
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
+var ACCOUNT_RESET_CREDITS_MAX_LENGTH = 32;
+var ACCOUNT_RESET_CREDIT_TIME_MAX_LENGTH = 64;
+var resetCreditTimeSchema = external_exports.string().min(1).max(ACCOUNT_RESET_CREDIT_TIME_MAX_LENGTH);
+var accountResetCreditSchema = external_exports.object({
+  expiresAt: resetCreditTimeSchema,
+  grantedAt: resetCreditTimeSchema.optional()
+}).strict();
 var accountResetCreditsSchema = external_exports.object({
   availableCount: external_exports.number().int().safe().positive(),
   nextExpiresAt: external_exports.string().min(1).optional(),
-  expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
+  expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(ACCOUNT_RESET_CREDITS_MAX_LENGTH).optional(),
+  credits: external_exports.array(accountResetCreditSchema).min(1).max(ACCOUNT_RESET_CREDITS_MAX_LENGTH).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
   /** Native label when the primary limit is scoped to a model or product group. */
@@ -14818,14 +15124,14 @@ var HARNESS_PERMISSION_MODE_ID_MAX_LENGTH = 128;
 var HARNESS_PERMISSION_MODE_LABEL_MAX_LENGTH = 256;
 var HARNESS_PERMISSION_MODE_DESCRIPTION_MAX_LENGTH = 1024;
 var HARNESS_PERMISSION_MODE_CATALOG_MAX_LENGTH = 32;
-var nonBlankTextSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+var nonBlankTextSchema2 = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Value must not be empty or whitespace"
 });
-var harnessPermissionModeIdSchema = nonBlankTextSchema.max(HARNESS_PERMISSION_MODE_ID_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Permission Mode ID must use transport-safe characters").brand();
+var harnessPermissionModeIdSchema = nonBlankTextSchema2.max(HARNESS_PERMISSION_MODE_ID_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Permission Mode ID must use transport-safe characters").brand();
 var harnessPermissionModeSchema = external_exports.object({
   id: harnessPermissionModeIdSchema,
-  label: nonBlankTextSchema.max(HARNESS_PERMISSION_MODE_LABEL_MAX_LENGTH),
-  description: nonBlankTextSchema.max(HARNESS_PERMISSION_MODE_DESCRIPTION_MAX_LENGTH).optional(),
+  label: nonBlankTextSchema2.max(HARNESS_PERMISSION_MODE_LABEL_MAX_LENGTH),
+  description: nonBlankTextSchema2.max(HARNESS_PERMISSION_MODE_DESCRIPTION_MAX_LENGTH).optional(),
   dangerous: external_exports.boolean().optional()
 }).strict();
 var harnessPermissionModeCatalogSchema = external_exports.object({
@@ -14861,22 +15167,22 @@ var HARNESS_MODEL_REF_MAX_LENGTH = 512;
 var HARNESS_MODEL_LABEL_MAX_LENGTH = 256;
 var HARNESS_THINKING_OPTION_ID_MAX_LENGTH = 128;
 var THREAD_OWNERSHIP_LIST_MAX_LENGTH = 100;
-var nonBlankTextSchema2 = external_exports.string().refine((value) => value.trim().length > 0, {
+var nonBlankTextSchema3 = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Value must not be empty or whitespace"
 });
-var harnessModelRefIdSchema = nonBlankTextSchema2.max(HARNESS_MODEL_REF_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Model Ref must use transport-safe opaque characters").brand();
+var harnessModelRefIdSchema = nonBlankTextSchema3.max(HARNESS_MODEL_REF_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Model Ref must use transport-safe opaque characters").brand();
 var harnessModelRefSchema = external_exports.object({
   id: harnessModelRefIdSchema
 }).strict();
-var harnessThinkingOptionIdSchema = nonBlankTextSchema2.max(HARNESS_THINKING_OPTION_ID_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Thinking option ID must use transport-safe characters").brand();
-var harnessResolvedModelLabelSchema = nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH);
+var harnessThinkingOptionIdSchema = nonBlankTextSchema3.max(HARNESS_THINKING_OPTION_ID_MAX_LENGTH).regex(/^[A-Za-z0-9._~-]+$/u, "Thinking option ID must use transport-safe characters").brand();
+var harnessResolvedModelLabelSchema = nonBlankTextSchema3.max(HARNESS_MODEL_LABEL_MAX_LENGTH);
 var harnessThinkingOptionSchema = external_exports.object({
   id: harnessThinkingOptionIdSchema,
-  label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH)
+  label: nonBlankTextSchema3.max(HARNESS_MODEL_LABEL_MAX_LENGTH)
 }).strict();
 var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
-  label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
+  label: nonBlankTextSchema3.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
@@ -15013,7 +15319,7 @@ var harnessInspectionSchema = external_exports.union([
 ]);
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
-  cwd: nonBlankTextSchema2.max(16384).optional(),
+  cwd: nonBlankTextSchema3.max(16384).optional(),
   refresh: external_exports.boolean().optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
@@ -15037,8 +15343,8 @@ var codexThreadInspectionSchema = external_exports.object({
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
-  harnessId: nonBlankTextSchema2.max(256),
-  transportModelId: nonBlankTextSchema2.max(1024),
+  harnessId: nonBlankTextSchema3.max(256),
+  transportModelId: nonBlankTextSchema3.max(1024),
   effectiveModel: harnessModelRefSchema.optional(),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
   effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
@@ -15096,48 +15402,6 @@ var threadOwnershipListResultSchema = external_exports.object({
   }
 });
 
-// ../../shared-contracts/dist/harness-plugins.js
-var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
-var HARNESS_PLUGIN_ICON_MAX_BYTES = 128 * 1024;
-var HARNESS_PLUGIN_LIMIT = 128;
-var harnessPluginIdSchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u).refine((id) => id !== "codex", "The official Codex identity is reserved").pipe(harnessIdSchema);
-var relativeResourceSchema = external_exports.string().min(1).max(512).refine((value) => !/[\\\u0000:#?]/u.test(value) && !value.startsWith("/") && !value.split("/").some((part) => part === ".." || part === ""), "Plugin resources must be relative paths inside the plugin");
-var documentationUrlSchema = external_exports.url().refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Plugin documentation links must be credential-free HTTPS URLs");
-var pluginPresentationShape = {
-  id: harnessPluginIdSchema,
-  name: external_exports.string().trim().min(1).max(128),
-  version: external_exports.string().min(1).max(128),
-  /** The factory accepts a persisted local entrypoint through its construction context. */
-  launchCommand: external_exports.literal(true).optional(),
-  links: external_exports.object({
-    documentation: documentationUrlSchema.optional(),
-    installation: documentationUrlSchema.optional()
-  }).strict().optional()
-};
-var harnessPluginManifestSchema = external_exports.object({
-  manifestVersion: external_exports.literal(1),
-  ...pluginPresentationShape,
-  adapterApiVersion: external_exports.number().int().positive(),
-  entry: relativeResourceSchema,
-  icon: relativeResourceSchema.optional()
-}).strict();
-var harnessPluginIconSchema = external_exports.string().max(Math.ceil(HARNESS_PLUGIN_ICON_MAX_BYTES / 3) * 4 + 64).regex(/^data:image\/(?:png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/u);
-var harnessPluginDescriptorSchema = external_exports.object({
-  ...pluginPresentationShape,
-  icon: harnessPluginIconSchema.optional()
-}).strict();
-var harnessPluginListParamsSchema = external_exports.object({}).strict();
-var harnessPluginListResultSchema = external_exports.object({
-  plugins: external_exports.array(harnessPluginDescriptorSchema).max(HARNESS_PLUGIN_LIMIT)
-}).strict();
-var harnessPluginConfigurationSchema = external_exports.object({
-  version: external_exports.literal(1),
-  enabled: external_exports.array(harnessPluginIdSchema).max(HARNESS_PLUGIN_LIMIT)
-}).strict().refine((value) => new Set(value.enabled).size === value.enabled.length, {
-  message: "Enabled plugin IDs must be unique",
-  path: ["enabled"]
-});
-
 // ../../shared-contracts/dist/harness-route.js
 var harnessPluginRouteSchema = external_exports.object({
   harnessId: harnessPluginIdSchema,
@@ -15161,7 +15425,7 @@ var harnessLaunchSettingsSchema = external_exports.object({
 
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
-var nonBlankTextSchema3 = external_exports.string().trim().min(1);
+var nonBlankTextSchema4 = external_exports.string().trim().min(1);
 var codexAccountPlanTypeSchema = external_exports.enum([
   "free",
   "go",
@@ -15183,7 +15447,7 @@ var codexAccountPlanTypeSchema = external_exports.enum([
 ]);
 var codexAccountSchema = external_exports.object({
   accountId: accountIdSchema,
-  label: nonBlankTextSchema3.max(256),
+  label: nonBlankTextSchema4.max(256),
   email: external_exports.string().email().max(320).optional(),
   planType: codexAccountPlanTypeSchema.optional()
 }).strict();
@@ -15193,7 +15457,7 @@ var codexAccountListResultSchema = external_exports.object({
   currentAccountId: accountIdSchema.nullable(),
   phase: codexAccountPhaseSchema,
   revision: external_exports.number().int().nonnegative(),
-  instanceId: nonBlankTextSchema3.max(1024).optional(),
+  instanceId: nonBlankTextSchema4.max(1024).optional(),
   accounts: external_exports.array(codexAccountSchema).max(1)
 }).strict();
 var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema, refresh: external_exports.boolean().optional() }).strict();
@@ -15205,47 +15469,6 @@ var codexAccountUsageResultSchema = external_exports.object({
   observedAt: external_exports.string().datetime().nullable()
 }).strict();
 
-// ../../shared-contracts/dist/harness-session-import.js
-var HARNESS_SESSION_IMPORT_ID_MAX_LENGTH = 1024;
-var HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH = 16384;
-var HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH = 4096;
-var HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH = 1e3;
-var HARNESS_SESSION_IMPORT_UPDATED_AT_MAX = 864e13;
-var nonBlankTextSchema4 = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
-var harnessSessionImportIdSchema = nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_ID_MAX_LENGTH);
-var harnessSessionImportCandidateSchema = external_exports.object({
-  nativeSessionId: harnessSessionImportIdSchema,
-  title: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH).nullable(),
-  updatedAt: external_exports.number().int().nonnegative().max(HARNESS_SESSION_IMPORT_UPDATED_AT_MAX),
-  cwd: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH),
-  // Native file discovery cannot reliably observe another process's activity.
-  running: external_exports.boolean().nullable()
-}).strict();
-var harnessSessionImportSourcesParamsSchema = external_exports.object({}).strict();
-var harnessSessionImportSourcesResultSchema = external_exports.object({
-  harnesses: external_exports.array(external_exports.object({
-    harnessId: harnessPluginIdSchema,
-    name: nonBlankTextSchema4.max(128)
-  }).strict()).max(128)
-}).strict();
-var harnessSessionListParamsSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema,
-  query: external_exports.string().trim().max(4096).refine((value) => !value.includes("\0")).optional(),
-  offset: external_exports.number().int().nonnegative().safe().optional(),
-  limit: external_exports.number().int().min(1).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH).optional()
-}).strict();
-var harnessSessionListResultSchema = external_exports.object({
-  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH),
-  total: external_exports.number().int().nonnegative().safe()
-}).strict();
-var harnessSessionImportParamsSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema,
-  nativeSessionId: harnessSessionImportIdSchema
-}).strict();
-var harnessSessionImportResultSchema = external_exports.object({
-  threadId: nonBlankTextSchema4.max(1024).pipe(hostThreadIdSchema)
-}).strict();
-
 // ../../shared-contracts/dist/deepseek-modern-sessions.js
 var DEEPSEEK_MODERN_SESSION_LIST_MAX_LENGTH = HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH;
 var DEEPSEEK_MODERN_HOST_THREAD_ID_MAX_LENGTH = 1024;
@@ -15653,6 +15876,61 @@ function parseHostUsage(value) {
   return { ...value };
 }
 
+// ../../harness-adapter/dist/native-session-summary.js
+var NATIVE_SESSION_IDLE_GAP_MS = 30 * 6e4;
+function emptyNativeSessionActivity() {
+  return {
+    firstActivityAt: null,
+    lastActivityAt: null,
+    activeMs: 0,
+    turns: 0,
+    edits: 0,
+    editing: false
+  };
+}
+function count(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function parseNativeSessionActivity(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const activity = value;
+  const time3 = (field) => field === null || count(field);
+  return time3(activity.firstActivityAt) && time3(activity.lastActivityAt) && count(activity.activeMs) && count(activity.turns) && count(activity.edits) && typeof activity.editing === "boolean" ? {
+    firstActivityAt: activity.firstActivityAt,
+    lastActivityAt: activity.lastActivityAt,
+    activeMs: activity.activeMs,
+    turns: activity.turns,
+    edits: activity.edits,
+    editing: activity.editing
+  } : null;
+}
+function recordNativeSessionActivity(activity, time3) {
+  if (activity.firstActivityAt === null || time3 < activity.firstActivityAt) {
+    activity.firstActivityAt = time3;
+  }
+  if (activity.lastActivityAt !== null) {
+    const gap = time3 - activity.lastActivityAt;
+    if (gap > 0 && gap <= NATIVE_SESSION_IDLE_GAP_MS)
+      activity.activeMs += gap;
+    if (gap <= 0)
+      return;
+  }
+  activity.lastActivityAt = time3;
+}
+function startNativeSessionTurn(activity) {
+  if (activity.editing)
+    activity.edits += 1;
+  activity.editing = false;
+  activity.turns += 1;
+}
+function recordNativeSessionEdit(activity) {
+  activity.editing = true;
+}
+function nativeSessionEdits(activity) {
+  return activity.edits + (activity.editing ? 1 : 0);
+}
+
 // ../../harness-adapter/dist/live-command-catalog.js
 var COMMON_EXCLUDED_LIVE_COMMANDS = /* @__PURE__ */ new Set([
   // Session lifecycle
@@ -15734,8 +16012,8 @@ function liveHarnessCommandPrompt(catalog, idPrefix, commandId, argumentText) {
   const descriptor = catalog.commands.find(({ id }) => id === commandId);
   if (!descriptor)
     return null;
-  const text = typeof argumentText === "string" ? argumentText.trim() : "";
-  return text ? `${descriptor.invocation} ${text}` : descriptor.invocation;
+  const text2 = typeof argumentText === "string" ? argumentText.trim() : "";
+  return text2 ? `${descriptor.invocation} ${text2}` : descriptor.invocation;
 }
 function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
   if (!live)
@@ -16680,7 +16958,7 @@ var BrokeredHarnessAdapter = class {
 
 // dist/claude-code-adapter.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import path12 from "node:path";
+import path13 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as DW } from "node:module";
@@ -42371,6 +42649,11 @@ var ClaudeBackgroundOccupancy = class {
   }
 };
 
+// dist/claude-native-usage.js
+import { createReadStream as createReadStream2 } from "node:fs";
+import { opendir as opendir2, stat as stat2 } from "node:fs/promises";
+import path3 from "node:path";
+
 // dist/claude-session-import.js
 import { createReadStream } from "node:fs";
 import { opendir, realpath, stat } from "node:fs/promises";
@@ -42408,8 +42691,8 @@ function userText(message) {
   if (!isRecord2(message) || message.role !== "user")
     return null;
   const { content } = message;
-  const text = typeof content === "string" ? cleanText(content) : Array.isArray(content) ? cleanText(content.filter((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join(" ")) : null;
-  return text && !CLAUDE_INTERNAL_USER_TEXT.test(text) ? text : null;
+  const text2 = typeof content === "string" ? cleanText(content) : Array.isArray(content) ? cleanText(content.filter((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join(" ")) : null;
+  return text2 && !CLAUDE_INTERNAL_USER_TEXT.test(text2) ? text2 : null;
 }
 function claudeProjectsDirectory(environment) {
   const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) || os2.homedir();
@@ -42582,14 +42865,338 @@ var ClaudeSessionImportIndex = class {
   }
 };
 
+// dist/claude-native-usage.js
+var NEWLINE = 10;
+var STREAMING_WINDOW_MS = 60 * 6e4;
+var offsetSchema = external_exports.number().int().nonnegative().safe();
+var knownTextSchema = external_exports.string().min(1).nullable();
+var fileSummarySchema = external_exports.strictObject({
+  customTitle: knownTextSchema,
+  aiTitle: knownTextSchema,
+  cwd: knownTextSchema,
+  model: knownTextSchema,
+  activity: external_exports.custom((value) => parseNativeSessionActivity(value) !== null)
+});
+var claudeUsageCursorSchema = external_exports.strictObject({
+  // Version 1 had no Session summaries; such a cursor reads everything again.
+  formatVersion: external_exports.literal(2),
+  /** Keyed by path relative to the projects directory. */
+  files: external_exports.record(external_exports.string(), external_exports.strictObject({
+    ino: external_exports.string(),
+    /** Where the next usage read starts; an unfinished response is read again. */
+    offset: offsetSchema,
+    /** Lines before this offset are already in `summary`. */
+    summarized: offsetSchema,
+    summary: fileSummarySchema
+  }))
+});
+var NOT_A_TURN = ["[Request interrupted by user", "<task-notification>"];
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit"]);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function missing2(error52) {
+  return isRecord3(error52) && error52.code === "ENOENT";
+}
+function count2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function occurredAt(value) {
+  if (typeof value !== "string")
+    return null;
+  const time3 = Date.parse(value);
+  return Number.isFinite(time3) ? time3 : null;
+}
+async function directoryEntries(directory) {
+  try {
+    return await opendir2(directory);
+  } catch (error52) {
+    if (missing2(error52))
+      return null;
+    throw error52;
+  }
+}
+async function usageFiles(projects) {
+  const files = [];
+  const projectEntries = await directoryEntries(projects);
+  if (!projectEntries)
+    return files;
+  for await (const project of projectEntries) {
+    if (!project.isDirectory())
+      continue;
+    const entries = await directoryEntries(path3.join(projects, project.name));
+    if (!entries)
+      continue;
+    for await (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push({ relative: path3.join(project.name, entry.name), main: true });
+      } else if (entry.isDirectory()) {
+        const subagents = path3.join(project.name, entry.name, "subagents");
+        const agentEntries = await directoryEntries(path3.join(projects, subagents));
+        if (!agentEntries)
+          continue;
+        for await (const agent of agentEntries) {
+          if (agent.isFile() && agent.name.endsWith(".jsonl")) {
+            files.push({ relative: path3.join(subagents, agent.name), main: false });
+          }
+        }
+      }
+    }
+  }
+  return files;
+}
+async function* completeLines(file2, start, end) {
+  if (end <= start)
+    return;
+  let carry = Buffer.alloc(0);
+  let carryStart = start;
+  for await (const chunk of createReadStream2(file2, { start, end: end - 1 })) {
+    const buffer = carry.length > 0 ? Buffer.concat([carry, chunk]) : chunk;
+    let lineStart = 0;
+    let newline = buffer.indexOf(NEWLINE, lineStart);
+    while (newline !== -1) {
+      yield {
+        line: buffer.toString("utf8", lineStart, newline),
+        start: carryStart + lineStart,
+        end: carryStart + newline + 1
+      };
+      lineStart = newline + 1;
+      newline = buffer.indexOf(NEWLINE, lineStart);
+    }
+    carry = buffer.subarray(lineStart);
+    carryStart += lineStart;
+  }
+}
+function usageTokens(usage) {
+  const cacheWrite = count2(usage.cache_creation_input_tokens);
+  const cacheWrite1h = isRecord3(usage.cache_creation) ? Math.min(count2(usage.cache_creation.ephemeral_1h_input_tokens), cacheWrite) : 0;
+  return {
+    input: count2(usage.input_tokens),
+    cacheRead: count2(usage.cache_read_input_tokens),
+    cacheWrite,
+    ...cacheWrite1h > 0 ? { cacheWrite1h } : {},
+    output: count2(usage.output_tokens),
+    // Claude transcripts report thinking only as part of output_tokens.
+    reasoning: 0
+  };
+}
+function zeroTokens(tokens) {
+  return tokens.input + tokens.cacheRead + tokens.cacheWrite + tokens.output + tokens.reasoning === 0;
+}
+function startsTurn(entry) {
+  if (entry.isMeta === true || !isRecord3(entry.message))
+    return false;
+  const { content } = entry.message;
+  let prompt;
+  if (typeof content === "string") {
+    prompt = content.trim();
+  } else if (Array.isArray(content)) {
+    if (content.length > 0 && content.every((block) => isRecord3(block) && block.type === "tool_result")) {
+      return false;
+    }
+    prompt = content.flatMap((block) => isRecord3(block) && typeof block.text === "string" && block.type === "text" ? [block.text] : []).join("\n").trim();
+  } else {
+    return false;
+  }
+  return prompt.length > 0 && !NOT_A_TURN.some((notice) => prompt.startsWith(notice));
+}
+function summarize(summary, entry) {
+  const cwd = text(entry.cwd);
+  if (cwd)
+    summary.cwd = cwd;
+  const time3 = occurredAt(entry.timestamp);
+  if (time3 !== null)
+    recordNativeSessionActivity(summary.activity, time3);
+  if (entry.type === "custom-title") {
+    const title = cleanText(entry.customTitle);
+    if (title)
+      summary.customTitle = title;
+  } else if (entry.type === "ai-title") {
+    const title = cleanText(entry.aiTitle);
+    if (title)
+      summary.aiTitle = title;
+  } else if (entry.type === "user") {
+    if (startsTurn(entry))
+      startNativeSessionTurn(summary.activity);
+  } else if (entry.type === "assistant" && isRecord3(entry.message)) {
+    const model = text(entry.message.model);
+    if (model && model !== "<synthetic>")
+      summary.model = model;
+    const { content } = entry.message;
+    if (Array.isArray(content) && content.some((block) => isRecord3(block) && block.type === "tool_use" && typeof block.name === "string" && EDIT_TOOLS.has(block.name.toLowerCase()))) {
+      recordNativeSessionEdit(summary.activity);
+    }
+  }
+}
+function emptyFileSummary() {
+  return {
+    customTitle: null,
+    aiTitle: null,
+    cwd: null,
+    model: null,
+    activity: emptyNativeSessionActivity()
+  };
+}
+function sessionSummary(relative, main, summary) {
+  const { activity } = summary;
+  const sessionId = main ? path3.basename(relative, ".jsonl") : path3.basename(path3.dirname(path3.dirname(relative)));
+  if (activity.firstActivityAt === null || activity.lastActivityAt === null)
+    return null;
+  const title = summary.customTitle ?? summary.aiTitle;
+  return {
+    key: relative,
+    ...main ? { nativeSessionId: sessionId } : {
+      nativeSessionId: `${sessionId}/${path3.basename(relative, ".jsonl")}`,
+      parentSessionId: sessionId
+    },
+    ...title ? { title } : {},
+    ...summary.cwd ? { cwd: summary.cwd } : {},
+    ...summary.model ? { model: summary.model } : {},
+    firstActivityAt: activity.firstActivityAt,
+    lastActivityAt: activity.lastActivityAt,
+    activeMs: activity.activeMs,
+    turns: activity.turns,
+    edits: nativeSessionEdits(activity)
+  };
+}
+function typedPrompt(entry) {
+  if (entry.type !== "user" || entry.isSidechain === true || !isRecord3(entry.message))
+    return false;
+  const { content } = entry.message;
+  return typeof content === "string" || Array.isArray(content) && content.some((block) => isRecord3(block) && block.type === "text");
+}
+function baseRecord(entry, dedupeKey, time3) {
+  const nativeSessionId = text(entry.sessionId);
+  if (!nativeSessionId)
+    return null;
+  const cwd = text(entry.cwd);
+  return {
+    dedupeKey,
+    occurredAt: time3,
+    nativeSessionId,
+    ...cwd ? { cwd } : {},
+    tokens: { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, reasoning: 0 },
+    conversations: 0
+  };
+}
+async function readFileUsage(file2, input, records) {
+  const { main, start, end } = input;
+  const responses = /* @__PURE__ */ new Map();
+  let consumed = start;
+  for await (const { line, start: lineStart, end: lineEnd } of completeLines(file2, start, end)) {
+    consumed = lineEnd;
+    const summarizing = lineStart >= input.summarized;
+    if (!summarizing && !line.includes('"usage"') && !line.includes('"type":"user"'))
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord3(entry))
+      continue;
+    if (summarizing)
+      summarize(input.summary, entry);
+    const message = isRecord3(entry.message) ? entry.message : null;
+    if (entry.type === "user") {
+      const uuid3 = text(entry.uuid);
+      const time4 = occurredAt(entry.timestamp);
+      if (!main || !uuid3 || time4 === null || !typedPrompt(entry))
+        continue;
+      const record3 = baseRecord(entry, `prompt:${uuid3}`, time4);
+      if (record3)
+        records.push({ ...record3, conversations: 1 });
+      continue;
+    }
+    if (entry.type !== "assistant" || !message || !isRecord3(message.usage))
+      continue;
+    const messageId = text(message.id);
+    const time3 = occurredAt(entry.timestamp);
+    if (!messageId || time3 === null)
+      continue;
+    const requestId = text(entry.requestId);
+    const key = requestId ? `message:${messageId}:${requestId}` : `message:${messageId}`;
+    const base = baseRecord(entry, key, time3);
+    if (!base)
+      continue;
+    const model = text(message.model);
+    const record2 = { ...base, ...model ? { model } : {}, tokens: usageTokens(message.usage) };
+    const previous = responses.get(key);
+    responses.set(key, {
+      record: record2,
+      firstLineStart: previous?.firstLineStart ?? lineStart,
+      finished: message.stop_reason !== null && message.stop_reason !== void 0
+    });
+  }
+  let resumeAt = consumed;
+  for (const response of responses.values()) {
+    if (!response.finished && input.mayStillStream) {
+      resumeAt = Math.min(resumeAt, response.firstLineStart);
+      continue;
+    }
+    if (!zeroTokens(response.record.tokens))
+      records.push(response.record);
+  }
+  return { offset: resumeAt, consumed };
+}
+async function readClaudeNativeUsage(environment, cursor, signal, onProgress) {
+  const projects = claudeProjectsDirectory(environment);
+  const previous = claudeUsageCursorSchema.safeParse(cursor).data ?? {
+    formatVersion: 2,
+    files: {}
+  };
+  const next = { formatVersion: 2, files: {} };
+  const records = [];
+  const sessions = [];
+  const files = await usageFiles(projects);
+  onProgress?.({ processed: 0, total: files.length });
+  for (const [index, { relative, main }] of files.entries()) {
+    signal.throwIfAborted();
+    const file2 = path3.join(projects, relative);
+    try {
+      const metadata = await stat2(file2, { bigint: true });
+      const ino = metadata.ino.toString();
+      const size = Number(metadata.size);
+      const known = previous.files[relative];
+      const continued = known && known.ino === ino && known.summarized <= size ? known : null;
+      const summary = continued ? structuredClone(continued.summary) : emptyFileSummary();
+      const summarized = continued?.summarized ?? 0;
+      const { offset, consumed } = await readFileUsage(file2, {
+        main,
+        start: continued?.offset ?? 0,
+        end: size,
+        mayStillStream: Date.now() - Number(metadata.mtimeMs) < STREAMING_WINDOW_MS,
+        summarized,
+        summary
+      }, records);
+      const summarizedNow = Math.max(summarized, consumed);
+      next.files[relative] = { ino, offset, summarized: summarizedNow, summary };
+      if (summarizedNow > summarized || !continued) {
+        const session = sessionSummary(relative, main, summary);
+        if (session)
+          sessions.push(session);
+      }
+    } catch (error52) {
+      if (!missing2(error52))
+        throw error52;
+    }
+    onProgress?.({ processed: index + 1, total: files.length });
+  }
+  return { records, sessions, cursor: next };
+}
+
 // dist/command.js
-import path5 from "node:path";
+import path6 from "node:path";
 
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 function targetPath(platform) {
-  return platform === "win32" ? path3.win32 : path3.posix;
+  return platform === "win32" ? path4.win32 : path4.posix;
 }
 function environmentValue(environment, name) {
   const lowered = name.toLowerCase();
@@ -42632,11 +43239,11 @@ function newestFirst(names) {
 }
 
 // ../../harness-discovery/dist/node-runtime.js
-import path4 from "node:path";
+import path5 from "node:path";
 function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath, platform = process.platform) {
   const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
   const delimiter = platform === "win32" ? ";" : ":";
-  const runtimeDirectory = path4.dirname(runtimeExecutable);
+  const runtimeDirectory = path5.dirname(runtimeExecutable);
   const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
   const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
   if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
@@ -42854,14 +43461,14 @@ function resolveClaudeCodeExecutable(input = {}, dependencies = {}) {
   }, dependencies);
   if (!resolution)
     throw new ClaudeCodeExecutableError("Claude Code is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path6.resolve(resolution.executable);
 }
 
 // dist/pending-session.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir, open, readFile as readFile2, rename, rm as rm2, stat as stat2, unlink } from "node:fs/promises";
+import { mkdir, open, readFile as readFile2, rename, rm as rm2, stat as stat3, unlink } from "node:fs/promises";
 import os4 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 var reservationSchema = external_exports.strictObject({
   version: external_exports.literal(1),
   sessionId: external_exports.uuid(),
@@ -42874,13 +43481,13 @@ function isPendingClaudeSession(ref) {
 var ClaudePendingSessions = class {
   #directory;
   constructor(environment) {
-    this.#directory = path6.join(path6.resolve(environment.CLAUDE_CONFIG_DIR ?? path6.join(os4.homedir(), ".claude")), "codexhost", "pending-sessions");
+    this.#directory = path7.join(path7.resolve(environment.CLAUDE_CONFIG_DIR ?? path7.join(os4.homedir(), ".claude")), "codexhost", "pending-sessions");
   }
   #path(ref, cwd) {
-    if (ref.harnessId !== "claude-code" || !external_exports.uuid().safeParse(ref.nativeSessionId).success || !external_exports.strictObject({ pendingSession: external_exports.literal(1) }).safeParse(ref.locator).success || !path6.isAbsolute(cwd)) {
+    if (ref.harnessId !== "claude-code" || !external_exports.uuid().safeParse(ref.nativeSessionId).success || !external_exports.strictObject({ pendingSession: external_exports.literal(1) }).safeParse(ref.locator).success || !path7.isAbsolute(cwd)) {
       throw new Error("Claude Code pending Session identity is invalid");
     }
-    return path6.join(this.#directory, ref.nativeSessionId);
+    return path7.join(this.#directory, ref.nativeSessionId);
   }
   async create(cwd, configuration) {
     const ref = nativeSessionRefSchema.parse({
@@ -42899,7 +43506,7 @@ var ClaudePendingSessions = class {
     await mkdir(this.#directory, { recursive: true, mode: 448 });
     await mkdir(directory, { mode: 448 });
     try {
-      const file2 = await open(path6.join(directory, "session.json"), "wx", 384);
+      const file2 = await open(path7.join(directory, "session.json"), "wx", 384);
       try {
         await file2.writeFile(JSON.stringify(reservation));
         await file2.sync();
@@ -42916,13 +43523,13 @@ var ClaudePendingSessions = class {
   }
   async read(ref, cwd) {
     const directory = this.#path(ref, cwd);
-    const reservation = reservationSchema.parse(JSON.parse(await readFile2(path6.join(directory, "session.json"), "utf8")));
+    const reservation = reservationSchema.parse(JSON.parse(await readFile2(path7.join(directory, "session.json"), "utf8")));
     if (reservation.sessionId !== ref.nativeSessionId || reservation.cwd !== cwd) {
       throw new Error("Claude Code pending Session does not belong to this working directory");
     }
     let started = false;
     try {
-      const claim = await stat2(path6.join(directory, "started"));
+      const claim = await stat3(path7.join(directory, "started"));
       if (!claim.isFile())
         throw new Error("Claude Code pending Session claim is invalid");
       started = true;
@@ -42935,7 +43542,7 @@ var ClaudePendingSessions = class {
   async saveConfiguration(ref, cwd, configuration) {
     await this.read(ref, cwd);
     const directory = this.#path(ref, cwd);
-    const temporary = path6.join(directory, `${randomUUID2()}.tmp`);
+    const temporary = path7.join(directory, `${randomUUID2()}.tmp`);
     try {
       const file2 = await open(temporary, "wx", 384);
       try {
@@ -42949,7 +43556,7 @@ var ClaudePendingSessions = class {
       } finally {
         await file2.close();
       }
-      await rename(temporary, path6.join(directory, "session.json"));
+      await rename(temporary, path7.join(directory, "session.json"));
       await this.#sync(directory);
     } finally {
       await rm2(temporary, { force: true });
@@ -42967,7 +43574,7 @@ var ClaudePendingSessions = class {
   }
   async claim(ref, cwd) {
     await this.read(ref, cwd);
-    const claim = await open(path6.join(this.#path(ref, cwd), "started"), "wx", 384);
+    const claim = await open(path7.join(this.#path(ref, cwd), "started"), "wx", 384);
     try {
       await claim.sync();
     } finally {
@@ -42977,7 +43584,7 @@ var ClaudePendingSessions = class {
   }
   /** Only the claim owner may release, after proven close and before submitting any native input. */
   async release(ref, cwd) {
-    await unlink(path6.join(this.#path(ref, cwd), "started"));
+    await unlink(path7.join(this.#path(ref, cwd), "started"));
     await this.#sync(this.#path(ref, cwd));
   }
   async discard(ref, cwd) {
@@ -42986,7 +43593,7 @@ var ClaudePendingSessions = class {
 };
 
 // dist/claude-fork.js
-import path7 from "node:path";
+import path8 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // dist/item-identity.js
@@ -42996,7 +43603,7 @@ function claudeTranscriptItemId(nativeTurnKey, kind, ordinal) {
 
 // dist/claude-history.js
 var claudeCodeHarnessId = harnessIdSchema.parse("claude-code");
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textParts(value) {
@@ -43004,12 +43611,12 @@ function textParts(value) {
     return value.length > 0 ? [value] : [];
   if (!Array.isArray(value))
     return [];
-  return value.flatMap((part) => isRecord3(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []);
+  return value.flatMap((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []);
 }
 function thinkingParts(value) {
   if (!Array.isArray(value))
     return [];
-  return value.flatMap((part) => isRecord3(part) && part.type === "thinking" && typeof part.thinking === "string" ? [part.thinking] : []);
+  return value.flatMap((part) => isRecord4(part) && part.type === "thinking" && typeof part.thinking === "string" ? [part.thinking] : []);
 }
 var localCommandRecordPattern = /^\s*<(local-command-(?:stdout|caveat))>[\s\S]*<\/\1>\s*$/u;
 var taskNotificationRecordPattern = /^\s*<task-notification>[\s\S]*<\/task-notification>\s*$/u;
@@ -43018,33 +43625,33 @@ var controlCommandNamePattern = /<command-name>\s*\/(?:model|compact)\s*<\/comma
 var recapCommandNamePattern = /<command-name>\s*\/recap\s*<\/command-name>/u;
 var initCommandNamePattern = /<command-name>\s*\/init\s*<\/command-name>/u;
 var localCommandStdoutPattern = /^\s*<local-command-stdout>([\s\S]*)<\/local-command-stdout>\s*$/u;
-function isLocalCommandRecord(text) {
-  return localCommandRecordPattern.test(text);
+function isLocalCommandRecord(text2) {
+  return localCommandRecordPattern.test(text2);
 }
-function isTaskNotificationRecord(text) {
-  return taskNotificationRecordPattern.test(text);
+function isTaskNotificationRecord(text2) {
+  return taskNotificationRecordPattern.test(text2);
 }
-function isControlCommandEnvelope(text) {
-  return commandEnvelopePattern.test(text) && controlCommandNamePattern.test(text);
+function isControlCommandEnvelope(text2) {
+  return commandEnvelopePattern.test(text2) && controlCommandNamePattern.test(text2);
 }
-function isNamedCommandEnvelope(text, namePattern) {
-  return commandEnvelopePattern.test(text) && namePattern.test(text);
+function isNamedCommandEnvelope(text2, namePattern) {
+  return commandEnvelopePattern.test(text2) && namePattern.test(text2);
 }
-function displayedUserText(text) {
-  if (isNamedCommandEnvelope(text, initCommandNamePattern))
+function displayedUserText(text2) {
+  if (isNamedCommandEnvelope(text2, initCommandNamePattern))
     return "/init";
-  if (isNamedCommandEnvelope(text, recapCommandNamePattern))
+  if (isNamedCommandEnvelope(text2, recapCommandNamePattern))
     return "/recap";
-  return text;
+  return text2;
 }
-function localCommandStdoutText(text) {
-  const match = localCommandStdoutPattern.exec(text);
+function localCommandStdoutText(text2) {
+  const match = localCommandStdoutPattern.exec(text2);
   if (!match)
     return null;
   return match[1] ?? "";
 }
 function isTaskNotificationOrigin(value) {
-  return isRecord3(value.origin) && value.origin.kind === "task-notification";
+  return isRecord4(value.origin) && value.origin.kind === "task-notification";
 }
 function visibleUserTextParts(message) {
   if (message.type !== "user" || message.syntheticUser)
@@ -43055,24 +43662,24 @@ function visibleUserTextParts(message) {
   return parts.filter((part) => !isLocalCommandRecord(part) && !isTaskNotificationRecord(part));
 }
 function isInterruptionRecord(value, promptId) {
-  if (value.type !== "user" || promptId === null || value.promptId !== promptId || value.promptSource !== void 0 || !isRecord3(value.message))
+  if (value.type !== "user" || promptId === null || value.promptId !== promptId || value.promptSource !== void 0 || !isRecord4(value.message))
     return false;
   const content = value.message.content;
   if (!Array.isArray(content) || content.length !== 1)
     return false;
   const part = content[0];
-  return isRecord3(part) && part.type === "text" && (part.text === "[Request interrupted by user]" || part.text === "[Request interrupted by user for tool use]");
+  return isRecord4(part) && part.type === "text" && (part.text === "[Request interrupted by user]" || part.text === "[Request interrupted by user for tool use]");
 }
 function conversationMessages(values, sessionId) {
   const messages = [];
   const ids = /* @__PURE__ */ new Set();
   let promptId = null;
   for (const value of values) {
-    if (!isRecord3(value))
+    if (!isRecord4(value))
       throw new Error("Claude history contains a malformed message");
     if (value.type === "system")
       continue;
-    if (value.type !== "user" && value.type !== "assistant" || typeof value.uuid !== "string" || value.uuid.length === 0 || value.session_id !== sessionId || !isRecord3(value.message) || value.message.role !== value.type) {
+    if (value.type !== "user" && value.type !== "assistant" || typeof value.uuid !== "string" || value.uuid.length === 0 || value.session_id !== sessionId || !isRecord4(value.message) || value.message.role !== value.type) {
       throw new Error("Claude history contains an invalid message identity");
     }
     if (ids.has(value.uuid))
@@ -43163,13 +43770,13 @@ function mapClaudeSnapshot(values, sessionId) {
           formatVersion: 1
         })
       } : {},
-      input: visibleUserTextParts(user).map((text) => ({
+      input: visibleUserTextParts(user).map((text2) => ({
         type: "text",
-        text: displayedUserText(text)
+        text: displayedUserText(text2)
       })),
       items: turnMessages.flatMap((message) => {
         if (message.type === "user") {
-          const recapOutput = visibleUserTextParts(user).some((text2) => isNamedCommandEnvelope(text2, recapCommandNamePattern)) ? textParts(message.message.content).map(localCommandStdoutText).find((text2) => text2 !== null && text2.length > 0) : void 0;
+          const recapOutput = visibleUserTextParts(user).some((text3) => isNamedCommandEnvelope(text3, recapCommandNamePattern)) ? textParts(message.message.content).map(localCommandStdoutText).find((text3) => text3 !== null && text3.length > 0) : void 0;
           if (!recapOutput)
             return [];
           return [
@@ -43186,15 +43793,15 @@ function mapClaudeSnapshot(values, sessionId) {
         if (message.type !== "assistant")
           return [];
         const content = message.message.content;
-        const text = textParts(content).join("");
+        const text2 = textParts(content).join("");
         const reasoning = thinkingParts(content).join("");
         if (!Array.isArray(content)) {
-          return text.length > 0 ? [
+          return text2.length > 0 ? [
             {
               item: {
                 type: "agentMessage",
                 itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
-                text
+                text: text2
               },
               outcome: itemOutcome(outcome)
             }
@@ -43204,7 +43811,7 @@ function mapClaudeSnapshot(values, sessionId) {
         let projectedReasoning = false;
         let projectedText = false;
         for (const [blockIndex, block] of content.entries()) {
-          if (!isRecord3(block))
+          if (!isRecord4(block))
             continue;
           if (block.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
             items.push({
@@ -43218,12 +43825,12 @@ function mapClaudeSnapshot(values, sessionId) {
             projectedReasoning = true;
             continue;
           }
-          if (block.type === "text" && !projectedText && text.length > 0) {
+          if (block.type === "text" && !projectedText && text2.length > 0) {
             items.push({
               item: {
                 type: "agentMessage",
                 itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
-                text
+                text: text2
               },
               outcome: itemOutcome(outcome)
             });
@@ -43247,7 +43854,7 @@ function mapClaudeSnapshot(values, sessionId) {
             }
           } : { status: "succeeded" };
           const itemId = hostItemIdSchema.parse(`claude-item-v1-${message.uuid}-tool-${blockIndex}`);
-          if (block.name === "Bash" && isRecord3(block.input) && typeof block.input.command === "string") {
+          if (block.name === "Bash" && isRecord4(block.input) && typeof block.input.command === "string") {
             items.push({
               item: {
                 type: "commandExecution",
@@ -43285,7 +43892,7 @@ function toolResultBlocks(messages) {
     if (message.type !== "user" || !Array.isArray(message.message.content))
       continue;
     for (const block of message.message.content) {
-      if (isRecord3(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      if (isRecord4(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
         results.set(block.tool_use_id, block);
       }
     }
@@ -43295,12 +43902,12 @@ function toolResultBlocks(messages) {
 function toolResultOutput(block) {
   if (!block)
     return void 0;
-  const text = textParts(block.content).join("");
-  return text.length > 0 ? text : void 0;
+  const text2 = textParts(block.content).join("");
+  return text2.length > 0 ? text2 : void 0;
 }
 function resultSubagentId(value, block) {
   const nativeResult = value.tool_use_result;
-  if (isRecord3(nativeResult)) {
+  if (isRecord4(nativeResult)) {
     const structured = nativeResult.agentId ?? nativeResult.agent_id ?? nativeResult.task_id;
     if (typeof structured === "string" && structured.length > 0)
       return structured;
@@ -43311,13 +43918,13 @@ function resultSubagentId(value, block) {
 function subagentPrompt(values, nativeSubagentId2) {
   const toolUses = /* @__PURE__ */ new Map();
   for (const value of values) {
-    if (!isRecord3(value) || !isRecord3(value.message) || !Array.isArray(value.message.content)) {
+    if (!isRecord4(value) || !isRecord4(value.message) || !Array.isArray(value.message.content)) {
       continue;
     }
     for (const block of value.message.content) {
-      if (!isRecord3(block))
+      if (!isRecord4(block))
         continue;
-      if (block.type === "tool_use" && typeof block.id === "string" && (block.name === "Agent" || block.name === "Task") && isRecord3(block.input) && typeof block.input.prompt === "string" && block.input.prompt.length > 0) {
+      if (block.type === "tool_use" && typeof block.id === "string" && (block.name === "Agent" || block.name === "Task") && isRecord4(block.input) && typeof block.input.prompt === "string" && block.input.prompt.length > 0) {
         toolUses.set(block.id, block.input.prompt);
         continue;
       }
@@ -43331,7 +43938,7 @@ function subagentPrompt(values, nativeSubagentId2) {
   return void 0;
 }
 function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, parentValues = []) {
-  const messages = conversationMessages(values.map((value) => isRecord3(value) ? { ...value, session_id: parentSessionId } : value), parentSessionId);
+  const messages = conversationMessages(values.map((value) => isRecord4(value) ? { ...value, session_id: parentSessionId } : value), parentSessionId);
   const turns = [];
   for (let index = 0; index < messages.length; ) {
     const first = messages[index];
@@ -43358,7 +43965,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
       const content = Array.isArray(message.message.content) ? message.message.content : [{ type: "text", text: message.message.content }];
       for (let blockIndex = 0; blockIndex < content.length; blockIndex += 1) {
         const block = content[blockIndex];
-        if (!isRecord3(block))
+        if (!isRecord4(block))
           continue;
         const itemId = hostItemIdSchema.parse(`claude-subagent-item-v2-${nativeSubagentId2}-${message.uuid}-${blockIndex}`);
         if (block.type === "thinking" && typeof block.thinking === "string") {
@@ -43395,7 +44002,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
             retryable: false
           }
         } : { status: "succeeded" };
-        if (block.name === "Bash" && isRecord3(block.input) && typeof block.input.command === "string") {
+        if (block.name === "Bash" && isRecord4(block.input) && typeof block.input.command === "string") {
           items.push({
             item: {
               type: "commandExecution",
@@ -43437,7 +44044,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
           formatVersion: 1
         })
       } : {},
-      input: user ? visibleUserTextParts(user).map((text) => ({ type: "text", text })) : turns.length === 0 ? [subagentPrompt(parentValues, nativeSubagentId2)].filter((text) => text !== void 0).map((text) => ({ type: "text", text })) : [],
+      input: user ? visibleUserTextParts(user).map((text2) => ({ type: "text", text: text2 })) : turns.length === 0 ? [subagentPrompt(parentValues, nativeSubagentId2)].filter((text2) => text2 !== void 0).map((text2) => ({ type: "text", text: text2 })) : [],
       items,
       outcome
     });
@@ -43525,7 +44132,7 @@ async function forkClaudeSession(input) {
       error: error51("protocolError", "Claude Code Session working directory is unavailable", false)
     };
   }
-  if (path7.resolve(sourceInfo.cwd) !== input.cwd) {
+  if (path8.resolve(sourceInfo.cwd) !== input.cwd) {
     return {
       ok: false,
       error: error51("unsupported", "Claude Code cannot Fork across working directories", false)
@@ -43626,25 +44233,25 @@ async function forkClaudeSession(input) {
 
 // dist/claude-transcript.js
 import os5 from "node:os";
-import path8 from "node:path";
-import { readFile as readFile3, readdir, stat as stat3 } from "node:fs/promises";
+import path9 from "node:path";
+import { readFile as readFile3, readdir, stat as stat4 } from "node:fs/promises";
 function projectDirectoryName(cwd) {
   return cwd.replace(/[^A-Za-z0-9]/gu, "-");
 }
 function configDirectory(environment) {
-  return environment.CLAUDE_CONFIG_DIR ? path8.resolve(environment.CLAUDE_CONFIG_DIR) : path8.join(os5.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path9.resolve(environment.CLAUDE_CONFIG_DIR) : path9.join(os5.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
-    return (await stat3(file2)).isFile();
+    return (await stat4(file2)).isFile();
   } catch {
     return false;
   }
 }
 async function findTranscript(input) {
-  const projectsDirectory = path8.join(configDirectory(input.environment), "projects");
+  const projectsDirectory = path9.join(configDirectory(input.environment), "projects");
   const name = `${input.sessionId}.jsonl`;
-  const expected = path8.join(projectsDirectory, projectDirectoryName(input.cwd), name);
+  const expected = path9.join(projectsDirectory, projectDirectoryName(input.cwd), name);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -43654,13 +44261,13 @@ async function findTranscript(input) {
     return null;
   }
   for (const project of projects) {
-    const candidate = path8.join(projectsDirectory, project, name);
+    const candidate = path9.join(projectsDirectory, project, name);
     if (await existingFile(candidate))
       return candidate;
   }
   return null;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readClaudeTranscript(input) {
@@ -43678,7 +44285,7 @@ async function readClaudeTranscript(input) {
     } catch {
       continue;
     }
-    if (!isRecord4(entry) || entry.type !== "user" && entry.type !== "assistant" || typeof entry.uuid !== "string" || !isRecord4(entry.message)) {
+    if (!isRecord5(entry) || entry.type !== "user" && entry.type !== "assistant" || typeof entry.uuid !== "string" || !isRecord5(entry.message)) {
       continue;
     }
     messages.push({ ...entry, session_id: input.sessionId });
@@ -43690,7 +44297,7 @@ async function readClaudeTranscript(input) {
 import { Buffer as Buffer2 } from "node:buffer";
 import { readFile as readFile4 } from "node:fs/promises";
 import os6 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // dist/thinking-options.js
 var option = (id, label) => ({
@@ -43772,7 +44379,7 @@ function decodeClaudeModelRef(ref) {
   return value === "default" ? void 0 : value;
 }
 function resolveClaudeConfigDirectory(environment = process.env) {
-  return path9.resolve(environment.CLAUDE_CONFIG_DIR ?? path9.join(os6.homedir(), ".claude"));
+  return path10.resolve(environment.CLAUDE_CONFIG_DIR ?? path10.join(os6.homedir(), ".claude"));
 }
 function parseModelPickerOptions(value) {
   if (!Array.isArray(value))
@@ -43814,7 +44421,7 @@ function parseClaudeModelPickerSettings(value) {
   };
 }
 async function readClaudeUserModelPicker(environment = process.env) {
-  const settingsPath = path9.join(resolveClaudeConfigDirectory(environment), "settings.json");
+  const settingsPath = path10.join(resolveClaudeConfigDirectory(environment), "settings.json");
   let raw;
   try {
     raw = await readFile4(settingsPath, "utf8");
@@ -44125,7 +44732,7 @@ function projectClaudeAccountUsage(usage, account) {
 }
 
 // dist/file-change.js
-import path10 from "node:path";
+import path11 from "node:path";
 var hunkSchema = external_exports.object({
   oldStart: external_exports.number().int().nonnegative(),
   oldLines: external_exports.number().int().nonnegative(),
@@ -44133,7 +44740,7 @@ var hunkSchema = external_exports.object({
   newLines: external_exports.number().int().nonnegative(),
   lines: external_exports.array(external_exports.string())
 }).strict();
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validNativePath(value) {
@@ -44157,7 +44764,7 @@ function validHunk(value) {
   return hunk;
 }
 function parseClaudeNativeFileChange(toolName, value) {
-  if (toolName !== "Edit" && toolName !== "Write" || !isRecord5(value))
+  if (toolName !== "Edit" && toolName !== "Write" || !isRecord6(value))
     return null;
   if (!validNativePath(value.filePath) || !Array.isArray(value.structuredPatch))
     return null;
@@ -44173,10 +44780,10 @@ function parseClaudeNativeFileChange(toolName, value) {
   };
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path10.resolve(cwd);
-  const resolvedPath = path10.isAbsolute(nativePath) ? path10.resolve(nativePath) : path10.resolve(cwd, nativePath);
-  const relative = path10.relative(resolvedCwd, resolvedPath);
-  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path10.sep}`) ? relative : resolvedPath;
+  const resolvedCwd = path11.resolve(cwd);
+  const resolvedPath = path11.isAbsolute(nativePath) ? path11.resolve(nativePath) : path11.resolve(cwd, nativePath);
+  const relative = path11.relative(resolvedCwd, resolvedPath);
+  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path11.sep}`) ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   return validNativePath(normalized) && normalized !== "." ? normalized : null;
 }
@@ -44188,7 +44795,7 @@ function projectClaudeFileChange(value, cwd) {
     `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
     ...hunk.lines
   ]);
-  const absoluteDisplayPath = path10.posix.isAbsolute(normalizedPath);
+  const absoluteDisplayPath = path11.posix.isAbsolute(normalizedPath);
   const oldHeader = value.kind === "add" ? "/dev/null" : absoluteDisplayPath ? normalizedPath : `a/${normalizedPath}`;
   const newHeader = absoluteDisplayPath ? normalizedPath : `b/${normalizedPath}`;
   const unifiedDiff = [`--- ${oldHeader}`, `+++ ${newHeader}`, ...body, ""].join("\n");
@@ -44201,7 +44808,7 @@ var AUTHENTICATION_ERRORS = /* @__PURE__ */ new Set(["authentication_failed", "o
 var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task", "SendMessage"]);
 var SUBAGENT_DESCRIPTION_LIMIT = 500;
 var SUBAGENT_SUMMARY_LIMIT = 2e3;
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nativeUuid(message) {
@@ -44211,12 +44818,12 @@ function parentToolUseId(message) {
   return typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0 ? message.parent_tool_use_id : null;
 }
 function assistantNativeMessageId(message) {
-  if (!isRecord6(message.message))
+  if (!isRecord7(message.message))
     return null;
   return typeof message.message.id === "string" && message.message.id.length > 0 ? message.message.id : null;
 }
 function assistantContent(message) {
-  if (message.type !== "assistant" || !isRecord6(message.message))
+  if (message.type !== "assistant" || !isRecord7(message.message))
     return null;
   return Array.isArray(message.message.content) ? message.message.content : null;
 }
@@ -44224,10 +44831,10 @@ function assistantText(message) {
   const content = assistantContent(message);
   if (!content)
     return null;
-  return content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+  return content.flatMap((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
 }
 function assistantError(message) {
-  return isRecord6(message) && message.type === "assistant" && typeof message.error === "string" ? message.error : null;
+  return isRecord7(message) && message.type === "assistant" && typeof message.error === "string" ? message.error : null;
 }
 function boundedString(value, limit) {
   if (typeof value !== "string")
@@ -44238,33 +44845,33 @@ function boundedString(value, limit) {
   return trimmed.slice(0, limit);
 }
 function subagentDescription(argumentsValue, toolName) {
-  if (!isRecord6(argumentsValue))
+  if (!isRecord7(argumentsValue))
     return `${toolName} delegation`;
   return boundedString(argumentsValue.description, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.summary, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.name, SUBAGENT_DESCRIPTION_LIMIT) ?? `${toolName} delegation`;
 }
 function subagentPrompt2(argumentsValue) {
-  if (!isRecord6(argumentsValue))
+  if (!isRecord7(argumentsValue))
     return void 0;
   return boundedString(argumentsValue.prompt ?? argumentsValue.message, SUBAGENT_SUMMARY_LIMIT);
 }
 function subagentRole(argumentsValue) {
-  if (!isRecord6(argumentsValue))
+  if (!isRecord7(argumentsValue))
     return void 0;
   return boundedString(argumentsValue.subagent_type ?? argumentsValue.agent_type, SUBAGENT_DESCRIPTION_LIMIT);
 }
 function subagentBackground(argumentsValue) {
-  return isRecord6(argumentsValue) && argumentsValue.run_in_background === true;
+  return isRecord7(argumentsValue) && argumentsValue.run_in_background === true;
 }
 function targetedSubagentId(argumentsValue) {
-  if (!isRecord6(argumentsValue))
+  if (!isRecord7(argumentsValue))
     return void 0;
   return boundedString(argumentsValue.to ?? argumentsValue.recipient ?? argumentsValue.agentId, SUBAGENT_DESCRIPTION_LIMIT);
 }
 function includesAuthenticationFailure(message, errors) {
   if (errors.some((error52) => AUTHENTICATION_ERRORS.has(error52)))
     return true;
-  const text = [message.result, ...Array.isArray(message.errors) ? message.errors : []].filter((value) => typeof value === "string").join(" ").toLowerCase();
-  return text.includes("not logged in") || text.includes("invalid api key") || text.includes("oauth");
+  const text2 = [message.result, ...Array.isArray(message.errors) ? message.errors : []].filter((value) => typeof value === "string").join(" ").toLowerCase();
+  return text2.includes("not logged in") || text2.includes("invalid api key") || text2.includes("oauth");
 }
 function failure(kind) {
   return { status: "failed", kind };
@@ -44276,11 +44883,11 @@ function finiteNonNegativeNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 function parseResultModelUsage(value) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return void 0;
   const usage = [];
   for (const entry of Object.values(value)) {
-    if (!isRecord6(entry) || !safeNonNegativeInteger(entry.inputTokens) || !safeNonNegativeInteger(entry.outputTokens)) {
+    if (!isRecord7(entry) || !safeNonNegativeInteger(entry.inputTokens) || !safeNonNegativeInteger(entry.outputTokens)) {
       return void 0;
     }
     usage.push({ inputTokens: entry.inputTokens, outputTokens: entry.outputTokens });
@@ -44288,7 +44895,7 @@ function parseResultModelUsage(value) {
   return usage;
 }
 function parseLastRequestUsage(value, attribution = {}) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return void 0;
   const inputTokens = value.input_tokens;
   const outputTokens = value.output_tokens;
@@ -44311,7 +44918,7 @@ function parseLastRequestUsage(value, attribution = {}) {
   };
 }
 function assistantRequestUsage(message, provider) {
-  if (!isRecord6(message.message))
+  if (!isRecord7(message.message))
     return void 0;
   return parseLastRequestUsage(message.message.usage, {
     requestId: message.message.id ?? message.request_id,
@@ -44334,7 +44941,7 @@ function parseResultUsageEvent(message) {
   };
 }
 function parsePlanLimitWindow(value) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return void 0;
   const utilization = value.utilization;
   if (typeof utilization !== "number" || !Number.isFinite(utilization) || utilization < 0) {
@@ -44346,12 +44953,12 @@ function parsePlanLimitWindow(value) {
   return { utilizationPercent, ...resetsAtUnix !== void 0 ? { resetsAtUnix } : {} };
 }
 function parseClaudePlanLimitEvent(message) {
-  if (!isRecord6(message) || message.type !== "rate_limit_event")
+  if (!isRecord7(message) || message.type !== "rate_limit_event")
     return null;
   const info = message.rate_limit_info;
-  if (!isRecord6(info))
+  if (!isRecord7(info))
     return null;
-  const windows = isRecord6(info.unifiedWindows) ? info.unifiedWindows : void 0;
+  const windows = isRecord7(info.unifiedWindows) ? info.unifiedWindows : void 0;
   let fiveHour = parsePlanLimitWindow(windows?.five_hour);
   let sevenDay = parsePlanLimitWindow(windows?.seven_day);
   if (!fiveHour && !sevenDay) {
@@ -44369,7 +44976,7 @@ function parseClaudePlanLimitEvent(message) {
   };
 }
 function nativeSubagentId(nativeResult, outputText) {
-  if (isRecord6(nativeResult)) {
+  if (isRecord7(nativeResult)) {
     const structured = boundedString(nativeResult.agentId ?? nativeResult.agent_id ?? nativeResult.task_id, SUBAGENT_DESCRIPTION_LIMIT);
     if (structured)
       return structured;
@@ -44377,7 +44984,7 @@ function nativeSubagentId(nativeResult, outputText) {
   return boundedString(/agentId:\s*([A-Za-z0-9_-]+)/u.exec(outputText ?? "")?.[1], SUBAGENT_DESCRIPTION_LIMIT);
 }
 function subagentContinuesInBackground(nativeResult, outputText) {
-  if (isRecord6(nativeResult)) {
+  if (isRecord7(nativeResult)) {
     if (nativeResult.isAsync === true || nativeResult.is_async === true)
       return true;
     if (nativeResult.status === "async_launched")
@@ -44386,15 +44993,15 @@ function subagentContinuesInBackground(nativeResult, outputText) {
   return outputText?.includes("The agent is working in the background.") ?? false;
 }
 function resultText(content, nativeResult) {
-  let text = "";
+  let text2 = "";
   if (typeof content === "string") {
-    text = content;
+    text2 = content;
   } else if (Array.isArray(content)) {
-    text = content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+    text2 = content.flatMap((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
   }
-  if (text.length > 0)
-    return text;
-  if (!isRecord6(nativeResult))
+  if (text2.length > 0)
+    return text2;
+  if (!isRecord7(nativeResult))
     return void 0;
   const stdout = typeof nativeResult.stdout === "string" ? nativeResult.stdout : "";
   const stderr = typeof nativeResult.stderr === "string" ? nativeResult.stderr : "";
@@ -44406,13 +45013,13 @@ function userMessageText(content) {
     return content;
   if (!Array.isArray(content))
     return null;
-  const text = content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
-  return text.length > 0 ? text : null;
+  const text2 = content.flatMap((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+  return text2.length > 0 ? text2 : null;
 }
 function parseClaudeTaskNotification(message) {
-  if (!isRecord6(message) || message.type !== "user" || !isRecord6(message.message))
+  if (!isRecord7(message) || message.type !== "user" || !isRecord7(message.message))
     return null;
-  if (isRecord6(message.origin) && message.origin.kind !== "task-notification")
+  if (isRecord7(message.origin) && message.origin.kind !== "task-notification")
     return null;
   const content = userMessageText(message.message.content);
   if (!content || !content.includes("<task-notification>"))
@@ -44471,7 +45078,7 @@ var ClaudeNativeTurnAccumulator = class {
     this.#cancelRequested = true;
   }
   consume(message) {
-    if (this.#completed || !isRecord6(message))
+    if (this.#completed || !isRecord7(message))
       return { events: [] };
     const events = [];
     this.#consumeSegmentLevel(message, events);
@@ -44485,7 +45092,7 @@ var ClaudeNativeTurnAccumulator = class {
       this.#consumeCompaction(message, events);
       this.#consumeLocalCommandOutput(message, events);
     }
-    if (message.type === "stream_event" && isRecord6(message.event)) {
+    if (message.type === "stream_event" && isRecord7(message.event)) {
       if (!nested)
         this.#consumeStreamEvent(message, events);
     } else if (message.type === "tool_progress") {
@@ -44592,7 +45199,7 @@ var ClaudeNativeTurnAccumulator = class {
     if (message.subtype !== "background_tasks_changed" || !Array.isArray(message.tasks))
       return;
     const nativeSubagentIds = message.tasks.flatMap((task) => {
-      if (!isRecord6(task))
+      if (!isRecord7(task))
         return [];
       const taskId = boundedString(task.task_id, SUBAGENT_DESCRIPTION_LIMIT);
       return taskId ? [taskId] : [];
@@ -44652,7 +45259,7 @@ var ClaudeNativeTurnAccumulator = class {
       });
       return;
     }
-    if (message.subtype === "task_updated" && isRecord6(message.patch)) {
+    if (message.subtype === "task_updated" && isRecord7(message.patch)) {
       const status = taskStatus(message.patch.status);
       if (!status)
         return;
@@ -44671,14 +45278,14 @@ var ClaudeNativeTurnAccumulator = class {
   }
   #consumeStreamEvent(message, events) {
     const event = message.event;
-    if (!isRecord6(event))
+    if (!isRecord7(event))
       return;
-    if (event.type === "message_start" && isRecord6(event.message) && typeof event.message.id === "string" && event.message.id.length > 0) {
+    if (event.type === "message_start" && isRecord7(event.message) && typeof event.message.id === "string" && event.message.id.length > 0) {
       this.#activeRootStreamMessageId = event.message.id;
       this.#messageState(event.message.id);
       return;
     }
-    if (event.type !== "content_block_delta" || !isRecord6(event.delta))
+    if (event.type !== "content_block_delta" || !isRecord7(event.delta))
       return;
     const messageId = this.#activeRootStreamMessageId ?? nativeUuid(message) ?? this.#nextMessageId();
     if (!this.#activeRootStreamMessageId)
@@ -44754,7 +45361,7 @@ var ClaudeNativeTurnAccumulator = class {
   }
   #consumeToolUseBlocks(message, events, ignoreKnownIds) {
     for (const block of assistantContent(message) ?? []) {
-      if (!isRecord6(block) || block.type !== "tool_use")
+      if (!isRecord7(block) || block.type !== "tool_use")
         continue;
       const argumentsResult = jsonValueSchema.safeParse(block.input);
       if (typeof block.id !== "string" || block.id.length === 0 || typeof block.name !== "string" || block.name.length === 0 || !argumentsResult.success) {
@@ -44806,9 +45413,9 @@ var ClaudeNativeTurnAccumulator = class {
       events.push(settled);
   }
   #consumeToolResults(message, events, ignoreUnknown) {
-    if (!isRecord6(message.message) || !Array.isArray(message.message.content))
+    if (!isRecord7(message.message) || !Array.isArray(message.message.content))
       return;
-    const resultBlocks = message.message.content.filter((block) => isRecord6(block) && block.type === "tool_result");
+    const resultBlocks = message.message.content.filter((block) => isRecord7(block) && block.type === "tool_result");
     if (resultBlocks.length === 0)
       return;
     if (resultBlocks.length > 1 && message.tool_use_result !== void 0) {
@@ -44877,7 +45484,7 @@ var ClaudeNativeTurnAccumulator = class {
 
 // dist/process-fence.js
 import { execFile } from "node:child_process";
-import path11 from "node:path";
+import path12 from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify } from "node:util";
 var executeFile = promisify(execFile);
@@ -44901,9 +45508,9 @@ async function closeClaudeProcessGroup(child, timeoutMs) {
     if (child.exitCode !== null || child.signalCode !== null)
       throw new Error("Claude process tree cannot be confirmed after its Windows root exited");
     const root = process.env.SystemRoot ?? process.env.SYSTEMROOT;
-    if (!root || !path11.win32.isAbsolute(root))
+    if (!root || !path12.win32.isAbsolute(root))
       throw new Error("Windows SystemRoot is unavailable");
-    await executeFile(path11.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
+    await executeFile(path12.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
       timeout: timeoutMs,
       windowsHide: true
     });
@@ -44990,17 +45597,17 @@ function allowsDangerouslySkipPermissions(getuid = process.getuid) {
 function processExited(child) {
   return child.exitCode !== null || child.signalCode !== null;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function permissionModeFromMessage(value) {
-  if (!isRecord7(value) || value.type !== "system" || value.subtype !== "init" && value.subtype !== "status" || !("permissionMode" in value) || value.permissionMode === void 0) {
+  if (!isRecord8(value) || value.type !== "system" || value.subtype !== "init" && value.subtype !== "status" || !("permissionMode" in value) || value.permissionMode === void 0) {
     return void 0;
   }
   return isClaudePermissionMode(value.permissionMode) ? value.permissionMode : void 0;
 }
 function parseContextUsage(value) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     throw new Error("Claude SDK context Usage is invalid");
   const usedTokens = value.totalTokens;
   const maxTokens = value.maxTokens;
@@ -45017,7 +45624,7 @@ function parseQuestions(input) {
   const questions = [];
   const questionTexts = /* @__PURE__ */ new Set();
   for (const value of input.questions) {
-    if (!isRecord7(value))
+    if (!isRecord8(value))
       return null;
     const question = value.question;
     const header = value.header;
@@ -45028,7 +45635,7 @@ function parseQuestions(input) {
     const labels = /* @__PURE__ */ new Set();
     const options = [];
     for (const option2 of value.options) {
-      if (!isRecord7(option2) || typeof option2.label !== "string" || option2.label.length === 0 || labels.has(option2.label) || typeof option2.description !== "string") {
+      if (!isRecord8(option2) || typeof option2.label !== "string" || option2.label.length === 0 || labels.has(option2.label) || typeof option2.description !== "string") {
         return null;
       }
       labels.add(option2.label);
@@ -45042,8 +45649,8 @@ function parseQuestions(input) {
 function boundedDisplayText(value, maxLength) {
   if (typeof value !== "string")
     return null;
-  const text = value.trim();
-  return text.length > 0 && text.length <= maxLength ? text : null;
+  const text2 = value.trim();
+  return text2.length > 0 && text2.length <= maxLength ? text2 : null;
 }
 var SESSION_PERMISSION_DESTINATIONS = /* @__PURE__ */ new Set(["session", "cliArg"]);
 var PERSISTENT_PERMISSION_DESTINATIONS = /* @__PURE__ */ new Set([
@@ -45070,7 +45677,7 @@ function permissionUpdateDestination(value) {
   return void 0;
 }
 function isPermissionUpdate(value) {
-  if (!isRecord7(value) || !permissionUpdateDestination(value.destination))
+  if (!isRecord8(value) || !permissionUpdateDestination(value.destination))
     return false;
   if (value.type === "setMode") {
     return typeof value.mode === "string" && PERMISSION_MODES.has(value.mode);
@@ -45079,7 +45686,7 @@ function isPermissionUpdate(value) {
     return Array.isArray(value.directories) && value.directories.every((directory) => typeof directory === "string");
   }
   if (value.type === "addRules" || value.type === "replaceRules" || value.type === "removeRules") {
-    return typeof value.behavior === "string" && PERMISSION_BEHAVIORS.has(value.behavior) && Array.isArray(value.rules) && value.rules.every((rule) => isRecord7(rule) && typeof rule.toolName === "string" && (rule.ruleContent === void 0 || typeof rule.ruleContent === "string"));
+    return typeof value.behavior === "string" && PERMISSION_BEHAVIORS.has(value.behavior) && Array.isArray(value.rules) && value.rules.every((rule) => isRecord8(rule) && typeof rule.toolName === "string" && (rule.ruleContent === void 0 || typeof rule.ruleContent === "string"));
   }
   return false;
 }
@@ -45251,7 +45858,7 @@ var ClaudeSdkTransport = class {
     return { commands: this.#slashCommands, skillNames: this.#skillNames };
   }
   #observeSlashCommands(message) {
-    if (!isRecord7(message) || message.type !== "system")
+    if (!isRecord8(message) || message.type !== "system")
       return;
     if (message.subtype === "init" && Array.isArray(message.skills)) {
       this.#skillNames = new Set(message.skills.filter((name) => typeof name === "string"));
@@ -45301,7 +45908,7 @@ var ClaudeSdkTransport = class {
   recap(userMessageId, onEvent) {
     return this.runTurn("/recap", userMessageId, onEvent);
   }
-  runTurn(text, userMessageId, onEvent) {
+  runTurn(text2, userMessageId, onEvent) {
     if (this.#closePromise || !this.#started || !this.#query) {
       return Promise.reject(new Error("Claude SDK transport is not started"));
     }
@@ -45319,7 +45926,7 @@ var ClaudeSdkTransport = class {
     });
     this.#input.push({
       type: "user",
-      message: { role: "user", content: text },
+      message: { role: "user", content: text2 },
       parent_tool_use_id: null,
       session_id: this.sessionId,
       uuid: userMessageId,
@@ -45535,10 +46142,10 @@ var ClaudeSdkTransport = class {
     }
   }
   #observeBackgroundTasks(message) {
-    if (!isRecord7(message) || message.type !== "system")
+    if (!isRecord8(message) || message.type !== "system")
       return;
     if (message.subtype === "background_tasks_changed" && Array.isArray(message.tasks)) {
-      this.#backgroundTasks = new Set(message.tasks.flatMap((task) => isRecord7(task) && typeof task.task_id === "string" ? [task.task_id] : []));
+      this.#backgroundTasks = new Set(message.tasks.flatMap((task) => isRecord8(task) && typeof task.task_id === "string" ? [task.task_id] : []));
     } else if (message.subtype === "task_started" && typeof message.task_id === "string") {
       this.#backgroundTasks.add(message.task_id);
     } else if (message.subtype === "task_notification" && typeof message.task_id === "string" && ["completed", "failed", "stopped"].includes(String(message.status))) {
@@ -45588,7 +46195,7 @@ var ClaudeSdkTransport = class {
           events: [],
           nativeTurnKey: null
         });
-        if (autonomous.nativeTurnKey === null && isRecord7(message) && message.type === "user" && (message.parent_tool_use_id === null || message.parent_tool_use_id === void 0) && typeof message.uuid === "string" && message.uuid.length > 0) {
+        if (autonomous.nativeTurnKey === null && isRecord8(message) && message.type === "user" && (message.parent_tool_use_id === null || message.parent_tool_use_id === void 0) && typeof message.uuid === "string" && message.uuid.length > 0) {
           autonomous.nativeTurnKey = message.uuid;
         }
         const interpreted = autonomous.accumulator.consume(message);
@@ -45931,11 +46538,11 @@ var ClaudeSubagentLifecycle = class {
 };
 
 // dist/task-tracker.js
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(value, keys) {
-  if (!isRecord8(value))
+  if (!isRecord9(value))
     return void 0;
   for (const key of keys) {
     const field = value[key];
@@ -45970,7 +46577,7 @@ var ClaudeTaskTracker = class {
     };
   }
   #create(args, result) {
-    if (!isRecord8(result) || !isRecord8(result.task))
+    if (!isRecord9(result) || !isRecord9(result.task))
       return;
     const id = stringField(result.task, ["id"]);
     const subject = stringField(args, ["subject"]) ?? stringField(result.task, ["subject"]);
@@ -45988,7 +46595,7 @@ var ClaudeTaskTracker = class {
     const id = stringField(args, ["taskId", "id", "task_id"]);
     if (!id)
       return;
-    const status = isRecord8(args) ? taskStatus2(args.status) : void 0;
+    const status = isRecord9(args) ? taskStatus2(args.status) : void 0;
     if (status === "deleted") {
       this.#tasks.delete(id);
       return;
@@ -46006,13 +46613,13 @@ var ClaudeTaskTracker = class {
     });
   }
   #replace(result) {
-    if (!isRecord8(result) || !Array.isArray(result.tasks))
+    if (!isRecord9(result) || !Array.isArray(result.tasks))
       return;
     const next = /* @__PURE__ */ new Map();
     for (const value of result.tasks) {
       const id = stringField(value, ["id"]);
       const subject = stringField(value, ["subject"]);
-      const status = isRecord8(value) ? taskStatus2(value.status) : void 0;
+      const status = isRecord9(value) ? taskStatus2(value.status) : void 0;
       if (!id || !subject || !status || status === "deleted")
         continue;
       const existing = this.#tasks.get(id);
@@ -46030,11 +46637,11 @@ var ClaudeTaskTracker = class {
 };
 
 // dist/tool-lifecycle.js
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField2(value, key) {
-  return isRecord9(value) && typeof value[key] === "string" ? value[key] : void 0;
+  return isRecord10(value) && typeof value[key] === "string" ? value[key] : void 0;
 }
 function toolFailure(toolName) {
   return {
@@ -46043,17 +46650,17 @@ function toolFailure(toolName) {
     retryable: false
   };
 }
-function boundedToolOutput(text, limit) {
-  if (!text || text.length === 0)
+function boundedToolOutput(text2, limit) {
+  if (!text2 || text2.length === 0)
     return void 0;
-  const truncated = text.length > limit;
+  const truncated = text2.length > limit;
   return {
-    content: [{ type: "text", text: truncated ? text.slice(0, limit) : text }],
+    content: [{ type: "text", text: truncated ? text2.slice(0, limit) : text2 }],
     ...truncated ? { truncated: true } : {}
   };
 }
 function toolOutputText(output) {
-  return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
+  return output?.content.filter((content) => content.type === "text").map(({ text: text2 }) => text2).join("") ?? "";
 }
 var ClaudeToolLifecycle = class {
   #cwd;
@@ -46282,7 +46889,7 @@ var CONTEXT_USAGE_TTL_MS = 1e4;
 var CONTEXT_USAGE_FAILURE_COOLDOWN_MS = 5e3;
 var REQUEST_USAGE_RETRY_DELAYS_MS = [0, 100, 250, 500, 1e3];
 var DEFAULT_CONTINUATION_QUIESCENCE_MS = 2e3;
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function safeNonNegativeInteger2(value) {
@@ -46291,7 +46898,7 @@ function safeNonNegativeInteger2(value) {
 function transcriptRequestUsage(messages, messageId) {
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     const entry = messages[index];
-    if (!isRecord10(entry) || entry.type !== "assistant" || entry.parent_tool_use_id !== null && entry.parent_tool_use_id !== void 0 || !isRecord10(entry.message) || entry.message.id !== messageId || !isRecord10(entry.message.usage)) {
+    if (!isRecord11(entry) || entry.type !== "assistant" || entry.parent_tool_use_id !== null && entry.parent_tool_use_id !== void 0 || !isRecord11(entry.message) || entry.message.id !== messageId || !isRecord11(entry.message.usage)) {
       continue;
     }
     const inputTokens = entry.message.usage.input_tokens;
@@ -46340,8 +46947,8 @@ function startupFailure(error52) {
   if (error52 instanceof ClaudeCodeExecutableError) {
     return { code: "notInstalled", message: error52.message, retryable: false };
   }
-  const text = error52 instanceof Error ? error52.message.toLowerCase() : "";
-  if (text.includes("not logged in") || text.includes("authentication") || text.includes("api key")) {
+  const text2 = error52 instanceof Error ? error52.message.toLowerCase() : "";
+  if (text2.includes("not logged in") || text2.includes("authentication") || text2.includes("api key")) {
     return {
       code: "authenticationRequired",
       message: "Claude Code authentication is required",
@@ -46543,7 +47150,7 @@ var ClaudeHarnessSession = class {
             cwd: this.#cwd,
             sessionId: this.#sessionId
           });
-          const ids = new Set(messages.flatMap((message) => isRecord10(message) && typeof message.uuid === "string" ? [message.uuid] : []));
+          const ids = new Set(messages.flatMap((message) => isRecord11(message) && typeof message.uuid === "string" ? [message.uuid] : []));
           if (this.#unpersistedMessageIds.every((id) => ids.has(id))) {
             this.#unpersistedMessageIds = [];
             break;
@@ -46639,8 +47246,8 @@ var ClaudeHarnessSession = class {
         }
       };
     }
-    const text = command.input.map((input) => input.text).join("\n");
-    if (text.length === 0) {
+    const text2 = command.input.map((input) => input.text).join("\n");
+    if (text2.length === 0) {
       return {
         ok: false,
         error: {
@@ -46727,7 +47334,7 @@ var ClaudeHarnessSession = class {
         nativeTurnKey,
         formatVersion: 1
       });
-      const running = transport.runTurn(text, nativeTurnRef.nativeTurnKey, (event) => {
+      const running = transport.runTurn(text2, nativeTurnRef.nativeTurnKey, (event) => {
         this.#handleTurnEvent(active, event);
       });
       active.nativeTurnRef = nativeTurnRef;
@@ -48162,6 +48769,10 @@ var ClaudeCodeAdapter = class {
       };
     }
   });
+  nativeUsage = Object.freeze({
+    read: (cursor, onProgress) => this.#readImport((signal) => readClaudeNativeUsage(this.#environment, cursor, signal, onProgress), "Claude Code usage records could not be read; check storage access and retry"),
+    resumeCommand: (nativeSessionId) => `claude --resume ${nativeSessionId}`
+  });
   subagents = {
     readSnapshot: async (input) => {
       if (input.parent.harnessId !== this.harnessId || input.nativeSubagentId.trim().length === 0) {
@@ -48205,6 +48816,7 @@ var ClaudeCodeAdapter = class {
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #dependencies;
+  #environment;
   #importAbort = new AbortController();
   #importIndex;
   #importRequests = /* @__PURE__ */ new Set();
@@ -48220,6 +48832,7 @@ var ClaudeCodeAdapter = class {
   #accountInspection = null;
   constructor(options = {}, dependencies) {
     const environment = options.environment ?? process.env;
+    this.#environment = environment;
     this.#importIndex = new ClaudeSessionImportIndex(environment);
     this.#pendingSessions = new ClaudePendingSessions(environment);
     this.#closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
@@ -48275,7 +48888,7 @@ var ClaudeCodeAdapter = class {
       readSubagentMessages: ({ cwd, sessionId, nativeSubagentId: nativeSubagentId2 }) => jkt(sessionId, nativeSubagentId2, { dir: cwd })
     };
   }
-  #readImport(operation) {
+  #readImport(operation, failureMessage = "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients") {
     if (this.#importAbort.signal.aborted) {
       return Promise.resolve({
         ok: false,
@@ -48284,11 +48897,7 @@ var ClaudeCodeAdapter = class {
     }
     const request = operation(this.#importAbort.signal).then((value) => ({ ok: true, value })).catch(() => ({
       ok: false,
-      error: {
-        code: "unavailable",
-        message: "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
-        retryable: true
-      }
+      error: { code: "unavailable", message: failureMessage, retryable: true }
     })).finally(() => this.#importRequests.delete(request));
     this.#importRequests.add(request);
     return request;
@@ -48300,7 +48909,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path12.resolve(input.cwd ?? process.cwd());
+    const cwd = path13.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -48481,7 +49090,7 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const cwd = path12.resolve(input.cwd);
+    const cwd = path13.resolve(input.cwd);
     if (input.kind === "rollbackLastTurn") {
       for (const source of this.#sessions) {
         const ready = await source.prepareRollback(input.sourceRef.nativeSessionId);
@@ -48604,7 +49213,7 @@ var ClaudeCodeAdapter = class {
 };
 
 // dist/user-shell-environment.js
-import path13 from "node:path";
+import path14 from "node:path";
 import { execFile as execFile2 } from "node:child_process";
 var ENVIRONMENT_MARKER = Buffer.from("\0CODEXHOST_USER_SHELL_ENV_V1\0");
 var ENVIRONMENT_COMMAND = "printf '\\0CODEXHOST_USER_SHELL_ENV_V1\\0'; /usr/bin/env -0";
@@ -48647,7 +49256,7 @@ async function withUserShellEnvironment(environment, dependencies) {
   if (platform === "win32" || !environment.HOME)
     return environment;
   const shell = environment.SHELL?.trim() || defaultShell(platform);
-  if (!shell || !SUPPORTED_SHELLS.has(path13.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path14.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);