@karlorz/codexhost-cli-win32-arm64 0.13.3-7 → 0.14.0-0

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

@@ -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),
@@ -14832,6 +14841,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/grok-computer-use/get",
@@ -14909,7 +14920,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(),
@@ -15317,7 +15339,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(),
@@ -15449,6 +15473,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;
@@ -15570,6 +15603,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(),
@@ -15577,6 +15614,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);
@@ -16135,6 +16186,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -16157,6 +16209,7 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
   for (const field of [
     "totalCredits",
     "contextUsagePercent",
@@ -16227,9 +16280,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",
@@ -16428,6 +16481,7 @@ var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.open",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
+  "session.readCapabilities",
   "session.refreshUsage",
   "session.execute",
   "session.commands.list",
@@ -16608,6 +16662,11 @@ var turnStartSchema = external_exports.object({
   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({
@@ -16633,6 +16692,7 @@ var permissionSelectSchema = external_exports.object({
 }).strict();
 var brokerHostCommandSchema = external_exports.discriminatedUnion("type", [
   turnStartSchema,
+  turnSteerSchema,
   turnCancelSchema,
   interactionRespondSchema,
   modelSelectSchema,
@@ -16825,6 +16885,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
@@ -17176,6 +17237,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", {});
   }
@@ -17207,6 +17273,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))
@@ -17752,6 +17820,31 @@ 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";
@@ -54570,11 +54663,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;
 }
@@ -54931,6 +55033,7 @@ var ClaudeNativeTurnAccumulator = class {
     events.push({
       type: "message.completed",
       messageId,
+      localCommand: true,
       ...checkpointId ? { checkpointId } : {}
     });
   }
@@ -55413,6 +55516,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 Set();
+  let pendingNotification = false;
   for (const value of values) {
     if (!isRecord8(value))
       throw new Error("Claude history contains a malformed message");
@@ -55431,8 +55538,46 @@ 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.add(event.callId);
+          if (event.nativeSubagentId)
+            occupancy.occupyAgent(event.nativeSubagentId);
+        } else if (event.background)
+          occupancy.occupySpawn(event.callId, event.nativeSubagentId);
+      } else if (event.type === "subagent.completed") {
+        if (!event.isError && (event.continuesInBackground || sends.has(event.callId))) {
+          occupancy.occupySpawn(event.callId, event.nativeSubagentId);
+        } else
+          occupancy.release(event.callId, event.nativeSubagentId);
+        sends.delete(event.callId);
+      } 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;
@@ -55489,17 +55634,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;
@@ -56663,12 +56808,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 {
@@ -56924,6 +57078,11 @@ 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();
   #autonomous = null;
   #autonomousTurnHandler = null;
   #idleHandler = null;
@@ -56947,6 +57106,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;
@@ -57001,7 +57161,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),
@@ -57038,6 +57199,40 @@ 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.
+   */
+  canSteerActiveTurn() {
+    return this.#nativeSteer && this.#active !== null && this.#rootToolCalls.size > 0;
+  }
+  #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;
@@ -57160,6 +57355,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,
@@ -57179,6 +57375,51 @@ 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) {
+    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());
+    }
+    const pending = this.#pendingSteers.get(messageId);
+    if (pending) {
+      pending.timer = setTimeout(() => this.#acceptSteer(messageId), 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();
+  }
   respondToInteraction(response) {
     const pending = this.#interactions.get(response.requestId);
     if (!pending) {
@@ -57350,6 +57591,7 @@ var ClaudeSdkTransport = class {
     }
   }
   async #close() {
+    this.#rejectPendingSteers();
     const failures = [];
     this.#closeInteractions("all", "cancelled");
     try {
@@ -57403,6 +57645,7 @@ var ClaudeSdkTransport = class {
     }
     this.#query = null;
     const active = this.#active;
+    this.#rootToolCalls.clear();
     this.#active = null;
     this.#autonomous = null;
     this.#idleAccumulator = null;
@@ -57457,6 +57700,26 @@ var ClaudeSdkTransport = class {
         await delay(10);
     }
   }
+  #rejectPendingSteers() {
+    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. */
+  #observeSteer(message) {
+    if (this.#pendingSteers.size === 0 || !isRecord11(message) || message.type !== "command_lifecycle") {
+      return;
+    }
+    if (message.state !== "queued")
+      return;
+    if (typeof message.command_uuid !== "string" || message.command_uuid.length === 0)
+      return;
+    this.#acceptSteer(message.command_uuid);
+  }
   #observeBackgroundTasks(message) {
     if (!isRecord11(message) || message.type !== "system")
       return;
@@ -57497,6 +57760,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;
@@ -57505,13 +57769,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);
           }
