@codexhost/cli-darwin-x64 0.13.3 → 0.15.0

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

@@ -777,10 +777,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path19) {
-  if (!path19)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path19.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1189,11 +1189,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path19, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path19);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -1340,16 +1340,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path19 = []) => {
+  const processError = (error53, path18 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1376,17 +1376,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path19 = []) => {
+  const processError = (error53, path18 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1418,8 +1418,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path19) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -3040,10 +3040,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
+      const field2 = shape[key]._zod;
+      if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field.values)
+        for (const v of field2.values)
           propValues[key].add(v);
       }
     }
@@ -14111,13 +14111,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path19 = ref.slice(1).split("/").filter(Boolean);
-  if (path19.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path19[0] === defsKey) {
-    const key = path19[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14662,10 +14662,19 @@ var model = external_exports.string().min(1).max(512);
 var project = external_exports.string().min(1).max(4096);
 var usageStatisticsParamsSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+  timeZone: external_exports.string().min(1).max(128).refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Unsupported usage statistics timezone").optional(),
   harness: harness.optional(),
   model: model.nullable().optional(),
   project: project.nullable().optional(),
-  /** One local date inside the range. */
+  /** One date in the query timezone inside the range. */
   date: localDate.optional()
 });
 var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -14701,7 +14710,7 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
 });
 var usageStatisticsResultSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
-  /** First local date of the range; null for all time. */
+  /** First date in the query timezone (Host local when omitted); null for all time. */
   from: localDate.nullable(),
   to: localDate,
   /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -14741,7 +14750,7 @@ var usageStatisticsResultSchema = external_exports.strictObject({
   totals: usageStatisticsTotalsSchema,
   /** Each date and Harness of the range: every filter except the day. */
   daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
   hourly: external_exports.array(external_exports.strictObject({
     weekday: external_exports.number().int().min(0).max(6),
     hour: external_exports.number().int().min(0).max(23),
@@ -14781,6 +14790,51 @@ var hostInteractionIdSchema = opaqueIdSchema.brand();
 var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
 var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+// ../../shared-contracts/dist/thread-questions.js
+var field = external_exports.discriminatedUnion("type", [
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("choice"),
+    prompt: external_exports.string(),
+    options: external_exports.array(external_exports.object({
+      value: external_exports.string().min(1),
+      label: external_exports.string(),
+      description: external_exports.string().optional()
+    })).min(1),
+    multiple: external_exports.boolean(),
+    allowOther: external_exports.boolean(),
+    optional: external_exports.boolean()
+  }),
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("text"),
+    prompt: external_exports.string(),
+    multiline: external_exports.boolean(),
+    secret: external_exports.literal(false),
+    optional: external_exports.boolean(),
+    placeholder: external_exports.string().optional(),
+    prefill: external_exports.string().optional()
+  })
+]);
+var threadQuestionSchema = external_exports.object({
+  interactionId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  title: external_exports.string().optional(),
+  questions: external_exports.array(field).min(1)
+}).refine(({ questions }) => questions.some((q) => q.type === "choice" && q.multiple), {
+  message: "Shared cards require at least one multi-select question"
+});
+var threadQuestionsListParamsSchema = external_exports.strictObject({ threadId: external_exports.string().min(1) });
+var threadQuestionsResultSchema = external_exports.object({ questions: external_exports.array(threadQuestionSchema) });
+var threadQuestionRespondParamsSchema = external_exports.strictObject({
+  threadId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  interactionId: external_exports.string().min(1),
+  answers: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())),
+  cancelled: external_exports.boolean().default(false)
+});
+var threadQuestionRespondResultSchema = external_exports.object({ accepted: external_exports.literal(true) });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -14801,6 +14855,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
   "codexhost/harness/installation",
+  "codexhost/harness/installation/start",
+  "codexhost/harness/installation/status",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
   "codexhost/harness/web-ui/open",
