@codexhost/cli-darwin-arm64 0.16.1 → 0.17.1

package/app/plugins/antigravity/plugin.mjs

@@ -19089,6 +19089,32 @@ function createAntigravityUsageStatistics(environment) {
 }
 
 // dist/antigravity-adapter.js
+function unstreamedReplyTail(streamed, reply) {
+  const shown = streamed.replace(/\s+/gu, "");
+  if (shown === "")
+    return null;
+  const replied = reply.replace(/\s+/gu, "");
+  if (shown.endsWith(replied))
+    return "";
+  let at = 0;
+  let matched = 0;
+  while (matched < shown.length && at < reply.length) {
+    const char = reply[at] ?? "";
+    if (/\s/u.test(char)) {
+      at += 1;
+      continue;
+    }
+    if (char !== shown[matched])
+      return null;
+    at += 1;
+    matched += 1;
+  }
+  if (matched < shown.length)
+    return null;
+  const tail = reply.slice(at);
+  const shownTrailing = /\s*$/u.exec(streamed)?.[0] ?? "";
+  return tail.startsWith(shownTrailing) ? tail.slice(shownTrailing.length) : tail;
+}
 var antigravityHarnessId = harnessIdSchema.parse("antigravity");
 var DEFAULT_INSPECT_TIMEOUT_MS = 2e4;
 var DEFAULT_PRINT_TIMEOUT = "30m";
@@ -19573,6 +19599,7 @@ var AntigravitySession = class {
       logPath,
       agentItem: null,
       agentText: "",
+      turnAgentText: "",
       tools: /* @__PURE__ */ new Map(),
       completedItems: [],
       stderr: "",
@@ -19770,19 +19797,27 @@ ${line}`).slice(-8e3);
     const repliedThisTurn = Boolean(active.agentItem) || turnReply.trim() !== "";
     if (response)
       this.#lastResultResponse = response;
-    if (turnReply.trim() !== "")
-      this.#appendOrSyncAgentText(active, turnReply, false);
+    if (turnReply.trim() !== "") {
+      const unshown = unstreamedReplyTail(active.turnAgentText, turnReply);
+      if (unshown === null)
+        this.#appendOrSyncAgentText(active, turnReply, false);
+      else if (unshown.trim() !== "")
+        this.#appendAgentText(active, unshown);
+    }
+    if (!convId) {
+      this.#completeIdentitylessTurn(active, event);
+      return;
+    }
     const safeTurnId = event.result.num_turns !== void 0 && event.result.num_turns !== null ? `turn:${event.result.num_turns}` : `turn:${this.#history.snapshot().length + 1}`;
-    const safeSessionId = convId || this.#nativeRef?.nativeSessionId || "unknown-session";
     const nativeTurnRef = nativeTurnRefSchema.parse({
       harnessId: this.harnessId,
-      nativeSessionId: safeSessionId,
+      nativeSessionId: convId,
       nativeTurnKey: safeTurnId,
       formatVersion: 1
     });
     const checkpoint = nativeCheckpointRefSchema.parse({
       harnessId: this.harnessId,
-      nativeSessionId: safeSessionId,
+      nativeSessionId: convId,
       checkpointId: safeTurnId,
       formatVersion: 1
     });
@@ -19799,16 +19834,33 @@ ${line}`).slice(-8e3);
         this.#completeTurn(active, { status: "succeeded", checkpoint }, nativeTurnRef);
       }
     } else {
-      const nativeError = event.result.error?.trim();
-      const errorDetail = nativeError || active.stderr;
-      const error51 = normalizedProcessError(errorDetail, `Antigravity Turn ended with status ${event.result.status}`, nativeError !== void 0);
-      if (repliedThisTurn && nativeError && this.#reportedEarlier(error51)) {
+      const error51 = this.#resultError(active, event);
+      if (repliedThisTurn && event.result.error?.trim() && this.#reportedEarlier(error51)) {
         this.#completeTurn(active, { status: "succeeded", checkpoint }, nativeTurnRef);
       } else {
         this.#completeTurn(active, { status: "failed", error: error51, checkpoint }, nativeTurnRef);
       }
     }
   }
+  /** A Turn agy ended without a Conversation keeps its native outcome but no native identity. */
+  #completeIdentitylessTurn(active, event) {
+    if (active.cancellationRequested) {
+      this.#completeTurn(active, { status: "cancelled", reason: "Cancelled by user" });
+      return;
+    }
+    this.#completeTurn(active, {
+      status: "failed",
+      error: event.result.status === "SUCCESS" ? {
+        code: "protocolError",
+        message: "Antigravity finished the Turn without a Conversation identity",
+        retryable: true
+      } : this.#resultError(active, event)
+    });
+  }
+  #resultError(active, event) {
+    const nativeError = event.result.error?.trim();
+    return normalizedProcessError(nativeError || active.stderr, `Antigravity Turn ended with status ${event.result.status}`, nativeError !== void 0);
+  }
   #reportedEarlier(error51) {
     return this.#history.snapshot().some(({ outcome }) => outcome.status === "failed" && outcome.error.code === error51.code && outcome.error.message === error51.message);
   }
@@ -19955,6 +20007,7 @@ ${line}`).slice(-8e3);
     this.#appendAgentText(active, text);
   }
   #appendAgentText(active, text) {