@@ -57565,6 +57832,8 @@ var ClaudeSdkTransport = class {
     } catch (error52) {
       const active = this.#active;
       this.#closeInteractions("all", "cancelled");
+      this.#rejectPendingSteers();
+      this.#rootToolCalls.clear();
       this.#active = null;
       active?.reject(error52);
       if (!this.#closePromise)
@@ -58754,7 +59023,7 @@ function projectClaudePlanLimitToCredits(planLimit) {
 }
 var ClaudeHarnessSession = class {
   harnessId = claudeCodeHarnessId2;
-  capabilities = {
+  capabilities = /* @__PURE__ */ ((session) => ({
     configuration: {
       selectModel: true,
       selectThinkingOption: true,
@@ -58762,11 +59031,16 @@ 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 only while a requested Turn runs a root tool call
+    // on a CLI that confirms steers (`msg_lifecycle_v1`). Otherwise the Host stops and restarts.
+    get steer() {
+      return session.#transport?.canSteerActiveTurn?.() === true;
+    }
+  }))(this);
   commands;
   initialState;
-  initialUsage = null;
+  initialUsage;
   outputs;
   #channel = new HarnessOutputChannel();
   #cancelTimeoutMs;
@@ -58805,7 +59079,10 @@ var ClaudeHarnessSession = class {
   #hardCancelTask = null;
   #usageGeneration = 0;
   #latestUsage = null;
+  #lastAssistantResponseAtUnix;
+  #accountCreditsSupported;
   #minimumContextUsedTokens = null;
+  #latestRequestModel = null;
   #calibratedInputTokens = 0;
   #calibratedOutputTokens = 0;
   #calibratedCostUsd = 0;
@@ -58823,6 +59100,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;
@@ -58977,6 +59259,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")
@@ -59113,6 +59397,45 @@ var ClaudeHarnessSession = class {
     }
     return { ok: true, value: { turnId: command.turnId } };
   }
+  async #steer(command) {
+    if (!this.#active || this.#active.command.turnId !== command.turnId) {
+      return { ok: false, error: invalidState("Claude Code steer target is not the active Turn") };
+    }
+    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
+        }
+      };
+    }
+    try {
+      await transport.steer(text2, this.#randomUUID());
+    } catch (error52) {
+      if (error52 instanceof ClaudeSteerMissedTurnError) {
+        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);
@@ -59883,6 +60206,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;
@@ -59944,9 +60271,7 @@ var ClaudeHarnessSession = class {
       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);
-          }
+          this.#occupancy.occupySpawn(event.callId, subagent.nativeSubagentId);
           return;
         }
         this.#occupancy.release(event.callId, subagent.nativeSubagentId);
@@ -60505,6 +60830,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({
@@ -60546,8 +60873,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
@@ -60560,6 +60903,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;
@@ -60835,6 +61187,7 @@ var ClaudeCodeAdapter = class {
   #closePromise = null;
   #latestPlanLimit = null;
   #accountInspection = null;
+  #accountCreditsSupported = false;
   constructor(options = {}, dependencies) {
     const environment = options.environment ?? process.env;
     this.#environment = environment;
@@ -60946,12 +61299,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 {
@@ -61194,6 +61555,7 @@ var ClaudeCodeAdapter = class {
       ...durableRef ? { nativeRef: durableRef } : {},
       sessionId,
       usageHistory,
+      accountCreditsSupported: this.#accountCreditsSupported,
       ...requestedModel ? { requestedModel } : {},
       requestedPermissionModeId,
       requestedThinkingOptionId,
@@ -61213,7 +61575,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 };
     }
@@ -61225,9 +61593,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);
       }