@liberseek/boft-cli-win32-arm64 0.6.2 → 0.6.3

package/README.md

@@ -7,7 +7,7 @@ BOFT CLI runs Pi and other external harnesses inside Codex Desktop.
 ## Install
 
 ```bash
-npm install -g @liberseek/boft-cli@0.6.2
+npm install -g @liberseek/boft-cli@0.6.3
 ```
 
 Do not install this package directly. npm selects it through the optional dependencies of `@liberseek/boft-cli`.

package/app/codexhost-distribution.json

@@ -1 +1 @@
-{"schemaVersion":1,"version":"0.6.2","distribution":"npm","target":"windows-arm64"}
+{"schemaVersion":1,"version":"0.6.3","distribution":"npm","target":"windows-arm64"}

package/app/desktop-controller.mjs

@@ -1352,7 +1352,10 @@ ${rendererSource}`,
           "opencode",
           "grok",
           "omp",
-          "antigravity"
+          "antigravity",
+          "hermes",
+          "muse",
+          "kiro-cli"
         ],
         timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS
       },

package/app/host-runtime.mjs

@@ -19732,6 +19732,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -20667,7 +20669,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 function isRecord2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -20701,6 +20705,12 @@ function parseHostUsage(value2) {
   if (value2.totalCostUsd !== void 0 && (typeof value2.totalCostUsd !== "number" || !Number.isFinite(value2.totalCostUsd) || value2.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value2[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 percentFields) {
     const candidate = value2[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
@@ -21269,6 +21279,9 @@ var MappingStore = class {
   async setTitle(hostThreadId, title) {
     return this.#update(hostThreadId, (current) => ({ ...current, title }));
   }
+  async setCwd(hostThreadId, cwd) {
+    return this.#update(hostThreadId, (current) => current.cwd === cwd ? null : { ...current, cwd });
+  }
   async setTransportModelId(hostThreadId, transportModelId) {
     return this.#update(hostThreadId, (current) => current.transportModelId === transportModelId ? null : { ...current, transportModelId });
   }
@@ -21640,9 +21653,16 @@ function projectCodexApprovalRequest(input) {
     throw new Error("Host Approval subject is unsupported");
   }
   validateActions(interaction);
-  const allow = requiredActionForEffect(interaction, "allowOnce");
+  if (new Set(interaction.actions.map(({ effect }) => effect)).size !== interaction.actions.length) {
+    return projectApprovalChoices(input);
+  }
+  const allowOnce = optionalActionForEffect(interaction, "allowOnce");
   const allowForSession = optionalActionForEffect(interaction, "allowForSession");
   const allowAlways = optionalActionForEffect(interaction, "allowAlways");
+  const allow = allowOnce ?? allowForSession ?? allowAlways;
+  if (!allow) {
+    throw new Error("Host Approval must declare an allowOnce, allowForSession, or allowAlways action");
+  }
   const deny = requiredActionForEffect(interaction, "deny");
   const serverName = boundedText(input.serverName, "server name", SERVER_NAME_MAX_LENGTH);
   const title = clampedText(interaction.title, "title", TITLE_MAX_LENGTH);
@@ -21705,6 +21725,63 @@ function projectCodexApprovalRequest(input) {
     }
   };
 }
+function projectApprovalChoices(input) {
+  const { interaction } = input;
+  const allow = actionsForEffect(interaction, "allowOnce")[0];
+  const deny = actionsForEffect(interaction, "deny")[0];
+  if (!allow || !deny)
+    throw new Error("Host Approval must declare allowOnce and deny actions");
+  const denyResponse = { type: "approval", actionId: deny.id };
+  return {
+    request: {
+      method: "mcpServer/elicitation/request",
+      params: {
+        serverName: boundedText(input.serverName, "server name", SERVER_NAME_MAX_LENGTH),
+        threadId: input.threadId,
+        turnId: interaction.turnId,
+        mode: "form",
+        message: [
+          clampedText(interaction.title, "title", TITLE_MAX_LENGTH),
+          ...interaction.description ? [interaction.description] : []
+        ].join("\n\n"),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            actionId: {
+              type: "string",
+              title: "Approval",
+              oneOf: interaction.actions.map(({ id: id2, label }) => ({ const: id2, title: label })),
+              default: allow.id
+            }
+          },
+          required: ["actionId"]
+        }
+      }
+    },
+    denyResponse,
+    parseResponse(result) {
+      if (!isRecord3(result) || typeof result.action !== "string")
+        throw responseError("missing action");
+      if (Object.keys(result).some((key) => !["action", "content", "_meta"].includes(key))) {
+        throw responseError("contains unreviewed fields");
+      }
+      if (result._meta !== void 0 && result._meta !== null) {
+        throw responseError("contains unexpected persist metadata");
+      }
+      if (result.action === "decline" || result.action === "cancel") {
+        if (result.content !== void 0 && result.content !== null) {
+          throw responseError("contains fields incompatible with denial");
+        }
+        return denyResponse;
+      }
+      const content = result.content;
+      if (result.action !== "accept" || !isRecord3(content) || Object.keys(content).length !== 1 || !interaction.actions.some(({ id: id2 }) => id2 === content.actionId)) {
+        throw responseError("contains an undeclared approval choice");
+      }
+      return { type: "approval", actionId: content.actionId };
+    }
+  };
+}
 
 // packages/protocol-core/dist/codex-question.js
 function isRecord4(value2) {
@@ -22417,7 +22494,7 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, sen
         id: item.itemId,
         type: "agentMessage",
         text: item.text,
-        phase: null,
+        phase: item.phase ?? null,
         memoryCitation: null,
         durationMs: item.durationMs ?? null
       };
@@ -24305,6 +24382,9 @@ var ExternalThreadRepository = class {
   setTitle(hostThreadId, title) {
     return this.store.setTitle(hostThreadId, title);
   }
+  setCwd(hostThreadId, cwd) {
+    return this.store.setCwd(hostThreadId, cwd);
+  }
   setTransportModelId(hostThreadId, transportModelId) {
     return this.store.setTransportModelId(hostThreadId, transportModelId);
   }
@@ -24812,8 +24892,25 @@ var HarnessSessionImporter = class {
       return { ok: false, error: fixedError(-32081, "Session mappings could not be read") };
     }
     const existing = this.#mappedRecord(records, nativeSessionId);
-    if (existing) return importedThread(existing);
     const capability = this.#capability;
+    if (existing) {
+      if (!capability?.resolveCandidate) return importedThread(existing);
+      try {
+        const resolved = await capability.resolveCandidate(nativeSessionId);
+        if (!resolved.ok) return importedThread(existing);
+        const metadata2 = harnessSessionImportCandidateSchema.safeParse(resolved.value.candidate);
+        const ref2 = nativeSessionRefSchema.safeParse(resolved.value.nativeRef);
+        if (!metadata2.success || !ref2.success || ref2.data.harnessId !== this.#harnessId || ref2.data.nativeSessionId !== nativeSessionId || metadata2.data.nativeSessionId !== nativeSessionId || metadata2.data.cwd === existing.cwd) {
+          return importedThread(existing);
+        }
+        return importedThread(
+          await this.#repository.setCwd(existing.hostThreadId, metadata2.data.cwd)
+        );
+      } catch (error51) {
+        this.#diagnose(error51);
+        return importedThread(existing);
+      }
+    }
     if (!capability?.resolveCandidate) return { ok: false, error: this.#unavailable() };
     let source;
     try {
@@ -28013,7 +28110,11 @@ function opposite(direction) {
   return direction === "asc" ? "desc" : "asc";
 }
 function officialParams(query, cursor, limit) {
-  return { ...query.params, cursor, limit };
+  const params = { ...query.params, cursor, limit };
+  if (Array.isArray(params.modelProviders) && params.modelProviders.length === 0) {
+    delete params.modelProviders;
+  }
+  return params;
 }
 function cursorValue(input) {
   return encodeHostThreadListCursor({
@@ -31241,17 +31342,15 @@ var AppServerHost = class {
       resolve: cancellationGate.resolve
     };
     thread.responseGates.set(turnId, gate);
-    const result = await thread.session.execute({ type: "turn.cancel", turnId });
-    if (!result.ok) {
-      try {
-        await this.#writer.json(rpcError(request, -32074, result.error.message));
-      } finally {
-        gate.resolve();
-      }
-      return;
+    let response;
+    try {
+      const result = await thread.session.execute({ type: "turn.cancel", turnId });
+      response = result.ok ? rpcEnvelope(request, { result: {} }) : rpcError(request, -32074, result.error.message);
+    } catch (error51) {
+      response = rpcError(request, -32074, errorMessage3(error51));
     }
     try {
-      await this.#writer.json(rpcEnvelope(request, { result: {} }));
+      await this.#writer.json(response);
     } finally {
       gate.resolve();
     }
@@ -31551,12 +31650,14 @@ var AppServerHost = class {
         await this.#repository.setDelegationStatus(delegation.delegationId, status);
       }
     }
-    for (const message of result.messages) await this.#writer.json(message);
     if (event.type === "turn.completed") {
       await this.#setThreadStatus(
         thread,
         this.#hasRunningSubagents(thread.id) ? { type: "active", activeFlags: [] } : { type: "idle" }
       );
+    }
+    for (const message of result.messages) await this.#writer.json(message);
+    if (event.type === "turn.completed") {
       this.#externalSteering.terminal(thread.id, event.turnId, event.outcome);
     }
   }
@@ -32295,6 +32396,7 @@ import path15 from "node:path";
 var SKILL_VERSION = 5;
 var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
+  "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
   "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
   "15eb63519ff867e1536c97188a0c43738d7a49d38d4d6adeb7a1036726e7246d",
@@ -32304,12 +32406,12 @@ var CODEXHOST_DELEGATION_SKILL = `---
 name: codexhost-delegation
 version: ${SKILL_VERSION}
 description: >