+    active.turnAgentText += text;
     if (!active.agentItem) {
       active.agentItem = { type: "agentMessage", itemId: this.#newItemId(), text };
       active.agentText = text;

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

@@ -55584,6 +55584,8 @@ function conversationMessages(values, sessionId) {
       type: value.type,
       uuid: value.uuid,
       message: value.message,
+      // Failure metadata belongs to the outer SDK/transcript record, not its Message.
+      failed: value.type === "assistant" && (typeof value.error === "string" || value.isApiErrorMessage === true),
       nested: typeof value.parent_tool_use_id === "string" && value.parent_tool_use_id.length > 0,
       interrupted,
       startsTurn: false,
@@ -55649,7 +55651,7 @@ function turnOutcome(messages) {
   if (messages.some(({ interrupted }) => interrupted))
     return { status: "cancelled", reason: "Cancelled by user" };
   const assistants = messages.filter(({ type }) => type === "assistant");
-  const failed = assistants.some(({ message }) => typeof message.error === "string");
+  const failed = assistants.some(({ failed: failed2, nested }) => failed2 && !nested);
   if (failed) {
     return {
       status: "failed",
@@ -55735,6 +55737,7 @@ function mapClaudeSnapshot(values, sessionId) {
         }
         if (message.type !== "assistant")
           return [];
+        const assistantOutcome = outcome.status === "failed" && (!message.failed || message.nested) ? { status: "succeeded" } : itemOutcome(outcome);
         const content = message.message.content;
         const text2 = textParts(content).join("");
         const reasoning = thinkingParts(content).join("");
@@ -55746,7 +55749,7 @@ function mapClaudeSnapshot(values, sessionId) {
                 itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
                 text: text2
               },
-              outcome: itemOutcome(outcome)
+              outcome: assistantOutcome
             }
           ] : [];
         }
@@ -55763,7 +55766,7 @@ function mapClaudeSnapshot(values, sessionId) {
                 itemId: claudeTranscriptItemId(user.uuid, "reasoning", reasoningOrdinal += 1),
                 text: reasoning
               },
-              outcome: itemOutcome(outcome)
+              outcome: assistantOutcome
             });
             projectedReasoning = true;
             continue;
@@ -55775,7 +55778,7 @@ function mapClaudeSnapshot(values, sessionId) {
                 itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
                 text: text2
               },
-              outcome: itemOutcome(outcome)
+              outcome: assistantOutcome
             });
             projectedText = true;
             continue;