@@ -14876,7 +14932,18 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text2) => text2.length <= maximum));
+var composerIndicatorsSchema = external_exports.array(external_exports.object({
+  kind: external_exports.literal("countdown"),
+  id: external_exports.string().min(1).max(64),
+  expiresAtUnix: nonNegativeSafeIntegerSchema,
+  label: indicatorTextSchema(256).optional(),
+  tooltip: indicatorTextSchema(1024).optional()
+}).strict()).max(2).refine((entries) => new Set(entries.map(({ id: id2 }) => id2)).size === entries.length, {
+  message: "Composer indicator IDs must be unique"
+});
 var threadUsageSnapshotSchema = external_exports.object({
+  composerIndicators: composerIndicatorsSchema.optional(),
   inputTokens: nonNegativeSafeIntegerSchema.optional(),
   cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15284,7 +15351,9 @@ var harnessSessionCapabilitiesSchema = external_exports.object({
   }).strict().optional(),
   autonomousTurns: external_exports.object({
     observe: external_exports.boolean()
-  }).strict().optional()
+  }).strict().optional(),
+  /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+  steer: external_exports.boolean().optional()
 }).strict();
 var harnessConfigurationStateSchema = external_exports.object({
   effectiveModel: harnessModelRefSchema.optional(),
@@ -15331,7 +15400,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -15414,6 +15485,15 @@ var threadOwnershipListResultSchema = external_exports.object({
     seen.add(thread.threadId);
   }
 });
+var threadSteeringInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  /** The text about to be steered; a Harness command always stops and restarts. */
+  text: external_exports.string().optional()
+}).strict();
+var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+var threadSteeringInspectResultSchema = external_exports.object({
+  delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+}).strict();
 
 // ../../shared-contracts/dist/harness-plugins.js
 var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -15515,6 +15595,10 @@ var harnessInstallationStateSchema = external_exports.object({
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
+  /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+  versionKind: external_exports.enum(["cli", "application"]).optional(),
+  /** Official download opened by the user; does not imply an automatic installation. */
+  manualUpdateUrl: external_exports.url().max(2048).refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Manual updates require a credential-free HTTPS URL").optional(),
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
@@ -15522,6 +15606,20 @@ var harnessInstallationStateSchema = external_exports.object({
   notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
+var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("succeeded"),
+    result: harnessInstallationStateSchema
+  }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("failed"),
+    error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+  }).strict()
+]);
 
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -16034,6 +16132,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -16056,26 +16155,27 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
-  for (const field of [
+  const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
+  for (const field2 of [
     "totalCredits",
     "contextUsagePercent",
     "apiOutputTokensPerSecond"
   ]) {
-    const candidate = value[field];
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+      throw new Error(`Harness Usage '${field2}' must be a finite non-negative number`);
     }
   }
-  for (const field of tokenFields) {
-    const candidate = value[field];
+  for (const field2 of tokenFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
-  for (const field of safeIntegerFields) {
-    const candidate = value[field];
+  for (const field2 of safeIntegerFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
@@ -16084,10 +16184,10 @@ function parseHostUsage(value) {
   if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
-  for (const field of percentFields) {
-    const candidate = value[field];
+  for (const field2 of percentFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+      throw new Error(`Harness Usage '${field2}' must be between 0 and 100`);
     }
   }
   if (value.sessionCacheUsage !== void 0) {
@@ -16126,9 +16226,9 @@ function parseHostUsage(value) {
     if (value.costSource !== "publicPrice") {
       throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
     }
-    return { ...value, unpricedModels: [...models] };
+    return { ...value, ...indicators, unpricedModels: [...models] };
   }
-  return { ...value };
+  return { ...value, ...indicators };
 }
 var requestTokenFields = [
   "inputTokens",
@@ -16158,19 +16258,19 @@ function parseHostUsageRequest(value) {
   if (typeof value.requestId !== "string" || value.requestId.length === 0) {
     throw new Error("Harness Usage request 'requestId' must be a non-empty string");
   }
-  for (const field of ["model", "provider"]) {
-    const candidate = value[field];
+  for (const field2 of ["model", "provider"]) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "string" || candidate.length === 0)) {
-      throw new Error(`Harness Usage request '${field}' must be a non-empty string`);
+      throw new Error(`Harness Usage request '${field2}' must be a non-empty string`);
     }
   }
   if (value.historical !== void 0 && typeof value.historical !== "boolean") {
     throw new Error("Harness Usage request 'historical' must be a boolean");
   }
-  for (const field of requestTokenFields) {
-    const candidate = value[field];
+  for (const field2 of requestTokenFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage request '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage request '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value.inputTokens === void 0 || value.outputTokens === void 0) {
@@ -16318,6 +16418,7 @@ var HARNESS_BROKER_PROTOCOL_VERSION = 1;
 var HARNESS_BROKER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var HARNESS_BROKER_MAX_PENDING_REQUESTS = 32;
 var HARNESS_BROKER_REQUEST_TIMEOUT_MS = 15e3;
+var HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE = 100;
 var HARNESS_BROKER_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
 var HARNESS_BROKER_RETIRING_ERROR_CODE = "brokerRetiring";
 var harnessBrokerMethodSchema = external_exports.enum([
@@ -16325,8 +16426,11 @@ var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspectAccount",
   "adapter.credits",
   "adapter.open",
+  "adapter.sessionImport.list",
+  "adapter.sessionImport.resolve",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
+  "session.readCapabilities",
   "session.refreshUsage",
   "session.execute",
   "session.commands.list",
@@ -16426,30 +16530,6 @@ function consumeBrokerFrames(socket, onFrame, onError) {
   });
 }
 
-// ../../harness-broker/dist/paths.js
-import os from "node:os";
-import path from "node:path";
-var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
-var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
-function defaultHarnessBrokerDirectory(environment = process.env) {
-  const home = environment.HOME || os.homedir();
-  return path.join(home, ".codexhost", "harness-broker");
-}
-function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
-  harnessPluginIdSchema.parse(harnessId);
-  if (harnessId !== "claude-code")
-    return path.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
-}
-function harnessBrokerLaunchAgentLabel(harnessId = "claude-code") {
-  harnessPluginIdSchema.parse(harnessId);
-  return harnessId === "claude-code" ? "ai.bytepioneer.codexhost.native-harness-broker" : `ai.bytepioneer.codexhost.${harnessId}-broker`;
-}
-function harnessBrokerLaunchAgentPlistPath(environment = process.env, harnessId = "claude-code") {
-  const home = environment.HOME || os.homedir();
-  return path.join(home, "Library", "LaunchAgents", `${harnessBrokerLaunchAgentLabel(harnessId)}.plist`);
-}
-
 // ../../harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
 var brokerEnvironmentSchema = external_exports.object({
@@ -16500,13 +16580,42 @@ var brokerOpenInputSchema = external_exports.discriminatedUnion("kind", [
   forkSchema,
   rollbackSchema
 ]);
-var brokerInspectInputSchema = external_exports.object({ cwd: cwdSchema.optional(), refresh: external_exports.boolean().optional() }).strict();
+var brokerInspectInputSchema = external_exports.object({
+  cwd: cwdSchema.optional(),
+  refresh: external_exports.boolean().optional(),
+  purpose: external_exports.literal("availability").optional()
+}).strict();
+var brokerSessionImportListParamsSchema = external_exports.object({
+  offset: external_exports.number().int().nonnegative().safe(),
+  limit: external_exports.number().int().min(1).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE)
+}).strict();
+var brokerSessionImportResolveParamsSchema = external_exports.object({ nativeSessionId: harnessSessionImportIdSchema }).strict();
+var brokerSessionImportPageSchema = external_exports.object({
+  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE),
+  total: external_exports.number().int().nonnegative().safe()
+}).strict();
+var brokerSessionImportSourceSchema = external_exports.object({
+  candidate: harnessSessionImportCandidateSchema,
+  nativeRef: nativeSessionRefSchema
+}).strict().superRefine((source, context) => {
+  if (source.nativeRef.nativeSessionId !== source.candidate.nativeSessionId) {
+    context.addIssue({
+      code: "custom",
+      message: "Session import source identity does not match"
+    });
+  }
+});
 var textInputSchema = external_exports.object({ type: external_exports.literal("text"), text: external_exports.string().max(4e6) }).strict();
 var turnStartSchema = external_exports.object({
   type: external_exports.literal("turn.start"),
   turnId: hostTurnIdSchema,
   input: external_exports.array(textInputSchema)
 }).strict();
+var turnSteerSchema = external_exports.object({
+  type: external_exports.literal("turn.steer"),
+  turnId: hostTurnIdSchema,
+  input: external_exports.array(textInputSchema)
+}).strict();
 var turnCancelSchema = external_exports.object({ type: external_exports.literal("turn.cancel"), turnId: hostTurnIdSchema }).strict();
 var interactionResponseSchema = external_exports.union([
   external_exports.object({
@@ -16532,6 +16641,7 @@ var permissionSelectSchema = external_exports.object({
 }).strict();
 var brokerHostCommandSchema = external_exports.discriminatedUnion("type", [
   turnStartSchema,
+  turnSteerSchema,
   turnCancelSchema,
   interactionRespondSchema,
   modelSelectSchema,
@@ -16665,6 +16775,107 @@ var harnessOutputSchema = external_exports.custom((value) => {
   return false;
 });
 
+// ../../harness-broker/dist/session-import-client.js
+function createBrokerSessionImportCapability(input) {
+  let listing = null;
+  const closed = () => ({
+    ok: false,
+    error: { code: "invalidState", message: "Harness broker adapter is closed", retryable: false }
+  });
+  const invalid = () => ({
+    ok: false,
+    error: {
+      code: "protocolError",
+      message: "Harness broker returned invalid Session import metadata",
+      retryable: false
+    }
+  });
+  const list = async () => {
+    try {
+      const candidates = [];
+      const identities = /* @__PURE__ */ new Set();
+      let total;
+      for (; ; ) {
+        if (input.isClosed())
+          return closed();
+        const result = await input.request("adapter.sessionImport.list", {
+          offset: candidates.length,
+          limit: HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE
+        });
+        if (input.isClosed())
+          return closed();
+        if (!result.ok)
+          return result;
+        const page = brokerSessionImportPageSchema.safeParse(result.value);
+        if (!page.success || total !== void 0 && total !== page.data.total || page.data.total < candidates.length + page.data.candidates.length || page.data.candidates.length === 0 && candidates.length < page.data.total)
+          return invalid();
+        total = page.data.total;
+        for (const candidate of page.data.candidates) {
+          if (identities.has(candidate.nativeSessionId))
+            return invalid();
+          identities.add(candidate.nativeSessionId);
+          candidates.push(candidate);
+        }
+        if (candidates.length === total)
+          return { ok: true, value: candidates };
+      }
+    } catch (error52) {
+      return { ok: false, error: input.error(error52) };
+    }
+  };
+  return {
+    listCandidates() {
+      if (input.isClosed())
+        return Promise.resolve(closed());
+      listing ??= list().finally(() => {
+        listing = null;
+      });
+      return listing;
+    },
+    async resolveCandidate(nativeSessionId) {
+      if (input.isClosed())
+        return closed();
+      try {
+        const result = await input.request("adapter.sessionImport.resolve", { nativeSessionId });
+        if (input.isClosed())
+          return closed();
+        if (!result.ok)
+          return result;
+        const source = brokerSessionImportSourceSchema.safeParse(result.value);
+        if (!source.success || source.data.nativeRef.harnessId !== input.harnessId || source.data.candidate.nativeSessionId !== nativeSessionId)
+          return invalid();
+        return { ok: true, value: source.data };
+      } catch (error52) {
+        return { ok: false, error: input.error(error52) };
+      }
+    }
+  };
+}
+
+// ../../harness-broker/dist/paths.js
+import os from "node:os";
+import path from "node:path";
+var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
+var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
+function defaultHarnessBrokerDirectory(environment = process.env) {
+  const home = environment.HOME || os.homedir();
+  return path.join(home, ".codexhost", "harness-broker");
+}
+function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  if (harnessId !== "claude-code")
+    return path.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+}
+function harnessBrokerLaunchAgentLabel(harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  return harnessId === "claude-code" ? "ai.bytepioneer.codexhost.native-harness-broker" : `ai.bytepioneer.codexhost.${harnessId}-broker`;
+}
+function harnessBrokerLaunchAgentPlistPath(environment = process.env, harnessId = "claude-code") {
+  const home = environment.HOME || os.homedir();
+  return path.join(home, "Library", "LaunchAgents", `${harnessBrokerLaunchAgentLabel(harnessId)}.plist`);
+}
+
 // ../../harness-broker/dist/client.js
 function unavailable(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
@@ -16724,6 +16935,7 @@ function parseSessionMetadata(value) {
     sessionId: candidate.sessionId,
     sessionGeneration: candidate.sessionGeneration,
     capabilities: harnessSessionCapabilitiesSchema.parse(candidate.capabilities),
+    readCapabilities: candidate.readCapabilities === true,
     initialState: state,
     initialUsage: candidate.initialUsage === null ? null : parseHostUsage(candidate.initialUsage),
     commands: candidate.commands === true
@@ -17075,6 +17287,11 @@ var BrokeredHarnessSession = class {
       event: { type: "session.faulted", error: unavailable(error52.message) }
     });
   }
+  async readCapabilities() {
+    if (!this.#metadata.readCapabilities)
+      return { ...this.capabilities, steer: false };
+    return harnessSessionCapabilitiesSchema.parse(await this.#request("session.readCapabilities", {}));
+  }
   async refreshUsage() {
     await this.#request("session.refreshUsage", {});
   }
@@ -17106,6 +17323,8 @@ var BrokeredHarnessSession = class {
     try {
       return parseHarnessResult(await this.#request("session.execute", { command }));
     } catch (error52) {
+      if (command.type === "turn.steer")
+        throw error52;
       return {
         ok: false,
         error: unavailable(error52 instanceof Error ? error52.message : String(error52))
@@ -17193,6 +17412,7 @@ var BrokeredHarnessAdapter = class {
   commandCatalog;
   liveCommandCatalog;
   harnessId;
+  sessionImport;
   credits;
   refreshCredits;
   #descriptorPath;
@@ -17215,6 +17435,14 @@ var BrokeredHarnessAdapter = class {
   };
   constructor(input = {}) {
     this.harnessId = harnessPluginIdSchema.parse(input.harnessId ?? "claude-code");
+    if (input.sessionImport) {
+      this.sessionImport = createBrokerSessionImportCapability({
+        harnessId: this.harnessId,
+        request: async (method, params) => parseHarnessResult(await this.#request(method, params, method === "adapter.sessionImport.resolve")),
+        isClosed: () => this.#closed,
+        error: (error52) => this.#error(error52)
+      });
+    }
     if (input.accountCredits !== false) {
       this.credits = () => this.#credits;
       this.refreshCredits = () => this.#refreshAccountCredits();
@@ -17492,10 +17720,13 @@ function usageSessionTitle(value) {
     return void 0;
   if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
     return normalized;
-  const characters = [...normalized];
-  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
-    return normalized;
-  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+  let title = "";
+  for (const character of normalized) {
+    if (title.length + character.length >= MAX_SESSION_TITLE_LENGTH)
+      break;
+    title += character;
+  }
+  return `${title.trimEnd()}…`;
 }
 function sessionIdOk(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
@@ -17648,9 +17879,34 @@ function createClaudeUsageStatistics(environment) {
   });
 }
 
+// dist/claude-prompt-cache.js
+function lastClaudeAssistantResponseUnix(messages) {
+  let latest;
+  for (const entry of messages) {
+    if (typeof entry !== "object" || entry === null || !("type" in entry) || entry.type !== "assistant" || "isSidechain" in entry && entry.isSidechain === true || "parent_tool_use_id" in entry && entry.parent_tool_use_id != null || !("timestamp" in entry) || typeof entry.timestamp !== "string")
+      continue;
+    const time3 = Math.floor(Date.parse(entry.timestamp) / 1e3);
+    if (Number.isSafeInteger(time3) && time3 >= 0)
+      latest = Math.max(latest ?? 0, time3);
+  }
+  return latest;
+}
+function claudePromptCacheIndicators(accountCreditsSupported, lastResponseAtUnix) {
+  if (!accountCreditsSupported || lastResponseAtUnix === void 0)
+    return [];
+  return [
+    {
+      kind: "countdown",
+      id: "prompt-cache",
+      expiresAtUnix: lastResponseAtUnix + 3600,
+      label: { en: "Prompt cache", "zh-CN": "提示词缓存" }
+    }
+  ];
+}
+
 // dist/claude-code-adapter.js
 import { randomUUID as randomUUID5 } from "node:crypto";
-import path16 from "node:path";
+import path15 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as jre } from "node:module";
@@ -54290,7 +54546,6 @@ var ClaudePendingSessions = class {
 };
 
 // dist/claude-fork.js
-import path12 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // dist/file-change.js
@@ -54432,6 +54687,17 @@ function targetedSubagentId(argumentsValue) {
     return void 0;
   return boundedString(argumentsValue.to ?? argumentsValue.recipient ?? argumentsValue.agentId, SUBAGENT_DESCRIPTION_LIMIT);
 }
+function claudeSendMessageFailed(nativeResult, outputText) {
+  if (isRecord7(nativeResult) && typeof nativeResult.success === "boolean") {
+    return nativeResult.success === false;
+  }
+  try {
+    const parsed = JSON.parse(outputText ?? "");
+    return isRecord7(parsed) && parsed.success === false;
+  } catch {
+    return false;
+  }
+}
 function includesAuthenticationFailure(errors) {
   return errors.some((error52) => AUTHENTICATION_ERRORS.has(error52));
 }
@@ -54448,11 +54714,20 @@ function parseResultModelUsage(value) {
   if (!isRecord7(value))
     return void 0;
   const usage = [];
-  for (const entry of Object.values(value)) {
+  for (const [model2, entry] of Object.entries(value)) {
     if (!isRecord7(entry) || !safeNonNegativeInteger(entry.inputTokens) || !safeNonNegativeInteger(entry.outputTokens)) {
       return void 0;
     }
-    usage.push({ inputTokens: entry.inputTokens, outputTokens: entry.outputTokens });
+    const cacheRead = safeNonNegativeInteger(entry.cacheReadInputTokens) ? entry.cacheReadInputTokens : 0;
+    const cacheWrite = safeNonNegativeInteger(entry.cacheCreationInputTokens) ? entry.cacheCreationInputTokens : 0;
+    const promptTokens = entry.inputTokens + cacheRead + cacheWrite;
+    usage.push({
+      model: model2,
+      inputTokens: entry.inputTokens,
+      outputTokens: entry.outputTokens,
+      ...Number.isSafeInteger(promptTokens) ? { promptTokens } : {},
+      ...safeNonNegativeInteger(entry.contextWindow) && entry.contextWindow > 0 ? { contextWindowTokens: entry.contextWindow } : {}
+    });
   }
   return usage;
 }
@@ -54803,6 +55078,7 @@ var ClaudeNativeTurnAccumulator = class {
     events.push({
       type: "message.completed",
       messageId,
+      localCommand: true,
       ...checkpointId ? { checkpointId } : {}
     });
   }
@@ -55152,7 +55428,7 @@ var ClaudeNativeTurnAccumulator = class {
         events.push({
           type: "subagent.completed",
           callId,
-          isError,
+          isError: isError || tool.name === "SendMessage" && claudeSendMessageFailed(nativeResult, outputText),
           ...subagentContinuesInBackground(nativeResult, outputText) ? { continuesInBackground: true } : {},
           ...agentId ? { nativeSubagentId: agentId } : {},
           ...resultSummary ? { resultSummary } : {}
@@ -55283,6 +55559,10 @@ function conversationMessages(values, sessionId) {
   const messages = [];
   const ids = /* @__PURE__ */ new Set();
   let promptId = null;
+  const occupancy = new ClaudeBackgroundOccupancy();
+  let accumulator = new ClaudeNativeTurnAccumulator();
+  const sends = /* @__PURE__ */ new Map();
+  let pendingNotification = false;
   for (const value of values) {
     if (!isRecord8(value))
       throw new Error("Claude history contains a malformed message");
@@ -55301,8 +55581,48 @@ function conversationMessages(values, sessionId) {
       message: value.message,
       nested: typeof value.parent_tool_use_id === "string" && value.parent_tool_use_id.length > 0,
       interrupted,
+      startsTurn: false,
       syntheticUser: value.type === "user" && (interrupted || value.isSynthetic === true || value.isMeta === true || isTaskNotificationOrigin(value) || value.toolUseResult !== void 0 && value.toolUseResult !== null)
     };
+    const notification = message.type === "user" && !message.nested && (isTaskNotificationOrigin(value) || textParts(message.message.content).some(isTaskNotificationRecord));
+    message.startsTurn = isHumanUser(message) || notification && !occupancy.unsettled && !pendingNotification;
+    if (message.startsTurn) {
+      occupancy.clear();
+      sends.clear();
+      accumulator = new ClaudeNativeTurnAccumulator();
+    }
+    for (const event of accumulator.consume(value).events) {
+      if (event.type === "subagent.started") {
+        if (event.operation === "send") {
+          sends.set(event.callId, event.nativeSubagentId);
+        } else if (event.background)
+          occupancy.occupySpawn(event.callId, event.nativeSubagentId);
+      } else if (event.type === "subagent.completed") {
+        if (sends.has(event.callId)) {
+          const agentId = event.nativeSubagentId ?? sends.get(event.callId);
+          if (!event.isError && agentId)
+            occupancy.occupyAgent(agentId);
+          sends.delete(event.callId);
+        } else if (!event.isError && event.continuesInBackground) {
+          occupancy.occupySpawn(event.callId, event.nativeSubagentId);
+        } else
+          occupancy.release(event.callId, event.nativeSubagentId);
+      } else if (event.type === "workflow.launched" && event.background && !event.isError) {
+        occupancy.occupySpawn(event.callId, event.taskId);
+      } else if (event.type === "subagent.settled") {
+        occupancy.notify(event.callId, event.nativeSubagentId);
+      }
+    }
+    if (notification)
+      pendingNotification = true;
+    if (message.type === "assistant" && !message.nested) {
+      pendingNotification = false;
+      if (["end_turn", "stop_sequence", "max_tokens"].includes(String(message.message.stop_reason))) {
+        occupancy.releaseContinuations();
+      }
+    }
+    if (interrupted)
+      occupancy.clear();
     messages.push(message);
     if (isHumanUser(message)) {
       promptId = typeof value.promptId === "string" && value.promptId.length > 0 ? value.promptId : null;
@@ -55359,17 +55679,17 @@ function mapClaudeSnapshot(values, sessionId) {
   const turns = [];
   for (let index = 0; index < messages.length; ) {
     const user = messages[index];
-    if (!user || !isHumanUser(user)) {
+    if (!user || !user.startsTurn) {
       index += 1;
       continue;
     }
     let end = index + 1;
-    while (end < messages.length && !isHumanUser(messages[end]))
+    while (end < messages.length && !messages[end]?.startsTurn)
       end += 1;
     const turnMessages = messages.slice(index, end);
     const outcome = turnOutcome(turnMessages);
     const results = toolResultBlocks(turnMessages);
-    const checkpointMessage = turnMessages.findLast(({ type, interrupted }) => type === "assistant" || interrupted);
+    const checkpointMessage = turnMessages.findLast(({ type, interrupted, nested }) => !nested && (type === "assistant" || interrupted));
     let agentMessageOrdinal = 0;
     let reasoningOrdinal = 0;
     let toolOrdinal = 0;
@@ -55463,7 +55783,7 @@ function mapClaudeSnapshot(values, sessionId) {
           if (!result)
             continue;
           const output = toolResultOutput(result);
-          const failed = result.is_error === true;
+          const failed = result.is_error === true || block.name === "SendMessage" && claudeSendMessageFailed(void 0, output);
           const toolOutcome = failed ? {
             status: "failed",
             error: {
@@ -55758,12 +56078,6 @@ async function forkClaudeSession(input) {
       error: error51("protocolError", "Claude Code Session working directory is unavailable", false)
     };
   }
-  if (path12.resolve(sourceInfo.cwd) !== input.cwd) {
-    return {
-      ok: false,
-      error: error51("unsupported", "Claude Code cannot Fork across working directories", false)
-    };
-  }
   const source = await readSnapshot(input.dependencies, input.cwd, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
@@ -55863,13 +56177,13 @@ import { readFile as readFile6, rename as rename4, rm as rm5, stat as stat5, wri
 
 // dist/claude-transcript.js
 import os6 from "node:os";
-import path13 from "node:path";
+import path12 from "node:path";
 import { readFile as readFile5, readdir as readdir3, 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 ? path13.resolve(environment.CLAUDE_CONFIG_DIR) : path13.join(os6.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path12.resolve(environment.CLAUDE_CONFIG_DIR) : path12.join(os6.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
@@ -55879,9 +56193,9 @@ async function existingFile(file2) {
   }
 }
 async function findClaudeTranscript(input) {
-  const projectsDirectory = path13.join(configDirectory(input.environment), "projects");
+  const projectsDirectory = path12.join(configDirectory(input.environment), "projects");
   const name = `${input.sessionId}.jsonl`;
-  const expected = path13.join(projectsDirectory, projectDirectoryName(input.cwd), name);
+  const expected = path12.join(projectsDirectory, projectDirectoryName(input.cwd), name);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -55891,7 +56205,7 @@ async function findClaudeTranscript(input) {
     return null;
   }
   for (const project2 of projects) {
-    const candidate = path13.join(projectsDirectory, project2, name);
+    const candidate = path12.join(projectsDirectory, project2, name);
     if (await existingFile(candidate))
       return candidate;
   }
@@ -56001,7 +56315,7 @@ async function remapForkedSessionReferences(input) {
 import { Buffer as Buffer2 } from "node:buffer";
 import { readFile as readFile7 } from "node:fs/promises";
 import os7 from "node:os";
-import path14 from "node:path";
+import path13 from "node:path";
 
 // dist/thinking-options.js
 var option = (id2, label) => ({
@@ -56094,7 +56408,7 @@ function decodeClaudeModelRef(ref) {
   return value === "default" ? void 0 : value;
 }
 function resolveClaudeConfigDirectory(environment = process.env) {
-  return path14.resolve(environment.CLAUDE_CONFIG_DIR ?? path14.join(os7.homedir(), ".claude"));
+  return path13.resolve(environment.CLAUDE_CONFIG_DIR ?? path13.join(os7.homedir(), ".claude"));
 }
 function parseModelPickerOptions(value) {
   if (!Array.isArray(value))
@@ -56136,7 +56450,7 @@ function parseClaudeModelPickerSettings(value) {
   };
 }
 async function readClaudeUserModelPicker(environment = process.env) {
-  const settingsPath = path14.join(resolveClaudeConfigDirectory(environment), "settings.json");
+  const settingsPath = path13.join(resolveClaudeConfigDirectory(environment), "settings.json");
   let raw;
   try {
     raw = await readFile7(settingsPath, "utf8");
@@ -56482,7 +56796,7 @@ function projectClaudeAccountUsage(usage, account) {
 
 // dist/process-fence.js
 import { execFile as execFile3 } from "node:child_process";
-import path15 from "node:path";
+import path14 from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify } from "node:util";
 var executeFile = promisify(execFile3);
@@ -56506,9 +56820,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 || !path15.win32.isAbsolute(root))
+    if (!root || !path14.win32.isAbsolute(root))
       throw new Error("Windows SystemRoot is unavailable");
-    await executeFile(path15.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
+    await executeFile(path14.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
       timeout: timeoutMs,
       windowsHide: true
     });
@@ -56533,12 +56847,21 @@ async function closeClaudeProcessGroup(child, timeoutMs) {
   throw new Error("Claude SDK process group did not exit");
 }
 
+// dist/transport.js
+var ClaudeSteerMissedTurnError = class extends Error {
+  constructor() {
+    super("Claude Code steer missed the active Turn");
+    this.name = "ClaudeSteerMissedTurnError";
+  }
+};
+
 // dist/sdk-transport.js
 var CLIENT_APP = "codexhost-claude-code-adapter/0.0.0";
 var SESSION_ENTRYPOINT = "codexhost-sdk";
 var APPROVAL_TITLE_MAX_LENGTH = 120;
 var APPROVAL_DESCRIPTION_MAX_LENGTH = 500;
 var DEFAULT_ABORT_TIMEOUT_MS = 2e3;
+var DEFAULT_STEER_QUEUED_TIMEOUT_MS = 5e3;
 var WORKFLOW_AGENT_LABEL_LIMIT = 1e3;
 var INTERRUPT_TIMEOUT_MESSAGE = "Claude SDK interrupt timed out";
 var PushableInput = class {
@@ -56794,6 +57117,13 @@ var ClaudeSdkTransport = class {
   #queryFactory;
   #thinkingOptionId;
   #active = null;
+  #steerQueuedTimeoutMs;
+  #nativeSteer = false;
+  /** Root tool calls of the requested Turn that have started and not yet returned a result. */
+  #rootToolCalls = /* @__PURE__ */ new Set();
+  #pendingSteers = /* @__PURE__ */ new Map();
+  /** Written steers Claude has not yet drained into a native turn, by message ID. */
+  #steerTakeovers = /* @__PURE__ */ new Map();
   #autonomous = null;
   #autonomousTurnHandler = null;
   #idleHandler = null;
@@ -56817,6 +57147,7 @@ var ClaudeSdkTransport = class {
     this.sessionId = options.sessionId;
     this.#cwd = options.cwd;
     this.#abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
+    this.#steerQueuedTimeoutMs = options.steerQueuedTimeoutMs ?? DEFAULT_STEER_QUEUED_TIMEOUT_MS;
     this.#closeTimeoutMs = options.closeTimeoutMs;
     this.#command = options.command;
     this.#environment = options.environment ?? process.env;
@@ -56871,7 +57202,8 @@ var ClaudeSdkTransport = class {
         thinking: thinking.enabled ? { type: "adaptive", display: "summarized" } : { type: "disabled" },
         ...thinking.effort ? { effort: thinking.effort } : {},
         pathToClaudeCodeExecutable: executable,
-        settingSources: ["user"],
+        // Omitted settingSources loads user, project and local settings like the
+        // Claude Code CLI, so project CLAUDE.md and .claude/skills apply.
         permissionMode: this.#permissionMode,
         ...this.#allowDangerouslySkipPermissions ? { allowDangerouslySkipPermissions: true } : {},
         canUseTool: (toolName, input, options) => this.#canUseTool(toolName, input, options),
@@ -56908,6 +57240,47 @@ var ClaudeSdkTransport = class {
       return null;
     return { commands: this.#slashCommands, skillNames: this.#skillNames };
   }
+  supportsNativeSteer() {
+    return this.#nativeSteer;
+  }
+  /**
+   * `priority: "next"` joins after the current tool call, and a tool result is always followed by
+   * another model request. So a steer written while a root tool call runs folds into this Turn;
+   * one written while Claude streams its final text may instead run as the next Turn.
+   *
+   * A held Turn's continuation steers as well: while its idle stream is live, the pushed input
+   * runs as that Turn's next Segment, and the background work the Turn waits on keeps running.
+   */
+  canSteerActiveTurn() {
+    if (!this.#nativeSteer)
+      return false;
+    if (this.#active !== null)
+      return this.#rootToolCalls.size > 0;
+    return this.#idleLive && this.#idleHandler !== null;
+  }
+  #observeRootToolCalls(message) {
+    if (!isRecord11(message) || message.parent_tool_use_id != null)
+      return;
+    if (message.type !== "assistant" && message.type !== "user")
+      return;
+    const body = message.message;
+    if (!isRecord11(body) || !Array.isArray(body.content))
+      return;
+    for (const block of body.content) {
+      if (!isRecord11(block))
+        continue;
+      if (message.type === "assistant" && block.type === "tool_use" && typeof block.id === "string") {
+        this.#rootToolCalls.add(block.id);
+      } else if (message.type === "user" && block.type === "tool_result" && typeof block.tool_use_id === "string") {
+        this.#rootToolCalls.delete(block.tool_use_id);
+      }
+    }
+  }
+  #observeNativeCapabilities(message) {
+    if (!isRecord11(message) || message.type !== "system" || message.subtype !== "init")
+      return;
+    this.#nativeSteer = Array.isArray(message.capabilities) && message.capabilities.includes("msg_lifecycle_v1");
+  }
   #observeSlashCommands(message) {
     if (!isRecord11(message) || message.type !== "system")
       return;
@@ -57030,6 +57403,7 @@ var ClaudeSdkTransport = class {
     const unclaimed = this.#autonomous?.events ?? [];
     this.#autonomous = null;
     const promise2 = new Promise((resolve5, reject) => {
+      this.#rootToolCalls.clear();
       this.#active = {
         accumulator: new ClaudeNativeTurnAccumulator(this.#provider ? { provider: this.#provider } : {}),
         onEvent,
@@ -57049,6 +57423,63 @@ var ClaudeSdkTransport = class {
     });
     return promise2;
   }
+  /**
+   * Claude accepts the input with `queued`; Claude Code 2.1.280 then emits `started` after the
+   * current tool call, when `priority: "next"` joins the running Turn. Waiting for `started` would
+   * hold the caller for a whole tool call.
+   *
+   * Once written, the input cannot be recalled: Claude delivers it in this Turn or runs it next.
+   * The Turn ending first therefore does not reject it, and a missing `queued` receipt resolves
+   * after a bounded wait so callers that serialize requests are never held indefinitely.
+   */
+  steer(text2, messageId, onTakeover) {
+    if (this.#closePromise || !this.#started || !this.#query || !this.canSteerActiveTurn()) {
+      return Promise.reject(new ClaudeSteerMissedTurnError());
+    }
+    const promise2 = new Promise((resolve5, reject) => {
+      this.#pendingSteers.set(messageId, { resolve: resolve5, reject, timer: void 0 });
+    });
+    try {
+      this.#input.push({
+        type: "user",
+        message: { role: "user", content: text2 },
+        parent_tool_use_id: null,
+        session_id: this.sessionId,
+        uuid: messageId,
+        origin: { kind: "human" },
+        priority: "next"
+      });
+    } catch {
+      this.#pendingSteers.delete(messageId);
+      return Promise.reject(new ClaudeSteerMissedTurnError());
+    }
+    if (onTakeover)
+      this.#steerTakeovers.set(messageId, onTakeover);
+    const pending = this.#pendingSteers.get(messageId);
+    if (pending) {
+      pending.timer = setTimeout(() => {
+        this.#acceptSteer(messageId);
+        this.#takeOverSteer(messageId, false);
+      }, this.#steerQueuedTimeoutMs);
+      pending.timer.unref?.();
+    }
+    return promise2;
+  }
+  #acceptSteer(messageId) {
+    const pending = this.#pendingSteers.get(messageId);
+    if (!pending)
+      return;
+    this.#pendingSteers.delete(messageId);
+    clearTimeout(pending.timer);
+    pending.resolve();
+  }
+  #takeOverSteer(messageId, started) {
+    const onTakeover = this.#steerTakeovers.get(messageId);
+    if (!onTakeover)
+      return;
+    this.#steerTakeovers.delete(messageId);
+    onTakeover(started);
+  }
   respondToInteraction(response) {
     const pending = this.#interactions.get(response.requestId);
     if (!pending) {
@@ -57220,6 +57651,7 @@ var ClaudeSdkTransport = class {
     }
   }
   async #close() {
+    this.#rejectPendingSteers();
     const failures = [];
     this.#closeInteractions("all", "cancelled");
     try {
@@ -57273,6 +57705,7 @@ var ClaudeSdkTransport = class {
     }
     this.#query = null;
     const active = this.#active;
+    this.#rootToolCalls.clear();
     this.#active = null;
     this.#autonomous = null;
     this.#idleAccumulator = null;
@@ -57327,6 +57760,37 @@ var ClaudeSdkTransport = class {
         await delay(10);
     }
   }
+  #rejectPendingSteers() {
+    for (const messageId of [...this.#steerTakeovers.keys()]) {
+      this.#takeOverSteer(messageId, false);
+    }
+    const pending = [...this.#pendingSteers.values()];
+    this.#pendingSteers.clear();
+    const error52 = new Error("Claude Code steer receipt was lost after input was written");
+    for (const entry of pending) {
+      clearTimeout(entry.timer);
+      entry.reject(error52);
+    }
+  }
+  /**
+   * `queued` is Claude's acceptance of this message into the running Session. `started` is its
+   * drain into a native turn, folded into the running one or run as the next; a terminal state
+   * without `started` means no native turn takes it over.
+   */
+  #observeSteer(message) {
+    if (this.#pendingSteers.size === 0 && this.#steerTakeovers.size === 0 || !isRecord11(message) || message.type !== "command_lifecycle") {
+      return;
+    }
+    if (typeof message.command_uuid !== "string" || message.command_uuid.length === 0)
+      return;
+    if (message.state === "queued") {
+      this.#acceptSteer(message.command_uuid);
+      return;
+    }
+    if (["started", "completed", "cancelled", "discarded", "refused"].includes(String(message.state))) {
+      this.#takeOverSteer(message.command_uuid, message.state === "started");
+    }
+  }
   #observeBackgroundTasks(message) {
     if (!isRecord11(message) || message.type !== "system")
       return;
@@ -57367,6 +57831,7 @@ var ClaudeSdkTransport = class {
         this.#observeBackgroundTasks(message);
         this.#observeWorkflowAgents(message);
         this.#observeSlashCommands(message);
+        this.#observeNativeCapabilities(message);
         const permissionMode = permissionModeFromMessage(message);
         if (permissionMode && permissionMode !== this.#permissionMode) {
           this.#permissionMode = permissionMode;
@@ -57375,13 +57840,16 @@ var ClaudeSdkTransport = class {
         const planLimit = parseClaudePlanLimitEvent(message);
         if (planLimit)
           this.#onPlanLimit(planLimit);
+        this.#observeSteer(message);
         const active = this.#active;
         if (active) {
+          this.#observeRootToolCalls(message);
           const interpreted2 = active.accumulator.consume(message);
           for (const event of interpreted2.events)
             active.onEvent(event);
           if (interpreted2.terminal) {
             this.#closeInteractions("root", "superseded");
+            this.#rootToolCalls.clear();
             this.#active = null;
             active.resolve(interpreted2.terminal);
           }
@@ -57434,11 +57902,13 @@ var ClaudeSdkTransport = class {
         throw new Error("Claude SDK Query ended unexpectedly");
     } catch (error52) {
       const active = this.#active;
+      if (!this.#closePromise)
+        this.#onFault(error52);
       this.#closeInteractions("all", "cancelled");
+      this.#rejectPendingSteers();
+      this.#rootToolCalls.clear();
       this.#active = null;
       active?.reject(error52);
-      if (!this.#closePromise)
-        this.#onFault(error52);
     }
   }
   #spawn(options) {
@@ -57735,7 +58205,7 @@ var ClaudeSubagentLifecycle = class {
     });
     const outcome = cancellationRequested ? { status: "cancelled", reason: "Cancelled by user" } : event.isError ? { status: "failed", error: subagentFailure() } : { status: "succeeded" };
     this.#emit({ type: "item.completed", turnId, snapshot: { item, outcome } });
-    return subagent;
+    return { operation: active.item.operation, subagent };
   }
   finalize(turnId, outcome) {
     for (const [callId, active] of this.#delegations) {
@@ -57943,9 +58413,9 @@ function stringField(value, keys) {
   if (!isRecord12(value))
     return void 0;
   for (const key of keys) {
-    const field = value[key];
-    if (typeof field === "string" && field.length > 0)
-      return field;
+    const field2 = value[key];
+    if (typeof field2 === "string" && field2.length > 0)
+      return field2;
   }
   return void 0;
 }
@@ -58622,7 +59092,7 @@ function projectClaudePlanLimitToCredits(planLimit) {
 }
 var ClaudeHarnessSession = class {
   harnessId = claudeCodeHarnessId2;
-  capabilities = {
+  capabilities = /* @__PURE__ */ ((session) => ({
     configuration: {
       selectModel: true,
       selectThinkingOption: true,
@@ -58630,11 +59100,18 @@ var ClaudeHarnessSession = class {
       permissionModeScope: "live"
     },
     history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: true },
-    subagents: { observe: true, readTranscript: true }
-  };
+    subagents: { observe: true, readTranscript: true },
+    // Read live: native delivery joins this Turn while a root tool call runs, or while a held
+    // Turn's continuation waits on background work, on a CLI that confirms steers
+    // (`msg_lifecycle_v1`). A Turn whose cancellation is in flight must not take more input;
+    // every other case stops and restarts.
+    get steer() {
+      return session.#transport?.canSteerActiveTurn?.() === true && session.#active?.cancellationRequested !== true;
+    }
+  }))(this);
   commands;
   initialState;
-  initialUsage = null;
+  initialUsage;
   outputs;
   #channel = new HarnessOutputChannel();
   #cancelTimeoutMs;
@@ -58673,7 +59150,10 @@ var ClaudeHarnessSession = class {
   #hardCancelTask = null;
   #usageGeneration = 0;
   #latestUsage = null;
+  #lastAssistantResponseAtUnix;
+  #accountCreditsSupported;
   #minimumContextUsedTokens = null;
+  #latestRequestModel = null;
   #calibratedInputTokens = 0;
   #calibratedOutputTokens = 0;
   #calibratedCostUsd = 0;
@@ -58691,6 +59171,11 @@ var ClaudeHarnessSession = class {
   #continuationQuiescence = null;
   constructor(cwd, dependencies, closeTimeoutMs, onClosed, onPlanLimitObserved, options) {
     this.#cwd = cwd;
+    this.#lastAssistantResponseAtUnix = options.usageHistory.lastResponseAtUnix;
+    this.#accountCreditsSupported = options.accountCreditsSupported;
+    const composerIndicators = claudePromptCacheIndicators(this.#accountCreditsSupported, this.#lastAssistantResponseAtUnix);
+    this.initialUsage = composerIndicators.length ? { composerIndicators } : null;
+    this.#latestUsage = this.initialUsage;
     this.#pendingSessions = options.pendingSessions;
     const environment = options.environment;
     this.#createTransport = environment ? (input) => dependencies.createTransport({ ...input, environment }) : dependencies.createTransport;
@@ -58845,6 +59330,8 @@ var ClaudeHarnessSession = class {
     }
     if (command.type === "turn.cancel")
       return this.#cancel(command);
+    if (command.type === "turn.steer")
+      return this.#steer(command);
     if (command.type === "interaction.respond")
       return this.#respond(command);
     if (command.type === "model.select")
@@ -58946,6 +59433,7 @@ var ClaudeHarnessSession = class {
       nativeTurnKey,
       nativeTurnRef: null,
       cancellationRequested: false,
+      steersAwaitingNative: /* @__PURE__ */ new Set(),
       usageRequestIds: /* @__PURE__ */ new Set(),
       estimatedInputTokens: 0,
       estimatedOutputTokens: 0,
@@ -58981,6 +59469,52 @@ var ClaudeHarnessSession = class {
     }
     return { ok: true, value: { turnId: command.turnId } };
   }
+  async #steer(command) {
+    const active = this.#active;
+    if (!active || active.command.turnId !== command.turnId) {
+      return { ok: false, error: invalidState("Claude Code steer target is not the active Turn") };
+    }
+    if (active.cancellationRequested) {
+      return { ok: false, error: invalidState("Claude Code steer target is being cancelled") };
+    }
+    const text2 = command.input.map((input) => input.text).join("\n");
+    if (text2.length === 0) {
+      return {
+        ok: false,
+        error: {
+          code: "invalidRequest",
+          message: "Claude Code steer text must not be empty",
+          retryable: false
+        }
+      };
+    }
+    const transport = this.#transport;
+    if (!transport) {
+      return { ok: false, error: invalidState("Claude Code steer missed the active Turn") };
+    }
+    if (transport.supportsNativeSteer?.() !== true) {
+      return {
+        ok: false,
+        error: {
+          code: "unsupported",
+          message: "This Claude Code version does not confirm native steering",
+          retryable: false
+        }
+      };
+    }
+    const messageId = this.#randomUUID();
+    active.steersAwaitingNative.add(messageId);
+    try {
+      await transport.steer(text2, messageId, (started) => this.#takeOverSteer(active, messageId, started));
+    } catch (error52) {
+      if (error52 instanceof ClaudeSteerMissedTurnError) {
+        this.#takeOverSteer(active, messageId, false);
+        return { ok: false, error: invalidState("Claude Code steer missed the active Turn") };
+      }
+      throw error52;
+    }
+    return { ok: true, value: { accepted: true } };
+  }
   /** Built-ins plus the live commands and skills of the started native Session. */
   #liveCommandCatalog() {
     return claudeLiveCommandCatalog(claudeCommandCatalog, this.#transport?.slashCommands?.() ?? null);
@@ -59077,6 +59611,7 @@ var ClaudeHarnessSession = class {
       nativeTurnKey,
       nativeTurnRef: null,
       cancellationRequested: false,
+      steersAwaitingNative: /* @__PURE__ */ new Set(),
       usageRequestIds: /* @__PURE__ */ new Set(),
       estimatedInputTokens: 0,
       estimatedOutputTokens: 0,
@@ -59438,7 +59973,7 @@ var ClaudeHarnessSession = class {
     active.cancellationRequested = true;
     const transport = this.#transport;
     const taskIds = this.#backgroundTaskIds(active);
-    if (transport && (taskIds.length > 0 || active.held && (active.rootSegmentActive || this.#occupancy.awaitingContinuation))) {
+    if (transport && (taskIds.length > 0 || active.held && (active.rootSegmentActive || this.#occupancy.awaitingContinuation || active.steersAwaitingNative.size > 0))) {
       await this.#cancelBackgroundWork(active, transport, taskIds);
       return { ok: true, value: { cancellationRequested: true } };
     }
@@ -59513,6 +60048,11 @@ var ClaudeHarnessSession = class {
       return;
     if (cancellation.stopping || cancellation.interrupting || active.rootSegmentActive)
       return;
+    if (active.steersAwaitingNative.size > 0) {
+      this.#armCancelEscalation(active);
+      return;
+    }
+    this.#clearCancelEscalation();
     this.#clearCancellationQuiet(cancellation);
     const quiet = setTimeout(() => {
       cancellation.quiet = null;
@@ -59751,6 +60291,10 @@ var ClaudeHarnessSession = class {
         this.#completeReasoning(active, event.messageId, { status: "succeeded" });
         return;
       case "message.completed": {
+        if (!event.localCommand) {
+          this.#lastAssistantResponseAtUnix = Math.floor(Date.now() / 1e3);
+          this.publishAccountCreditsSupport(this.#accountCreditsSupported);
+        }
         this.#observeRootOutput(active);
         if (event.lastRequestUsage) {
           this.#requestUsageBoundary += 1;
@@ -59788,10 +60332,7 @@ var ClaudeHarnessSession = class {
         }
         this.#completeAgentItem(active, { status: "succeeded" }, false);
         active.subagents.start(active.command.turnId, event);
-        if (event.operation === "send") {
-          if (event.nativeSubagentId)
-            this.#occupancy.occupyAgent(event.nativeSubagentId);
-        } else if (event.background) {
+        if (event.operation === "spawn" && event.background) {
           this.#occupancy.occupySpawn(event.callId, event.nativeSubagentId);
         }
         return;
@@ -59810,13 +60351,17 @@ var ClaudeHarnessSession = class {
         }
         return;
       case "subagent.completed": {
-        const subagent = active.subagents.complete(active.command.turnId, event, active.cancellationRequested);
-        if (subagent.status === "running") {
-          if (subagent.nativeSubagentId) {
-            this.#occupancy.bind(event.callId, subagent.nativeSubagentId);
+        const { operation, subagent } = active.subagents.complete(active.command.turnId, event, active.cancellationRequested);
+        if (operation === "send") {
+          if (subagent.status === "running" && subagent.nativeSubagentId) {
+            this.#occupancy.occupyAgent(subagent.nativeSubagentId);
           }
           return;
         }
+        if (subagent.status === "running") {
+          this.#occupancy.occupySpawn(event.callId, subagent.nativeSubagentId);
+          return;
+        }
         this.#occupancy.release(event.callId, subagent.nativeSubagentId);
         return;
       }
@@ -60124,6 +60669,7 @@ var ClaudeHarnessSession = class {
     const active = {
       command: { type: "turn.start", turnId, input: [] },
       compactionItem: null,
+      steersAwaitingNative: /* @__PURE__ */ new Set(),
       item,
       agentMessageOrdinal: 1,
       assistantMessageId: null,
@@ -60373,6 +60919,8 @@ var ClaudeHarnessSession = class {
     const promptTokens = usage.inputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
     if (promptTokens > 0)
       this.#minimumContextUsedTokens = promptTokens;
+    if (usage.model)
+      this.#latestRequestModel = usage.model;
     const cacheHitRatePercent = claudeCacheHitRatePercent(usage);
     const contextWindowTokens = this.#latestUsage?.contextWindowTokens;
     this.#mergeAndPublishUsage({
@@ -60414,8 +60962,24 @@ var ClaudeHarnessSession = class {
       if (cacheHitRatePercent !== void 0)
         delta.cacheHitRatePercent = cacheHitRatePercent;
     }
+    if (this.#latestUsage?.contextWindowTokens === void 0 && this.#minimumContextUsedTokens !== null) {
+      const contextWindowTokens = this.#resultContextWindow(event.modelUsage);
+      if (contextWindowTokens !== void 0) {
+        delta.contextUsedTokens = this.#minimumContextUsedTokens;
+        delta.contextWindowTokens = contextWindowTokens;
+      }
+    }
     this.#mergeAndPublishUsage(delta, active.command.turnId);
   }
+  /** The latest request's Model, else the Model that carried the most prompt tokens. */
+  #resultContextWindow(modelUsage) {
+    if (!modelUsage?.length)
+      return void 0;
+    const latest = this.#latestRequestModel;
+    const matched = latest ? modelUsage.find(({ model: model2 }) => model2 === latest) : void 0;
+    const main = matched ?? modelUsage.reduce((best, entry) => (entry.promptTokens ?? entry.inputTokens) > (best.promptTokens ?? best.inputTokens) ? entry : best);
+    return main.contextWindowTokens;
+  }
   /**
    * Plan usage is account-wide, not Thread-scoped, so every observation is
    * offered to the Adapter's shared cache regardless of this Session's own
@@ -60428,6 +60992,15 @@ var ClaudeHarnessSession = class {
     if (effective)
       this.publishPlanLimit(effective);
   }
+  publishAccountCreditsSupport(supported) {
+    if (this.#phase !== "open")
+      return;
+    this.#accountCreditsSupported = supported;
+    const composerIndicators = claudePromptCacheIndicators(supported, this.#lastAssistantResponseAtUnix);
+    if (composerIndicators[0]?.expiresAtUnix === this.#latestUsage?.composerIndicators?.[0]?.expiresAtUnix)
+      return;
+    this.#mergeAndPublishUsage({ composerIndicators }, this.#active?.command.turnId);
+  }
   publishPlanLimit(planLimit) {
     if (this.#phase !== "open")
       return;
@@ -60485,7 +61058,7 @@ var ClaudeHarnessSession = class {
     this.#clearContinuationQuiescence();
     const quiescence = setTimeout(() => {
       this.#continuationQuiescence = null;
-      if (this.#active !== active || !active.held || active.rootSegmentActive || this.#phase !== "open") {
+      if (this.#active !== active || !active.held || active.rootSegmentActive || active.steersAwaitingNative.size > 0 || this.#phase !== "open") {
         return;
       }
       this.#occupancy.releaseContinuations();
@@ -60506,6 +61079,30 @@ var ClaudeHarnessSession = class {
     active.rootSegmentActive = true;
     this.#clearContinuationQuiescence();
   }
+  /**
+   * A drained steer runs in a native turn whose result still reaches this Turn, folded into the
+   * running Root Segment or as the held Turn's next one. A steer that ends without one releases
+   * its keep-open, so a Turn held only for it settles as if the steer had never been written.
+   */
+  #takeOverSteer(active, messageId, started) {
+    if (!active.steersAwaitingNative.delete(messageId) || this.#active !== active)
+      return;
+    if (started) {
+      this.#handleTurnEvent(active, { type: "segment.started" });
+      return;
+    }
+    if (active.cancellation) {
+      this.#settleCancellation(active);
+      return;
+    }
+    if (!active.held || active.rootSegmentActive || active.steersAwaitingNative.size > 0 || this.#phase !== "open") {
+      return;
+    }
+    if (this.#occupancy.awaitingContinuation)
+      this.#armContinuationQuiescence(active);
+    else if (!this.#occupancy.unsettled)
+      this.#finish(active, { status: "succeeded" });
+  }
   #finish(active, outcome) {
     if (this.#active !== active)
       return;
@@ -60516,7 +61113,7 @@ var ClaudeHarnessSession = class {
       active.cancellation = null;
     }
     this.#clearContinuationQuiescence();
-    const hold = outcome.status === "succeeded" && !active.cancellationRequested && this.#occupancy.unsettled;
+    const hold = outcome.status === "succeeded" && !active.cancellationRequested && (this.#occupancy.unsettled || active.steersAwaitingNative.size > 0);
     this.#closeActiveInteractions(active, outcome.status === "succeeded" ? "superseded" : "cancelled", hold);
     const itemOutcome2 = outcome;
     if (active.compactionItem)
@@ -60703,6 +61300,7 @@ var ClaudeCodeAdapter = class {
   #closePromise = null;
   #latestPlanLimit = null;
   #accountInspection = null;
+  #accountCreditsSupported = false;
   constructor(options = {}, dependencies) {
     const environment = options.environment ?? process.env;
     this.#environment = environment;
@@ -60781,7 +61379,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path16.resolve(input.cwd ?? process.cwd());
+    const cwd = path15.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -60814,12 +61412,20 @@ var ClaudeCodeAdapter = class {
     return this.#accountInspection;
   }
   async #readAccount() {
+    const planLimitAtStart = this.#latestPlanLimit;
     let inspector;
     try {
       this.#dependencies.inspectInstallation();
       inspector = this.#dependencies.createInspector({ cwd: process.cwd() });
       this.#inspectors.add(inspector);
-      return await inspector.inspectAccount?.() ?? null;
+      const account = await inspector.inspectAccount?.() ?? null;
+      if (this.#latestPlanLimit === planLimitAtStart) {
+        this.#accountCreditsSupported = account?.credits !== void 0;
+        for (const session of this.#sessions) {
+          session.publishAccountCreditsSupport(this.#accountCreditsSupported);
+        }
+      }
+      return account;
     } catch {
       return null;
     } finally {
@@ -60977,7 +61583,7 @@ var ClaudeCodeAdapter = class {
       }
       requestedPermissionModeId = CLAUDE_DEFAULT_PERMISSION_MODE_ID;
     }
-    const cwd = path16.resolve(input.cwd);
+    const cwd = path15.resolve(input.cwd);
     if (input.kind === "rollbackLastTurn") {
       for (const source of this.#sessions) {
         const ready = await source.prepareRollback(input.sourceRef.nativeSessionId);
@@ -61062,6 +61668,7 @@ var ClaudeCodeAdapter = class {
       ...durableRef ? { nativeRef: durableRef } : {},
       sessionId,
       usageHistory,
+      accountCreditsSupported: this.#accountCreditsSupported,
       ...requestedModel ? { requestedModel } : {},
       requestedPermissionModeId,
       requestedThinkingOptionId,
@@ -61081,7 +61688,13 @@ var ClaudeCodeAdapter = class {
       return { requests: [], complete: true };
     try {
       const messages = await this.#dependencies.readSessionMessages({ cwd, sessionId });
-      return messages === null ? { requests: [], complete: false } : claudeUsageHistory(messages);
+      if (messages === null)
+        return { requests: [], complete: false };
+      const lastResponseAtUnix = lastClaudeAssistantResponseUnix(messages);
+      return {
+        ...claudeUsageHistory(messages),
+        ...lastResponseAtUnix !== void 0 ? { lastResponseAtUnix } : {}
+      };
     } catch {
       return { requests: [], complete: false };
     }
@@ -61093,9 +61706,17 @@ var ClaudeCodeAdapter = class {
       next.fiveHour = planLimit.fiveHour;
     if (planLimit.sevenDay)
       next.sevenDay = planLimit.sevenDay;
+    try {
+      if (!accountCreditsSnapshotSchema.safeParse(projectClaudePlanLimitToCredits(next)).success)
+        return null;
+    } catch {
+      return null;
+    }
     this.#latestPlanLimit = next.fiveHour || next.sevenDay ? next : null;
     if (this.#latestPlanLimit) {
+      this.#accountCreditsSupported = true;
       for (const session of this.#sessions) {
+        session.publishAccountCreditsSupport(true);
         if (session !== origin)
           session.publishPlanLimit(this.#latestPlanLimit);
       }
@@ -61122,7 +61743,7 @@ var ClaudeCodeAdapter = class {
 // dist/installation.js
 import { readFile as readFile8, realpath as realpath5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path17 from "node:path";
+import path16 from "node:path";
 async function readSettings(file2) {
   const text2 = await readFile8(file2, "utf8").catch((error52) => {
     if (error52.code === "ENOENT")
@@ -61143,9 +61764,9 @@ function createClaudeInstallation(environment, command) {
         ...command ? { command } : {}
       });
       const home = environment.HOME ?? environment.USERPROFILE ?? homedir2();
-      const config2 = environment.CLAUDE_CONFIG_DIR ? path17.resolve(home, environment.CLAUDE_CONFIG_DIR) : path17.join(home, ".claude");
-      const managedFile = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? path17.join(environment.ProgramFiles ?? "C:\\Program Files", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
-      const user = await readSettings(path17.join(config2, "settings.json"));
+      const config2 = environment.CLAUDE_CONFIG_DIR ? path16.resolve(home, environment.CLAUDE_CONFIG_DIR) : path16.join(home, ".claude");
+      const managedFile = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? path16.join(environment.ProgramFiles ?? "C:\\Program Files", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
+      const user = await readSettings(path16.join(config2, "settings.json"));
       const managed = await readSettings(managedFile);
       const settings = { ...user, ...managed, env: { ...user.env, ...managed.env } };
       const env = { ...environment, ...settings.env };
@@ -61158,10 +61779,10 @@ function createClaudeInstallation(environment, command) {
         throw new Error("Unknown Claude release channel");
       const latestVersion = installationVersion(await fetchInstallationText(`https://downloads.claude.ai/claude-code-releases/${channel}`));
       const npm = await npmInstallation(executable, ["@anthropic-ai/claude-code"], env);
-      const launcher = path17.join(home, ".local", "bin", process.platform === "win32" ? "claude.exe" : "claude");
+      const launcher = path16.join(home, ".local", "bin", process.platform === "win32" ? "claude.exe" : "claude");
       const selected = await realpath5(executable);
-      const versions = path17.join(home, ".local", "share", "claude", "versions") + path17.sep;
-      const native = path17.resolve(executable) === launcher && (selected.startsWith(versions) || process.platform === "win32" && selected === launcher);
+      const versions = path16.join(home, ".local", "share", "claude", "versions") + path16.sep;
+      const native = path16.resolve(executable) === launcher && (selected.startsWith(versions) || process.platform === "win32" && selected === launcher);
       const blocked = !!env.DISABLE_UPDATES && env.DISABLE_UPDATES !== "0" || !!settings.minimumVersion && newerInstallationVersion(latestVersion, installationVersion(settings.minimumVersion)) || !!settings.requiredMaximumVersion && newerInstallationVersion(installationVersion(settings.requiredMaximumVersion), latestVersion);
       const canUpdate = !blocked && (npm?.canUpdate ?? native);
       update = async () => {
@@ -61192,7 +61813,7 @@ function createClaudeInstallation(environment, command) {
 }
 
 // dist/user-shell-environment.js
-import path18 from "node:path";
+import path17 from "node:path";
 import { execFile as execFile4 } 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";
@@ -61235,7 +61856,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(path18.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path17.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);
@@ -61273,6 +61894,7 @@ async function createHarnessAdapter(context) {
   const environment = await withUserShellEnvironment({ ...context.environment });
   if (context.platform === "darwin" && context.managedRemoteHost) {
     return new BrokeredHarnessAdapter({
+      sessionImport: true,
       forwardDelegationEnvironment: true,
       commandCatalog: claudeCommandCatalog,
       liveCommandCatalog: true,