-  Delegate work to another coding agent. Use when the user explicitly asks
-  Claude Code, Pi, Codex/OpenAI, OMP, Grok, another agent, or an agent mentioned
-  as @<agent> to independently review, investigate, implement, test, or verify
-  something. Do not use when the user is merely discussing, comparing, or
-  configuring agents, choosing a Model or Provider, or asking the current agent
-  to role-play as another agent.
+  Delegate tasks to other coding agents, or read and follow up on existing
+  external agent sessions. Use when the user asks another agent (including
+  @agent) to independently perform a task, or asks to view a specified external
+  session's content, progress, or results, send follow-up messages, wait, or
+  cancel a task. Not for recapping the current conversation, discussing or
+  configuring agents, or role-playing.
 ---
 
 # Execute the task
@@ -32334,9 +32436,14 @@ When the user asks for a specific Model or Thinking level, inspect the target
 Harness first and use the exact opaque IDs returned by the authoritative CLI.
 When they do not specify either setting, omit it so the target keeps its default.
 
-Create an independent child session and submit the requested task.
+For a new delegation, create an independent child session and submit the
+requested task. For an existing external session, resolve the target from the
+user-provided session link, identifier, or context and operate on that Thread
+directly; it need not have been created by the current assistant. If the target
+is ambiguous, ask the user to identify it. Keep requests to view or summarize a
+session read-only.
 
