@liberseek/boft-cli-win32-arm64 0.6.4 → 0.6.5

package/app/plugins/deepseek-harness/plugin.mjs

@@ -19248,6 +19248,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    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`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -30826,6 +30832,7 @@ var LiveBuffer = class {
 import { randomUUID as nodeRandomUUID } from "node:crypto";
 import { isDeepStrictEqual as isDeepStrictEqual5 } from "node:util";
 var DEEPSEEK_HARNESS_ID2 = harnessIdSchema.parse("deepseek-harness");
+var NATIVE_CLOSE_TIMEOUT_MS = 5e3;
 var MODERN_PROMPT_CORRELATION_GRACE_MS = 5e3;
 var MODERN_ACCEPTED_CORRELATION_TIMEOUT_MS = 3e5;
 var MAX_TIMER_DELAY_MS2 = 2147483647;
@@ -30905,8 +30912,11 @@ var ModernHarnessSession = class {
   #usage;
   #historyBytes;
   #closed = false;
+  #closing = false;
+  #nativeCloseTerminal;
   #closedNotified = false;
   #faulted;
+  #faultMayHaveNativeWork = false;
   #closePromise;
   #pumpPromise;
   constructor(options) {
@@ -30999,14 +31009,14 @@ var ModernHarnessSession = class {
     this.#pumpPromise = this.#pump();
     if (resumedAutonomousBuffer) {
       queueMicrotask(() => {
-        if (!this.#closed && this.#buffer === resumedAutonomousBuffer) {
+        if (!this.#closed && !this.#closing && this.#buffer === resumedAutonomousBuffer) {
           this.#activateBufferedAutonomous(true);
         }
       });
     }
   }
   readSnapshot() {
-    if (this.#closed)
+    if (this.#closed || this.#closing)
       return Promise.resolve({ ok: false, error: closedError() });
     if (this.#reading)
       return Promise.resolve({ ok: false, error: busyError("read history") });
@@ -31028,7 +31038,7 @@ var ModernHarnessSession = class {
     }
   }
   execute(command) {
-    if (this.#closed)
+    if (this.#closed || this.#closing)
       return Promise.resolve({ ok: false, error: closedError() });
     switch (command.type) {
       case "turn.start":
@@ -31046,6 +31056,13 @@ var ModernHarnessSession = class {
     }
   }
   close() {
+    const faultCleanup = this.#closePromise;
+    if (this.#faultMayHaveNativeWork && !this.#closing && faultCleanup) {
+      this.#closing = true;
+      this.#closePromise = faultCleanup.then(() => {
+        throw new Error("DeepSeek Harness native execution stop was not confirmed before the Session fault");
+      });
+    }
     this.#closePromise ??= this.#performClose();
     return this.#closePromise;
   }
@@ -31060,7 +31077,7 @@ var ModernHarnessSession = class {
     if (this.#queuedDeliveries.has(delivery.eventId) || this.#interactionByEventId.has(delivery.eventId)) {
       throw new ModernEventGatewayError("protocolError", "DeepSeek Harness event delivery was duplicated");
     }
-    if (this.#closed) {
+    if (this.#closed || this.#closing) {
       this.#queuedDeliveries.set(delivery.eventId, delivery);
       return;
     }
@@ -31329,14 +31346,14 @@ ${question.detail}` : question.question;
     this.#operationControllers.add(abort);
     try {
       const result = await operation(abort.signal);
-      if (this.#closed)
+      if (this.#closed || this.#closing)
         return { ok: false, error: closedError() };
       this.#publishConfiguration(true);
       return { ok: true, value: result.value };
     } catch (error51) {
       if (this.#faulted)
         return { ok: false, error: this.#faulted };
-      if (this.#closed)
+      if (this.#closed || this.#closing)
         return { ok: false, error: closedError() };
       const failure = configurationOrProtocolError(error51, "DeepSeek Harness configuration failed");
       if (configurationFailureRequiresSessionFault(error51))
@@ -31448,7 +31465,7 @@ ${question.detail}` : question.question;
     } catch (error51) {
       if (this.#faulted)
         return { ok: false, error: this.#faulted };
-      if (this.#closed)
+      if (this.#closed || this.#closing)
         return { ok: false, error: closedError() };
       if (pending.admissionObserved)
         return this.#acceptPrompt(pending);
@@ -31456,7 +31473,7 @@ ${question.detail}` : question.question;
       if (resolution.kind === "accepted") {
         if (this.#faulted)
           return { ok: false, error: this.#faulted };
-        if (this.#closed)
+        if (this.#closed || this.#closing)
           return { ok: false, error: closedError() };
         return this.#acceptPrompt(pending);
       }
@@ -31524,12 +31541,12 @@ ${question.detail}` : question.question;
     return true;
   }
   async #listHarnessCommands() {
-    if (this.#closed)
+    if (this.#closed || this.#closing)
       return { ok: false, error: closedError() };
     return { ok: true, value: deepSeekHarnessCommandCatalog() };
   }
   async #executeHarnessCommand(command) {
-    if (this.#closed)
+    if (this.#closed || this.#closing)
       return { ok: false, error: closedError() };
     const parsed = parseDeepSeekHarnessCommand(command);
     if (!parsed.ok)
@@ -31549,7 +31566,7 @@ ${question.detail}` : question.question;
       const catalog = await this.#listHarnessCommands();
       if (!catalog.ok)
         return catalog;
-      if (this.#closed)
+      if (this.#closed || this.#closing)
         return { ok: false, error: closedError() };
       if (admission.cancellationRequested) {
         return { ok: false, error: invalidState3("DeepSeek Harness command was cancelled") };
@@ -31911,13 +31928,13 @@ ${question.detail}` : question.question;
   }
   #scheduleBoundTurn(pending) {
     const buffer = pending.buffer;
-    if (!buffer || !pending.admitted || pending.publishScheduled || buffer.active || this.#closed) {
+    if (!buffer || !pending.admitted || pending.publishScheduled || buffer.active || this.#closed || this.#closing) {
       return;
     }
     pending.publishScheduled = true;
     queueMicrotask(() => queueMicrotask(() => {
       pending.publishScheduled = false;
-      if (!this.#closed && pending.admitted && pending.buffer === buffer && this.#buffer === buffer && !buffer.active) {
+      if (!this.#closed && !this.#closing && pending.admitted && pending.buffer === buffer && this.#buffer === buffer && !buffer.active) {
         this.#materialize(buffer, pending.command.turnId, textInputs2(pending.command.input), false, false);
       }
     }));
@@ -31933,7 +31950,7 @@ ${question.detail}` : question.question;
       delete pending.buffer;
       if (buffer.reachedCorrelationBoundary || buffer.events.at(-1)?.type === "turn/end") {
         queueMicrotask(() => {
-          if (!this.#closed && this.#buffer === buffer && !buffer.active && !buffer.pending) {
+          if (!this.#closed && !this.#closing && this.#buffer === buffer && !buffer.active && !buffer.pending) {
             this.#materializeAutonomous(buffer, false);
           }
         });
@@ -31948,12 +31965,14 @@ ${question.detail}` : question.question;
   }
   #activateBufferedAutonomous(initialReplay = false) {
     const buffer = this.#buffer;
-    if (this.#closed || !buffer || buffer.active || buffer.pending || this.#deferAutonomousTurn() || !this.#resumeNeedsAutonomousTurn(buffer) && !buffer.reachedCorrelationBoundary && buffer.events.at(-1)?.type !== "turn/end") {
+    if (this.#closed || this.#closing || !buffer || buffer.active || buffer.pending || this.#deferAutonomousTurn() || !this.#resumeNeedsAutonomousTurn(buffer) && !buffer.reachedCorrelationBoundary && buffer.events.at(-1)?.type !== "turn/end") {
       return;
     }
     this.#materializeAutonomous(buffer, initialReplay || buffer.initialResume);
   }
   #materializeAutonomous(buffer, initialReplay) {
+    if (this.#closed || this.#closing)
+      return;
     const turnId = hostTurnIdSchema.parse(this.#randomUUID());
     this.#emit({
       type: "turn.autonomous.started",
@@ -32222,6 +32241,7 @@ ${question.detail}` : question.question;
     active.terminal = true;
     if (buffer.pending)
       buffer.pending.terminal = true;
+    this.#nativeCloseTerminal?.();
     const checkpoint = modernCheckpointRef(this.harnessId, this.#sessionId, seq);
     this.#emit({
       type: "turn.completed",
@@ -32283,6 +32303,7 @@ ${question.detail}` : question.question;
       return;
     const failure = sanitizedHarnessError(error51);
     const acceptedPending = this.#acceptedPending();
+    this.#faultMayHaveNativeWork = Boolean(this.#active && !this.#active.terminal || this.#pendingByRequestId.size > 0 || this.#buffer || this.#commandAdmission || this.#activeCommand);
     this.#faulted = failure;
     this.#closed = true;
     this.#journalLifetime.abort(new Error("DeepSeek Harness Session faulted"));
@@ -32356,6 +32377,49 @@ ${question.detail}` : question.question;
     this.#notifyClosed();
   }
   async #performClose() {
+    this.#closing = true;
+    let stopFailure;
+    const activeAtClose = this.#active;
+    const pendingAtClose = new Set(this.#pendingByRequestId.values());
+    if (this.#buffer?.pending)
+      pendingAtClose.add(this.#buffer.pending);
+    const correlatedPending = activeAtClose && this.#buffer?.active === activeAtClose ? this.#buffer.pending : void 0;
+    const uncorrelatedExecution = [...pendingAtClose].some((pending) => !pending.terminal && pending !== correlatedPending) || !activeAtClose && this.#buffer !== void 0 || this.#commandAdmission !== void 0 || this.#activeCommand !== void 0;
+    if (!this.#closed && (activeAtClose && !activeAtClose.terminal || uncorrelatedExecution)) {
+      let timer;
+      const terminal = new Promise((resolve2) => {
+        this.#nativeCloseTerminal = () => {
+          if (activeAtClose?.terminal)
+            resolve2();
+        };
+      });
+      try {
+        await Promise.race([
+          (async () => {
+            const result = await (activeAtClose?.cancelPromise ?? this.#requestNativeCancel(activeAtClose));
+            if (!result.ok)
+              throw new Error(result.error.message);
+            if (uncorrelatedExecution) {
+              throw new Error("DeepSeek Harness cannot confirm stop before the native Turn is correlated");
+            }
+            await terminal;
+          })(),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("DeepSeek Harness did not confirm native Turn stop before close")), NATIVE_CLOSE_TIMEOUT_MS);
+          })
+        ]);
+      } catch (error51) {
+        stopFailure = error51;
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+        this.#nativeCloseTerminal = void 0;
+      }
+    }
+    if (this.#faulted) {
+      await this.#performFault(this.#faulted, this.#acceptedPending(pendingAtClose));
+      throw stopFailure ?? new Error(this.#faulted.message);
+    }
     if (!this.#closed) {
       const acceptedPending = this.#acceptedPending();
       this.#closed = true;
@@ -32410,6 +32474,8 @@ ${question.detail}` : question.question;
     }
     await Promise.allSettled([this.#journal.close(), this.#pumpPromise]);
     this.#notifyClosed();
+    if (stopFailure)
+      throw stopFailure;
   }
   #abortOperations() {
     for (const controller of this.#operationControllers) {
@@ -32422,8 +32488,7 @@ ${question.detail}` : question.question;
     for (const unsubscribe of this.#removeControlSubscriptions.splice(0))
       unsubscribe();
   }
-  #acceptedPending() {
-    const values = new Set(this.#pendingByRequestId.values());
+  #acceptedPending(values = new Set(this.#pendingByRequestId.values())) {
     if (this.#buffer?.pending)
       values.add(this.#buffer.pending);
     return [...values].filter((pending) => (pending.admitted || pending.admissionObserved || pending.observed) && !pending.terminal);

package/app/plugins/grok/plugin.mjs

@@ -19685,6 +19685,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    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`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {

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

@@ -15524,6 +15524,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    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`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -20155,12 +20161,14 @@ function classifyStartupError(error51) {
   }
   return new KiroTransportError("unavailable", "Kiro CLI could not start", { cause: error51 });
 }
+var KiroRequestTimeoutError = class extends KiroTransportError {
+};
 function withTimeout(promise2, milliseconds, operation) {
   let timeout;
   return Promise.race([
     promise2,
     new Promise((_resolve, reject) => {
-      timeout = setTimeout(() => reject(new KiroTransportError("unavailable", `${operation} timed out`)), milliseconds);
+      timeout = setTimeout(() => reject(new KiroRequestTimeoutError("unavailable", `${operation} timed out`)), milliseconds);
     })
   ]).finally(() => {
     if (timeout)
@@ -20205,6 +20213,7 @@ var KiroAcpTransport = class {
   #replay = null;
   #sessionId = null;
   #stderrTail = "";
+  #configUpdates = /* @__PURE__ */ new Set();
   constructor(options) {
     this.#options = options;
     this.#commandTimeoutMs = options.commandTimeoutMs ?? 3e4;
@@ -20363,17 +20372,38 @@ var KiroAcpTransport = class {
     };
   }
   async #setConfigOptionOnSession(connection, sessionId, configId, value) {
+    const confirmation = Promise.withResolvers();
+    const listener = {
+      update: (params) => {
+        if (params.sessionId !== sessionId || params.update.sessionUpdate !== "config_option_update")
+          return;
+        try {
+          confirmation.resolve(confirmedKiroConfig(params.update, configId, value));
+        } catch {
+        }
+      },
+      cancel: () => confirmation.reject(new KiroTransportError("unavailable", "Kiro Session closed during configuration"))
+    };
+    void confirmation.promise.catch(() => void 0);
+    this.#configUpdates.add(listener);
     try {
-      const result = await withTimeout(connection.setSessionConfigOption({
-        sessionId,
-        configId,
-        value
-      }), this.#commandTimeoutMs, `Kiro set_config_option (${configId})`);
-      return confirmedKiroConfig(result, configId, value);
+      return await withTimeout((async () => {
+        const result = await connection.setSessionConfigOption({ sessionId, configId, value });
+        if (configId === "model" && Array.isArray(result.configOptions) && !result.configOptions.some((option) => option.id === "model")) {
+          return confirmation.promise;
+        }
+        return confirmedKiroConfig(result, configId, value);
+      })(), this.#commandTimeoutMs, `Kiro set_config_option (${configId})`);
     } catch (error51) {
+      if (error51 instanceof KiroRequestTimeoutError) {
+        this.#fault(error51);
+        await this.close().catch(() => void 0);
+      }
       throw new KiroTransportError("unavailable", `Failed to set ${configId} config option`, {
         cause: error51
       });
+    } finally {
+      this.#configUpdates.delete(listener);
     }
   }
   async #forkSession(params) {
@@ -20524,6 +20554,8 @@ var KiroAcpTransport = class {
     return initialize;
   }
   #handleUpdate(params) {
+    for (const listener of this.#configUpdates)
+      listener.update(params);
     const update = params.update;
     const meta3 = isRecord4(update) && isRecord4(update._meta) ? update._meta : void 0;
     const kiroMeta = meta3 && isRecord4(meta3.kiro) ? meta3.kiro : void 0;
@@ -20626,6 +20658,9 @@ var KiroAcpTransport = class {
       return;
     this.#closed = true;
     this.#closing = true;
+    for (const listener of this.#configUpdates)
+      listener.cancel();
+    this.#configUpdates.clear();
     try {
       if (this.#child) {
         const child = this.#child;
@@ -22579,7 +22614,7 @@ var KiroSession = class {
   #currentPermissionModeId;
   #thinking;
   #modelCatalog;
-  #pendingInteraction = null;
+  #pendingInteractions = /* @__PURE__ */ new Map();
   #closed = false;
   #activeTask = null;
   #stopTurn = null;
@@ -22825,48 +22860,42 @@ var KiroSession = class {
             const question = projectKiroRequirementQuestion(interactionId, turnId, request);
             if (question) {
               return new Promise((resolve) => {
-                this.#pendingInteraction = {
+                this.#pendingInteractions.set(question.interaction.interactionId, {
                   type: "question",
                   id: question.interaction.interactionId,
                   interaction: question.interaction,
                   resolve: (response) => resolve(question.resolve(response))
-                };
+                });
                 this.#channel.emit({ kind: "interaction", interaction: question.interaction });
               });
             }
             const projected = projectKiroPermission(interactionId, turnId, request);
-            this.#channel.emit({
-              kind: "interaction",
-              interaction: projected.interaction
-            });
             return new Promise((resolve) => {
-              this.#pendingInteraction = {
+              this.#pendingInteractions.set(projected.interaction.interactionId, {
                 type: "approval",
                 id: projected.interaction.interactionId,
                 interaction: projected.interaction,
                 resolve: (actionId, cancelled) => {
                   resolve(projected.resolve(actionId, cancelled));
                 }
-              };
+              });
+              this.#channel.emit({ kind: "interaction", interaction: projected.interaction });
             });
           }, async (params) => {
             if (this.#closed || this.#activeTurnId !== turnId)
               return { action: "dismissed" };
             const interactionId = this.#randomUUID();
             const projected = projectKiroUserInput(interactionId, turnId, params);
-            this.#channel.emit({
-              kind: "interaction",
-              interaction: projected.interaction
-            });
             return new Promise((resolve) => {
-              this.#pendingInteraction = {
+              this.#pendingInteractions.set(projected.interaction.interactionId, {
                 type: "question",
                 id: projected.interaction.interactionId,
                 interaction: projected.interaction,
                 resolve: (response) => {
                   resolve(projected.resolve(response));
                 }
-              };
+              });
+              this.#channel.emit({ kind: "interaction", interaction: projected.interaction });
             });
           })
         ]);
@@ -22885,23 +22914,7 @@ var KiroSession = class {
           }
         };
       } finally {
-        if (this.#pendingInteraction) {
-          const pending = this.#pendingInteraction;
-          this.#pendingInteraction = null;
-          if (pending.type === "approval")
-            pending.resolve("", true);
-          else
-            pending.resolve({ type: "question", cancelled: true, answers: {} });
-          this.#channel.emit({
-            kind: "event",
-            event: {
-              type: "interaction.closed",
-              interactionId: pending.id,
-              turnId,
-              reason: "cancelled"
-            }
-          });
-        }
+        this.#cancelInteractions(turnId);
         output.finish(turnOutcome);
         const nativeTurnRef = assignedUserMessageId ? nativeTurnRefSchema.parse({
           harnessId: this.harnessId,
@@ -22929,29 +22942,33 @@ var KiroSession = class {
   async #cancelTurn(command) {
     if (this.#activeTurnId !== null && this.#activeTurnId === command.turnId) {
       await this.#transport.cancel();
-      if (this.#pendingInteraction) {
-        const pending = this.#pendingInteraction;
-        this.#pendingInteraction = null;
-        if (pending.type === "approval") {
-          pending.resolve("", true);
-        } else {
-          pending.resolve({ type: "question", cancelled: true, answers: {} });
-        }
-        this.#channel.emit({
-          kind: "event",
-          event: {
-            type: "interaction.closed",
-            interactionId: pending.id,
-            turnId: command.turnId,
-            reason: "cancelled"
-          }
-        });
-      }
+      if (this.#activeTurnId === command.turnId)
+        this.#cancelInteractions(command.turnId);
     }
     return { ok: true, value: { cancellationRequested: true } };
   }
+  #cancelInteractions(turnId) {
+    const interactions = [...this.#pendingInteractions.values()];
+    this.#pendingInteractions.clear();
+    for (const pending of interactions) {
+      if (pending.type === "approval")
+        pending.resolve("", true);
+      else
+        pending.resolve({ type: "question", cancelled: true, answers: {} });
+      this.#channel.emit({
+        kind: "event",
+        event: {
+          type: "interaction.closed",
+          interactionId: pending.id,
+          turnId,
+          reason: "cancelled"
+        }
+      });
+    }
+  }
   async #respondInteraction(command) {
-    if (!this.#pendingInteraction || this.#pendingInteraction.id !== command.interactionId) {
+    const pending = this.#pendingInteractions.get(command.interactionId);
+    if (!pending) {
       return {
         ok: false,
         error: {
@@ -22961,7 +22978,6 @@ var KiroSession = class {
         }
       };
     }
-    const pending = this.#pendingInteraction;
     if (pending.type === "approval") {
       if (command.response.type !== "approval") {
         return {
@@ -22976,7 +22992,7 @@ var KiroSession = class {
       const error51 = validateHostApprovalResponse(pending.interaction, command.response);
       if (error51)
         return { ok: false, error: error51 };
-      this.#pendingInteraction = null;
+      this.#pendingInteractions.delete(command.interactionId);
       pending.resolve(command.response.actionId);
     } else {
       if (command.response.type !== "question") {
@@ -22992,7 +23008,7 @@ var KiroSession = class {
       const error51 = validateHostQuestionResponse(pending.interaction, command.response);
       if (error51)
         return { ok: false, error: error51 };
-      this.#pendingInteraction = null;
+      this.#pendingInteractions.delete(command.interactionId);
       pending.resolve(command.response);
     }
     if (this.#activeTurnId) {

package/app/plugins/omp/plugin.mjs

@@ -16044,6 +16044,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    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`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {