@gleapai/kai-bridge 0.9.1 → 0.10.1

package/runner/lib/acp/harnesses.mjs

@@ -11,7 +11,7 @@
 import { existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { findClaudeTranscript, findCodexRollout, readClaudeTurnUsage, readCodexTurnUsage } from "./transcripts.mjs";
+import { findClaudeTranscript, findCodexRollout, readClaudePriorCostUsd, readClaudeTurnUsage, readCodexTurnUsage } from "./transcripts.mjs";
 import { isClaudeAcpPatched } from "../../tools/patch-claude-acp.mjs";
 
 export const HARNESS_IDS = ["claude", "codex", "cursor"];
@@ -242,6 +242,14 @@ export const HARNESSES = {
         // Drops the CLI's per-run dynamic sections (cwd listing, date …)
         // so the cached prefix stays byte-stable across turns.
         excludeDynamicSections: true,
+        // Render the append fresh on every launch. Agent SDKs after 0.3.258
+        // (0.3.266 and 0.3.280 checked) record the first launch's system
+        // prompt in the transcript by default and replay it on resume,
+        // IGNORING a different `append` until compaction — a plan → build
+        // resume would keep the plan turn's guards and lose the git
+        // hand-off rule (verified live on 0.3.280: a resumed turn answered
+        // from the previous turn's project instructions).
+        snapshot: false,
       },
       claudeCode: {
         options: {
@@ -297,6 +305,12 @@ export const HARNESSES = {
     sessionModePreference: (ctx) => (ctx.isPlanMode ? ["plan"] : ctx.isArtifactWriter ? ["dontAsk", "plan"] : ["bypassPermissions", "acceptEdits", "default"]),
     /** A prior turn's transcript on disk is what makes `resume` viable. */
     hasResumableSession: (ctx) => !!findClaudeTranscript(ctx.configDir, ctx.workDir, ctx.resumeSessionId),
+    /**
+     * USD the session's earlier turns already cost, as the CLI saved it —
+     * a resumed query's cost figure continues from it (see
+     * readClaudePriorCostUsd). Read BEFORE session/resume.
+     */
+    priorTurnsCostUsd: (ctx) => readClaudePriorCostUsd({ configDir: ctx.configDir, cwd: ctx.workDir, sessionId: ctx.resumeSessionId }),
     /** Billing-grade usage for the turn from the CLI's own transcript. */
     collectTurnUsage: (ctx) =>
       readClaudeTurnUsage({

package/runner/lib/acp/mapper.mjs

@@ -24,19 +24,6 @@ import {
 const QUESTION_TOOL = "Question";
 const EXIT_PLAN_TOOL = "ExitPlanMode";
 
-/**
- * The `kai_verify` bridge's `report_verification` (tools/verify-mcp.mjs)
- * in every harness spelling: Claude `mcp__kai_verify__report_verification`,
- * Codex's server-scoped form (rebuilt from `rawInput.server/tool` by
- * toolNameFromUpdate), a bare title. Its call becomes the `verify_report`
- * contract event — never a tool row, and NOT turn-ending (the persona
- * wraps up after reporting).
- */
-export function isVerifyReportTool(name) {
-  return /(^|__|\.)report_verification$/.test(String(name || ""));
-}
-const VERIFY_REPORT_TOOL_NAME = "mcp__kai_verify__report_verification";
-
 /** Generic ACP `kind` → a readable tool label when no meta name exists. */
 const KIND_LABEL = {
   read: "Read",
@@ -60,6 +47,14 @@ export function toolNameFromUpdate(update) {
     meta.codex?.tool ??
     meta.toolName;
   if (typeof fromMeta === "string" && fromMeta) return fromMeta;
+  // ACP's own tool `name` is all that names an ExitPlanMode /
+  // AskUserQuestion PERMISSION REQUEST — claude-agent-acp sends that
+  // toolCall without `_meta.claudeCode`. Read as a generic "SwitchMode",
+  // the policy approved the plan whenever the request beat the hand-off's
+  // cancel (`exit-plan-clear-auto`, seen live on 0.81.1).
+  // Trusted for these turn-ending names only: codex-acp's generic ones
+  // (`exec_command`, `request_permissions`, …) keep the mapping below.
+  if (update?.name === EXIT_PLAN_TOOL || update?.name === "AskUserQuestion") return update.name;
   // codex-acp encodes MCP tool calls as `rawInput: {server, tool,
   // arguments}` under kind "execute" — without this they'd render as a
   // Bash row, and the ask_user question bridge would never be detected.
@@ -75,8 +70,6 @@ export function toolNameFromUpdate(update) {
   // the announce leaks a bare "Tool (running)" row that the suppressed
   // completion never clears.
   if (typeof update?.title === "string" && /todo_write/.test(update.title)) return "TodoWrite";
-  // Same for the verifier's report bridge.
-  if (typeof update?.title === "string" && /report_verification/.test(update.title)) return VERIFY_REPORT_TOOL_NAME;
   if (update?.kind && KIND_LABEL[update.kind]) return KIND_LABEL[update.kind];
   return "Tool";
 }
@@ -248,16 +241,11 @@ function contentToValue(content) {
  * the agent: a mode the adapter fails to apply must not become a free
  * pass for edits.
  */
-export function permissionPolicy({ isPlanMode = false, isArtifactWriter = false, isReadOnly = false, workDir = "" } = {}) {
+export function permissionPolicy({ isPlanMode = false, isArtifactWriter = false, workDir = "" } = {}) {
   const WRITE_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit)$/;
   const READONLY_BASH = /^\s*(cat|head|tail|wc|stat|ls|find|grep|rg|git (log|diff|show|status|ls-files|grep|rev-parse|branch)|sed -n|awk|jq|sort|uniq|cut|tr|diff|nl|basename|dirname|realpath|file|echo|pwd|which)\b/;
   const kaiDir = workDir ? `${workDir.replace(/\/+$/, "")}/.kai/` : "/.kai/";
   return (name, input) => {
-    // Read-only agents (kai-verifier) keep build-mode tool access — the
-    // browser MCP, shell probes and questions must run unprompted — but a
-    // file-write tool is never theirs. Shell leaks are caught by the
-    // post-turn revert.
-    if (isReadOnly && !isPlanMode && !isArtifactWriter) return !WRITE_TOOLS.test(canonicalToolName(name));
     if (!isPlanMode && !isArtifactWriter) return true;
     const canonical = canonicalToolName(name);
     if (WRITE_TOOLS.test(canonical)) {
@@ -342,16 +330,6 @@ export function createAcpMapper({ emit, isPlanMode = false, onTurnShouldEnd, onC
       }
       return;
     }
-    if (isVerifyReportTool(meta.name)) {
-      // One `verify_report` per call, on completion only — the announce
-      // (input still streaming) and the completed update would otherwise
-      // hand the host two reports for one filing. Local artifact paths
-      // ride in `report`; the host uploads them and rewrites to URLs.
-      if (status !== "running" && meta.input && typeof meta.input === "object" && !Array.isArray(meta.input)) {
-        emit({ type: "verify_report", message: "Verification report filed", report: sanitizeToolValue(meta.input, 4000) });
-      }
-      return;
-    }
     // Adapter-provided titles ("List files in 'src'") stand in when the
     // input carries nothing summarizeTool understands.
     const summary = summarizeTool(name, meta.input || {}) || meta.title || "";
@@ -594,6 +572,10 @@ export function createAcpMapper({ emit, isPlanMode = false, onTurnShouldEnd, onC
         return pick("reject_once") ?? pick("reject_always") ?? "__reject__";
       }
       if (handleTurnEndingTool(name, input)) return null;
+      // A question / plan hand-off without a usable payload is still never
+      // approved: allowing ExitPlanMode would start the build inside the
+      // plan turn. Cancelling denies just this call.
+      if (isTurnEndingTool(name)) return null;
       if (!allowTool(name, input)) {
         emit({
           type: "tool_status",

package/runner/lib/acp/transcripts.mjs

@@ -148,6 +148,47 @@ export function readClaudeTurnUsage({ configDir, cwd, sessionId, sinceTs }) {
   return { path, rows: parseClaudeTranscript(readFileSync(path, "utf8"), { sinceTs }) };
 }
 
+/**
+ * The session's cumulative USD as Claude Code saved it: the LAST
+ * `{"type":"cost-state","totalCostUSD":…}` line (written after each turn
+ * by CLI 2.1.280; absent from older transcripts). 0 when there is none.
+ */
+export function lastClaudeCostState(text) {
+  let total = 0;
+  for (const line of String(text || "").split(/\r?\n/)) {
+    if (!line.includes('"cost-state"')) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (obj?.type === "cost-state" && typeof obj.totalCostUSD === "number" && Number.isFinite(obj.totalCostUSD)) {
+      total = Math.max(0, obj.totalCostUSD);
+    }
+  }
+  return total;
+}
+
+/**
+ * What the session's earlier turns already cost. A resumed query's
+ * `total_cost_usd` — the adapter's `usage_update.cost` — "continues from
+ * the total its transcript saved" (Agent SDK 0.3.280; 0.3.258 started
+ * resumed sessions at 0), so without subtracting this every resumed turn
+ * reports the whole conversation's cost. Must be read BEFORE the resume:
+ * the turn appends its own record.
+ */
+export function readClaudePriorCostUsd({ configDir, cwd, sessionId }) {
+  if (!sessionId) return 0;
+  const path = findClaudeTranscript(configDir, cwd, sessionId);
+  if (!path) return 0;
+  try {
+    return lastClaudeCostState(readFileSync(path, "utf8"));
+  } catch {
+    return 0;
+  }
+}
+
 // ── Codex ──────────────────────────────────────────────────────────────
 
 /**

package/runner/lib/contract.mjs

@@ -64,9 +64,6 @@ export function decodeB64Json(value, fallback) {
 export const KAI_PLANNER_AGENT_NAME = "kai-planner";
 export const KAI_BUILDER_AGENT_NAME = "kai";
 export const KAI_RESOLUTION_ANALYST_AGENT_NAME = "kai-resolution-analyst";
-// Kai Code "Verify": drives the running preview with the browser tools,
-// records evidence, files a `report_verification`. Read-only by contract.
-export const KAI_VERIFIER_AGENT_NAME = "kai-verifier";
 
 export function normalizeAgentName(raw) {
   const value = typeof raw === "string" ? raw : "";
@@ -121,18 +118,6 @@ export function isArtifactWriterAgent(agentName) {
   return ARTIFACT_WRITER_AGENT_NAMES.includes(agentName);
 }
 
-// Read-only agents produce NO files at all — not even `.kai/` artifacts.
-// The verifier's output is the `report_verification` tool call plus the
-// browser recordings the Playwright MCP writes OUTSIDE the workspace
-// (the host's artifacts dir). They run with build-mode tool access (the
-// browser MCP + questions must work unprompted), so `revertRepoMutations`
-// is what guarantees the repos come out exactly as they went in.
-export const READ_ONLY_AGENT_NAMES = [KAI_VERIFIER_AGENT_NAME];
-
-export function isReadOnlyAgent(agentName) {
-  return READ_ONLY_AGENT_NAMES.includes(agentName);
-}
-
 function findWorkspaceRepos(workDir) {
   const repos = [];
   if (existsSync(join(workDir, ".git"))) {
@@ -356,7 +341,7 @@ const SUPPORTED_FILE_PART_MIMES = new Set(["application/pdf"]);
  * flags are optional except `--task-b64`; callers fail fast on an
  * empty `task` themselves (the error message differs per runner).
  *
- *   --agent <name>                       kai | kai-planner | kai-verifier | kai-documentarian | …
+ *   --agent <name>                       kai | kai-planner | kai-documentarian | …
  *   --model <provider/modelID>           canonical registry id
  *   --engine-model <slug>                engine-native model slug (claude/codex wire form)
  *   --subagent-model <provider/modelID>  cheaper sibling for explorer subagents

package/runner/tools/patch-claude-acp.mjs

@@ -3,7 +3,7 @@
 // `prompt_suggestion` message (the predicted next user prompt Claude
 // Code shows as ghost text in its own composer) reaches the runner.
 //
-// Upstream (≤ 0.75.1) drops the message on the floor — `case
+// Upstream (≤ 0.81.1) drops the message on the floor — `case
 // "prompt_suggestion": break;` — because ACP has no update kind for it.
 // We forward it as a `session_info_update` carrying `_meta.kai
 // .promptSuggestion` (ACP's sanctioned extension point; the SDK's

package/scripts/postinstall.mjs

@@ -16,6 +16,13 @@ try {
 } catch {
   // The daemon retries on start; a missing patch only means no suggestions.
 }
+// Raise the browser MCP's 30 s per-call default (see src/playwright-patch.mjs).
+try {
+  const { ensurePlaywrightTimeoutPatched } = await import("../src/playwright-patch.mjs");
+  ensurePlaywrightTimeoutPatched();
+} catch {
+  // The daemon retries on start.
+}
 try {
   const interactive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
   const isGlobal = process.env.npm_config_global === "true";

package/src/api.mjs

@@ -6,18 +6,18 @@
 //   POST   /gleapcode/bridge/devices/me/heartbeat  { running: [turnIds] }
 //   POST   /gleapcode/bridge/turns/:id/events      { events: [contract lines] }
 //   POST   /gleapcode/bridge/turns/:id/result      { result, changes, status }
-//   POST   /gleapcode/bridge/turns/:id/artifacts   multipart `file`            → { url }   (verify evidence)
-//   POST   /gleapcode/bridge/turns/:id/verification{ status, scope, reason, checks, untested, artifacts, evidence?, revisions? }
-//   PUT    /gleapcode/bridge/turns/:id/verification/artifacts { artifacts, evidence }   (evidence retry — union by URL, clears evidenceMissing)
-//   POST   /gleapcode/bridge/turns/:id/verification/stage { stage, note? }   (setup|booting|login|verifying|fixing|saving)
-//   GET    /gleapcode/bridge/turns/:id/preview-login → the saved sign-in record for this verify turn (one GET per turn)
-//   POST   /gleapcode/bridge/preview-logins/:requestId          { storageState, origins, services, landingUrl, loginPaths }  (capture upload)
-//   POST   /gleapcode/bridge/preview-logins/:requestId/status   { status: opened|waiting_signin|detected|failed|cancelled, error? }
-//   PUT    /gleapcode/bridge/preview-logins/:id                 { storageState, basedOnVersion } → 409 on a stale version
+//   POST   /gleapcode/bridge/devices/me/public-hosts { sessionId, services } → { domain, hosts, tunnel, displaced }
 //   POST   /users/me/pusher                        { socket_id, channel_name }   (channel auth)
 
-import { readFile } from "node:fs/promises";
-import { basename } from "node:path";
+/**
+ * The human-readable part of a Server error body. `statusOr500` answers
+ * `{ ok: false, message }`; the global handler answers `{ error: { message,
+ * details } }` — reading `error` itself printed "[object Object]".
+ */
+export function errorMessage(data, text = "") {
+  const pick = (v) => (typeof v === "string" && v ? v : null);
+  return pick(data?.message) ?? pick(data?.error?.message) ?? pick(data?.error) ?? pick(text.slice(0, 200)) ?? "no error body";
+}
 
 export class BridgeApi {
   constructor({ apiBase, token, fetchImpl = fetch }) {
@@ -51,7 +51,7 @@ export class BridgeApi {
       data = { raw: text };
     }
     if (!res.ok) {
-      const err = new Error(`${method} ${path} → ${res.status}: ${data?.message ?? data?.error ?? text.slice(0, 200)}`);
+      const err = new Error(`${method} ${path} → ${res.status}: ${errorMessage(data, text)}`);
       err.status = res.status;
       err.data = data;
       throw err;
@@ -116,97 +116,7 @@ export class BridgeApi {
     );
   }
 
-  /**
-   * Upload one verify artifact (recording / screenshot / trace) as
-   * multipart `file`; resolves the Server's `{ url }`. Separate from the
-   * JSON-only `request()`: the body is a FormData (fetch sets the boundary
-   * header itself — never set content-type here), a video can take a
-   * while (5-min cap), and it retries transient failures 3× — a dropped
-   * screenshot is missing evidence, not a broken turn.
-   */
-  async uploadArtifact(turnId, filePath, contentType, { tries = 3, timeoutMs = 5 * 60_000, onRetry } = {}) {
-    const bytes = await readFile(filePath);
-    const path = `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/artifacts`;
-    let delay = 1_000;
-    for (let attempt = 1; ; attempt += 1) {
-      try {
-        const form = new FormData();
-        form.append("file", new Blob([bytes], { type: contentType }), basename(filePath));
-        const res = await this.fetch(`${this.apiBase}${path}`, {
-          method: "POST",
-          headers: { ...(this.token ? { authorization: `Bearer ${this.token}` } : {}) },
-          body: form,
-          signal: AbortSignal.timeout(timeoutMs),
-        });
-        const text = await res.text();
-        let data = null;
-        try {
-          data = text ? JSON.parse(text) : null;
-        } catch {
-          data = { raw: text };
-        }
-        if (!res.ok) {
-          const err = new Error(`POST ${path} → ${res.status}: ${data?.message ?? data?.error ?? text.slice(0, 200)}`);
-          err.status = res.status;
-          err.data = data;
-          throw err;
-        }
-        if (typeof data?.url !== "string" || !data.url) throw new Error(`POST ${path} → no url in response`);
-        return data;
-      } catch (err) {
-        const permanent = err.status >= 400 && err.status < 500 && err.status !== 429;
-        if (permanent || attempt >= tries) throw err;
-        onRetry?.(err, attempt, delay);
-        await new Promise((r) => setTimeout(r, delay));
-        delay = Math.min(delay * 2, 30_000);
-      }
-    }
-  }
-
-  /** The verification report for a verify turn (artifacts already uploaded → URLs). */
-  turnVerification(turnId, payload, opts) {
-    return this.requestWithRetry("POST", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/verification`, payload, opts);
-  }
-
-  /** Late evidence (`bridge.verify.evidence.retry`): the Server unions by URL and clears `evidenceMissing`. */
-  putVerificationArtifacts(turnId, payload, opts) {
-    return this.requestWithRetry("PUT", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/verification/artifacts`, payload, opts);
-  }
-
-  /** Stage transition of a running verify turn (best-effort UI state — callers swallow errors). */
-  turnVerificationStage(turnId, payload) {
-    return this.request("POST", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/verification/stage`, payload);
-  }
-  /**
-   * The saved sign-in for this verify turn: `{ id, version, storageState,
-   * origins, services, landingUrl, loginPaths, optional }` (or `null` —
-   * a 404 is "no record", not an error). The Server allows ONE successful
-   * GET per turn and never caches it.
-   */
-  async turnPreviewLogin(turnId) {
-    try {
-      const data = await this.request("GET", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/preview-login`);
-      const record = data && typeof data === "object" && "record" in data ? data.record : data;
-      return record && typeof record === "object" && record.storageState ? record : null;
-    } catch (err) {
-      if (err?.status === 404) return null;
-      throw err;
-    }
-  }
-  /** Capture upload against a pending login request (the ONLY thing a device may upload a sign-in against). */
-  uploadPreviewLogin(requestId, payload, opts) {
-    return this.requestWithRetry("POST", `/gleapcode/bridge/preview-logins/${encodeURIComponent(requestId)}`, payload, opts);
-  }
-  /** Capture progress for the dashboard's sign-in card. */
-  previewLoginStatus(requestId, payload) {
-    return this.request("POST", `/gleapcode/bridge/preview-logins/${encodeURIComponent(requestId)}/status`, payload);
-  }
-  /** Refresh a record after a verify run (CAS on `basedOnVersion`; 409 = someone else refreshed first → discard). */
-  refreshPreviewLogin(recordId, payload) {
-    return this.request("PUT", `/gleapcode/bridge/preview-logins/${encodeURIComponent(recordId)}`, payload);
-  }
-
-  /** Turns (and pending sign-in requests) the server still believes this device is running. */
+  /** Turns the server still believes this device is running. */
   pendingTurns() {
     return this.request("GET", "/gleapcode/bridge/devices/me/pending");
   }
@@ -217,6 +127,10 @@ export class BridgeApi {
   gitCredentials(repoKey) {
     return this.request("POST", "/gleapcode/bridge/devices/me/git-credentials", { repoKey });
   }
+  /** Public hostnames + tunnel credentials for a session being published (the Server decides displacement). */
+  publicHosts(payload) {
+    return this.request("POST", "/gleapcode/bridge/devices/me/public-hosts", payload);
+  }
 
   commandAck(commandId, payload) {
     return this.request("POST", `/gleapcode/bridge/commands/${encodeURIComponent(commandId)}/ack`, payload);

package/src/companions.mjs

@@ -69,7 +69,7 @@ export function orderCompanions(entries) {
  * repo required by any config is required overall; depth is capped at
  * `maxDepth`; a visited set keeps cycles harmless.
  */
-export async function collectCompanions({ roots, loadConfig, maxDepth = 3 } = {}) {
+export async function collectCompanions({ roots, loadConfig, maxDepth = 3, extra = [] } = {}) {
   const sessionKeys = new Set((roots || []).map((r) => String(r.key).toLowerCase()));
   const seen = new Map(); // key → entry
   let queue = (roots || []).map((r) => ({ key: String(r.key).toLowerCase(), config: r.config, depth: 0 }));
@@ -77,7 +77,8 @@ export async function collectCompanions({ roots, loadConfig, maxDepth = 3 } = {}
   for (let depth = 1; depth <= maxDepth && queue.length > 0; depth += 1) {
     const next = [];
     for (const node of queue) {
-      for (const c of node.config?.companions || []) {
+      // `extra`: companions the daemon inferred (reverse companions) count as declared by the session repos.
+      for (const c of [...(node.config?.companions || []), ...(node.depth === 0 ? extra : [])]) {
         const key = String(c.repo).toLowerCase();
         if (sessionKeys.has(key)) continue; // already part of the session
         const prev = seen.get(key);