-After starting the task, choose the appropriate next action based on the
+For a new or existing task, choose the appropriate next action based on the
 user’s request and the task:
 
 - send a follow-up message to the same Thread;
@@ -32346,10 +32453,11 @@ user’s request and the task:
 - check it again later;
 - leave it running in the background.
 
-When the result is needed, explicitly read the child Thread. Report only the
+When the result is needed, explicitly read the target Thread. Report only the
 visible result returned by that Thread.
 
-Provide the user with the necessary tracking information, including:
+Provide the user with the necessary tracking information available from the
+CLI; omit unavailable fields rather than inventing them:
 
 - target agent;
 - \`delegationId\`;
@@ -35045,10 +35153,13 @@ async function runRemoteHostCli(input) {
 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_SESSION_IMPORT_PAGE_SIZE = 100;
 var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspect",
   "adapter.inspectAccount",
   "adapter.open",
+  "adapter.sessionImport.list",
+  "adapter.sessionImport.resolve",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
   "session.refreshUsage",
@@ -35204,6 +35315,27 @@ var brokerOpenInputSchema = external_exports.discriminatedUnion("kind", [
   rollbackSchema
 ]);
 var brokerInspectInputSchema = external_exports.object({ cwd: cwdSchema.optional(), refresh: external_exports.boolean().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 brokerSessionImportCandidatesSchema = external_exports.array(harnessSessionImportCandidateSchema);
+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.harnessId !== "claude-code" || source.nativeRef.nativeSessionId !== source.candidate.nativeSessionId) {
+    context.addIssue({
+      code: "custom",
+      message: "Claude 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"),
@@ -35702,6 +35834,50 @@ async function startHarnessBrokerServer(input) {
           return { ok: false, error: harnessError("Claude subagents are unavailable", false) };
         return subagents.readSnapshot(subagentReadSnapshotSchema.parse(request.params));
       }
+      if (request.method === "adapter.sessionImport.list") {
+        const { limit, offset } = brokerSessionImportListParamsSchema.parse(request.params);
+        const sessionImport = input.adapter.sessionImport;
+        if (!sessionImport?.resolveCandidate) {
+          return {
+            ok: false,
+            error: harnessError("Claude Session import is unavailable", false)
+          };
+        }
+        if (offset === 0) {
+          const result = await sessionImport.listCandidates();
+          if (!result.ok)
+            return result;
+          state.sessionImportCandidates = result.value.map((candidate) => harnessSessionImportCandidateSchema.parse(candidate));
+        }
+        const candidates = state.sessionImportCandidates;
+        if (!candidates) {
+          return {
+            ok: false,
+            error: {
+              code: "invalidState",
+              message: "Claude Session import page snapshot is unavailable",
+              retryable: true,
+              stage: "harnessBroker.sessionImport"
+            }
+          };
+        }
+        const page = candidates.slice(offset, offset + limit);
+        const total = candidates.length;
+        if (offset + page.length >= total)
+          delete state.sessionImportCandidates;
+        return { ok: true, value: { candidates: page, total } };
+      }
+      if (request.method === "adapter.sessionImport.resolve") {
+        const { nativeSessionId } = brokerSessionImportResolveParamsSchema.parse(request.params);
+        const resolveCandidate = input.adapter.sessionImport?.resolveCandidate;
+        if (!resolveCandidate) {
+          return {
+            ok: false,
+            error: harnessError("Claude Session import is unavailable", false)
+          };
+        }
+        return resolveCandidate(nativeSessionId);
+      }
       if (request.method === "adapter.open") {
         const openInput = brokerOpenInputSchema.parse(request.params);
         const sourceRef = openInput.kind === "create" ? void 0 : openInput.kind === "resume" ? openInput.nativeRef : openInput.sourceRef;

package/app/plugins/antigravity/plugin.mjs

@@ -14554,6 +14554,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15509,7 +15511,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 
 // ../../harness-discovery/dist/environment.js
@@ -19177,6 +19181,7 @@ function historySubagentState(history, id) {
   return void 0;
 }
 var AntigravityAdapter = class {
+  commandCatalog = ANTIGRAVITY_COMMAND_CATALOG;
   harnessId = antigravityHarnessId;
   subagents = {
     readSnapshot: async (input) => {