@@ -57551,7 +57554,8 @@ var ClaudeSdkTransport = class {
     const activeQuery = this.#query;
     if (!activeQuery)
       throw new Error("Claude SDK transport is not running");
-    this.#idleAccumulator?.requestCancel();
+    const idle = this.#idleAccumulator ??= new ClaudeNativeTurnAccumulator(this.#provider ? { provider: this.#provider } : {});
+    idle.requestCancel();
     try {
       await this.#stopRequest(activeQuery.interrupt(), INTERRUPT_TIMEOUT_MESSAGE);
     } catch (error52) {
@@ -59978,7 +59982,9 @@ 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 || active.steersAwaitingNative.size > 0))) {
+    if (transport && (taskIds.length > 0 || // A written steer survives the interrupt and runs as Claude's next native turn, so the
+    // Turn stays open to interrupt that turn too instead of leaking it into the next one.
+    active.steersAwaitingNative.size > 0 || active.held && (active.rootSegmentActive || this.#occupancy.awaitingContinuation))) {
       await this.#cancelBackgroundWork(active, transport, taskIds);
       return { ok: true, value: { cancellationRequested: true } };
     }

package/app/plugins/codebuddy/plugin.mjs

@@ -18350,6 +18350,16 @@ function snapshotFromHistory(contents, ref, cwd, profile = CODEBUDDY_RUNTIME_PRO
       continue;
     if (supportsNativeCommands && row.type === "message" && row.role === "user" && data.agent === "compact" && !manualCompactions.has(text(row.id)))
       continue;
+    if (row.type === "message" && row.role === "user" && data.startsNewUserRequest === false && !localCommand && data.agent !== "compact" && !isNativeCompactionSummary(row)) {
+      const contextOnly = body.trim().length > 0 && body.replace(/<system-reminder\b[^>]*\sdata-role=(["'])user-context\1[^>]*>[\s\S]*?<\/system-reminder>/gu, "").trim().length === 0;
+      if (data.isMeta === true || contextOnly)
+        continue;
+      if (current) {
+        if (body)
+          current.input.push({ type: "text", text: body });
+        continue;
+      }
+    }
     if (includeCompactionHistory && isNativeCompactionSummary(row)) {
       if (supportsNativeCommands && current) {
         const outcome = data.isCompacted === true ? { status: "succeeded" } : {

package/app/plugins/cursor-cli/plugin.mjs

@@ -17042,6 +17042,16 @@ function cursorConfigDirectory(environment) {
   const home = environment.HOME ?? environment.USERPROFILE ?? os2.homedir();
   return environment.CURSOR_CONFIG_DIR?.trim() ? path6.resolve(environment.CURSOR_CONFIG_DIR) : environment.XDG_CONFIG_HOME?.trim() ? path6.resolve(environment.XDG_CONFIG_HOME, "cursor") : path6.join(home, ".cursor");
 }
+function cursorCliApprovalModeIsUnrestricted(environment, cwd = process.cwd()) {
+  try {
+    const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) ?? os2.userInfo().homedir;
+    const directory = environment.CURSOR_CONFIG_DIR?.trim() ? environment.CURSOR_CONFIG_DIR : environment.XDG_CONFIG_HOME?.trim() ? path6.join(environment.XDG_CONFIG_HOME, "cursor") : path6.join(home, ".cursor");
+    const raw = JSON.parse(readFileSync(path6.resolve(cwd, directory, "cli-config.json"), "utf8"));
+    return !!raw && typeof raw === "object" && !Array.isArray(raw) && raw.approvalMode === "unrestricted";
+  } catch {
+    return false;
+  }
+}
 function cursorSessionDirectory(sessionId, environment) {
   if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(sessionId))
     throw new Error("Unsupported Cursor native session ID");
@@ -17138,7 +17148,8 @@ function readCursorNativeHistory(sessionId, cwd, environment, allowMissing = fal
         result.push({
           id,
           text: one(user, 1).toString("utf8"),
-          ...rewindRoot ? { rewindRoot } : {}
+          ...rewindRoot ? { rewindRoot } : {},
+          ...user.get(15)?.length ? { notification: true } : {}
         });
       }
     }
@@ -17412,12 +17423,17 @@ function cursorCatalog(info) {
   const native = cursorModels(info);
   const thinking = /* @__PURE__ */ new Map();
   const models = native.models.map((model2) => {
-    const config2 = model2.value === native.current ? info.configOptions : info.nativeModels?.find((entry) => entry.value === model2.value)?.configOptions;
+    const live = model2.value === native.current;
+    const config2 = live ? info.configOptions : info.nativeModels?.find((entry) => entry.value === model2.value)?.configOptions;
     const options = cursorThinking(config2);
     for (const { id, label } of options)
       thinking.set(id, { id, label });
     return {
-      ref: cursorConfiguredModelRef(model2.value, config2),
+      // Only the live model's parameters reflect the user's Cursor settings. The parameterized
+      // catalog reports Cursor's built-in defaults for every other model (for example
+      // `fast=true`), so pinning them would override the user's remembered per-model parameters.
+      // A bare Ref selects only the model and lets Cursor apply those parameters itself.
+      ref: live ? cursorConfiguredModelRef(model2.value, config2) : cursorModelRef(model2.value),
       label: model2.name,
       supportedThinkingOptionIds: options.map(({ id }) => id)
     };
@@ -21716,7 +21732,8 @@ var CursorTransport = class {
     return this.#preparation ??= this.#prepare();
   }
   async #prepare() {
-    const invocation = cursorInvocation(this.options.environment, this.options.command, this.options.executionPolicy === "unattended-full-access" ? ["--force", "acp"] : ["acp"]);
+    const useForce = this.options.executionPolicy === "unattended-full-access" || cursorCliApprovalModeIsUnrestricted(this.options.environment, this.options.cwd);
+    const invocation = cursorInvocation(this.options.environment, this.options.command, useForce ? ["--force", "acp"] : ["acp"]);
     const child = spawn(invocation.command, invocation.arguments, {
       cwd: this.options.cwd,
       env: this.options.environment,
@@ -23803,19 +23820,22 @@ var CursorSession = class {
       const administrative = command.input.map((part) => part.text).join("\n").trim().toLowerCase() === "/copy-request-id";
       if (administrative && JSON.stringify(before) === JSON.stringify(after)) {
       } else {
-        if (added.length !== 1 || after.length !== before.length + 1 || before.some((turn, index) => after[index]?.id !== turn.id) || added[0]?.text !== command.input.map((part) => part.text).join("\n"))
+        const prompted = added.filter((turn) => !turn.notification);
+        const own = prompted[0];
+        if (!own || prompted.length !== 1 || after.length !== before.length + added.length || before.some((turn, index) => after[index]?.id !== turn.id) || own.text !== command.input.map((part) => part.text).join("\n"))
           throw new Error("Cursor terminal has no unique, verified native turn identity");
         nativeTurnRef = nativeTurnRefSchema.parse({
           harnessId: "cursor-cli",
           nativeSessionId: this.transport.sessionId,
-          nativeTurnKey: added[0].id,
+          nativeTurnKey: own.id,
           formatVersion: 1
         });
         this.#fresh = false;
-        if (outcome.status === "succeeded" && cursorForkAvailable())
+        const ownIndex = after.findIndex((turn) => turn.id === own.id);
+        if (outcome.status === "succeeded" && cursorForkAvailable() && (ownIndex === after.length - 1 || after[ownIndex + 1]?.rewindRoot))
           outcome = {
             ...outcome,
-            checkpoint: cursorCheckpoint(this.transport.sessionId, added[0].id)
+            checkpoint: cursorCheckpoint(this.transport.sessionId, own.id)
           };
       }
     } catch (error51) {