@cognisphere-sh/cognisphere-harness 0.12.0 → 0.13.0

package/src/core/models-catalog.ts

@@ -10,21 +10,21 @@ import type { CredField, ProviderCatalogEntry } from "./types.js";
  * can be appended via the UI.
  *
  * OAuth subscription auth: entries with `oauth: true` (Anthropic
- * Claude Pro/Max, OpenAI Codex) support browser sign-in from the Models
+ * Claude Pro/Max, Sign in with ChatGPT, OpenAI Codex) support browser sign-in from the Models
  * page in addition to (or instead of) API keys — see `oauth-logins.ts`.
  * GitHub Copilot OAuth exists in pi-ai but has no catalog entry yet.
  * Bedrock / Vertex / Azure / Cloudflare are in scope as multi-cred
  * providers.
  *
  * SOURCE OF TRUTH for provider IDs and env-var names:
- *   temp/pi-mono/packages/ai/src/types.ts (KnownProvider union)
- *   temp/pi-mono/packages/ai/src/env-api-keys.ts (envMap)
+ *   temp/pi/packages/ai/src/types.ts (KnownProvider union)
+ *   temp/pi/packages/ai/src/env-api-keys.ts (envMap)
  * Keep this file in sync on each pi-coding-agent upgrade — the
  * `KnownProvider` union below is a copy of pi-ai's; entries declared
  * here are typechecked against it.
  */
 
-// Mirrored from pi-ai's `KnownProvider` (pi-mono/packages/ai/src/types.ts).
+// Mirrored from pi-ai's `KnownProvider` (temp/pi/packages/ai/src/types.ts).
 // Only ids declared in the catalog below are typechecked against it, so a
 // provider added upstream stays invisible here until it gets an entry.
 export type KnownProvider =
@@ -37,6 +37,7 @@ export type KnownProvider =
   | "azure-openai-responses"
   | "openai-codex"
   | "radius"
+  | "typesafe"
   | "nvidia"
   | "deepseek"
   | "github-copilot"
@@ -59,6 +60,7 @@ export type KnownProvider =
   | "opencode"
   | "opencode-go"
   | "kimi-coding"
+  | "meta"
   | "cloudflare-workers-ai"
   | "cloudflare-ai-gateway"
   | "qwen-token-plan"
@@ -97,46 +99,52 @@ export const PROVIDER_CATALOG: CatalogEntry[] = [
     notes:
       "API key or Claude Pro/Max subscription OAuth. When both are set, pi prefers the OAuth credential.",
     models: [
+      "claude-opus-5-5",
+      "claude-sonnet-5-5",
+      "claude-fable-5-1",
+      "claude-opus-5",
+      "claude-sonnet-5",
+      "claude-opus-4-8",
       "claude-opus-4-7",
-      "claude-opus-4-6",
-      "claude-opus-4-5",
       "claude-sonnet-4-6",
-      "claude-sonnet-4-5",
       "claude-haiku-4-5",
-      "claude-3-7-sonnet-20250219",
-      "claude-3-5-sonnet-20241022",
-      "claude-3-5-haiku-20241022",
     ],
   },
   {
     id: "openai",
     displayName: "OpenAI",
     credentials: apiKeyOnly("OPENAI_API_KEY"),
+    oauth: true,
+    notes:
+      "API key or Sign in with ChatGPT (uses a ChatGPT subscription with the OpenAI API).",
     models: [
-      "gpt-5.1",
-      "gpt-5",
+      "gpt-6.1-sol",
+      "gpt-6-sol",
+      "gpt-6-luna",
+      "gpt-6-astra",
+      "gpt-5.5",
+      "gpt-5.4-mini",
       "gpt-4.1",
-      "gpt-4o",
-      "gpt-4o-mini",
-      "o4-mini",
       "o3",
-      "o3-mini",
     ],
   },
   {
     id: "openai-codex",
-    displayName: "OpenAI Codex",
+    displayName: "OpenAI Codex (legacy)",
     credentials: [],
     oauth: true,
     notes:
-      "ChatGPT Plus/Pro subscription via OAuth — no API key. Sign in below.",
+      "ChatGPT Plus/Pro subscription via OAuth — no API key. Superseded by Sign in with ChatGPT on OpenAI.",
     models: [
+      "gpt-6.1-sol",
+      "gpt-6-sol",
+      "gpt-6-luna",
+      "gpt-6-astra",
+      "gpt-5.6-sol",
+      "gpt-5.6-luna",
+      "gpt-5.6-terra",
       "gpt-5.5",
-      "gpt-5.4",
-      "gpt-5.4-mini",
-      "gpt-5.3-codex",
       "gpt-5.3-codex-spark",
-      "gpt-5.2",
     ],
   },
   {
@@ -144,17 +152,21 @@ export const PROVIDER_CATALOG: CatalogEntry[] = [
     displayName: "Google Gemini",
     credentials: apiKeyOnly("GEMINI_API_KEY"),
     models: [
+      "gemini-3.8-flash",
+      "gemini-3.1-pro-preview",
+      "gemini-3.5-flash-lite",
       "gemini-2.5-pro",
       "gemini-2.5-flash",
-      "gemini-2.5-flash-lite",
-      "gemini-2.0-flash",
     ],
   },
   {
     id: "deepseek",
     displayName: "DeepSeek",
     credentials: apiKeyOnly("DEEPSEEK_API_KEY"),
-    models: ["deepseek-chat", "deepseek-reasoner"],
+    models: [
+      "deepseek-v4-pro",
+      "deepseek-flash",
+    ],
   },
   {
     id: "mistral",
@@ -174,30 +186,39 @@ export const PROVIDER_CATALOG: CatalogEntry[] = [
     models: [
       "llama-3.3-70b-versatile",
       "llama-3.1-8b-instant",
-      "moonshotai/kimi-k2-instruct",
+      "openai/gpt-oss-120b",
+      "qwen/qwen3.8-27b",
     ],
   },
   {
     id: "cerebras",
     displayName: "Cerebras",
     credentials: apiKeyOnly("CEREBRAS_API_KEY"),
-    models: ["llama3.3-70b", "llama-4-scout-17b-16e-instruct"],
+    models: [
+      "gpt-oss-120b",
+      "qwen-3.8-27b",
+    ],
   },
   {
     id: "xai",
     displayName: "xAI",
     credentials: apiKeyOnly("XAI_API_KEY"),
-    models: ["grok-4", "grok-3", "grok-3-mini"],
+    models: [
+      "grok-4.7",
+      "grok-4.6",
+      "grok-4.5",
+    ],
   },
   {
     id: "openrouter",
     displayName: "OpenRouter",
     credentials: apiKeyOnly("OPENROUTER_API_KEY"),
     models: [
-      "anthropic/claude-sonnet-4.5",
-      "openai/gpt-5",
-      "google/gemini-2.5-pro",
-      "deepseek/deepseek-chat",
+      "anthropic/claude-sonnet-5.5",
+      "anthropic/claude-opus-5.5",
+      "openai/gpt-6-astra",
+      "google/gemini-3.8-flash",
+      "deepseek/deepseek-v4-pro",
     ],
   },
   {
@@ -205,37 +226,48 @@ export const PROVIDER_CATALOG: CatalogEntry[] = [
     displayName: "Vercel AI Gateway",
     credentials: apiKeyOnly("AI_GATEWAY_API_KEY"),
     models: [
-      "anthropic/claude-sonnet-4.5",
-      "openai/gpt-5",
-      "google/gemini-2.5-pro",
+      "anthropic/claude-sonnet-5.5",
+      "openai/gpt-6-sol",
+      "google/gemini-3.8-flash",
     ],
   },
   {
     id: "zai",
     displayName: "ZAI",
     credentials: apiKeyOnly("ZAI_API_KEY"),
-    models: ["glm-4.6", "glm-4.5"],
+    models: [
+      "glm-5.3",
+      "glm-5.3-flash",
+      "glm-5.2",
+    ],
   },
   {
     id: "fireworks",
     displayName: "Fireworks",
     credentials: apiKeyOnly("FIREWORKS_API_KEY"),
     models: [
-      "accounts/fireworks/models/deepseek-v3",
-      "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct",
+      "accounts/fireworks/models/kimi-k3",
+      "accounts/fireworks/models/glm-5p3",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     ],
   },
   {
     id: "kimi-coding",
     displayName: "Kimi For Coding",
     credentials: apiKeyOnly("KIMI_API_KEY"),
-    models: ["kimi-k2-coding"],
+    models: [
+      "kimi-for-coding",
+      "k3",
+    ],
   },
   {
     id: "minimax",
     displayName: "MiniMax",
     credentials: apiKeyOnly("MINIMAX_API_KEY"),
-    models: ["minimax-m2"],
+    models: [
+      "MiniMax-M3",
+      "MiniMax-M2.7",
+    ],
   },
   {
     id: "minimax-cn",

package/src/core/models-store.ts

@@ -12,10 +12,9 @@
  *     }
  *   }
  *
- * v0: file-based, plaintext (HLD §15). Read on every `load()` so PUT
- * writes are immediately visible to subsequent agent starts. Edits to
- * the in-memory snapshot don't reach already-running agents — matches
- * the secrets store's restart-required model.
+ * File-based, plaintext. Read on every `load()` so PUT
+ * writes are visible to subsequent agent starts. The settings API requests
+ * a soft reload for affected running agents to refresh their environment.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";

package/src/core/oauth-logins.ts

@@ -4,7 +4,7 @@
  *
  * Reuses pi-coding-agent's `ModelRuntime` — the exact machinery behind
  * pi's `/login` command. Tokens persist to pi's own
- * `<agentDir>/auth.json` (default `~/.pi/agent/auth.json`, 0600,
+ * `<agentDir>/auth.json` (this harness's `.secrets/pi/auth.json`, 0600,
  * file-locked), NOT to the harness's models.json. Rationale:
  *   - refresh tokens rotate on every refresh; spawned pi children
  *     already refresh + persist under a file lock, so the harness must
@@ -29,7 +29,7 @@
  * login per provider — the callback server binds a fixed port.
  */
 
-import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
 import type { AuthPrompt } from "@earendil-works/pi-ai";
 import type { Logger } from "./logger.js";
 
@@ -96,7 +96,7 @@ export class OAuthLoginManager {
 
   /**
    * Shared pi model runtime, created on first use. Owns login/logout
-   * orchestration; credentials go to pi's default auth.json.
+   * orchestration; credentials go to the harness's pi auth.json.
    */
   private runtime(): Promise<ModelRuntime> {
     this.runtimePromise ??= ModelRuntime.create();
@@ -172,6 +172,10 @@ export class OAuthLoginManager {
           }
         },
         prompt: (prompt) => this.handlePrompt(entry, prompt, surfaced),
+      }, {
+        // Sign in with ChatGPT identifies the installation by a stable UUID.
+        // Use pi's own (global settings `deviceId`), as pi's `/login` does.
+        getDeviceId: () => SettingsManager.create(process.cwd()).getOrCreateDeviceId(),
       })
       .then(() => {
         this.results.set(providerId, { state: "success" });

package/src/core/pi-delivery-receipts.ts

@@ -0,0 +1,69 @@
+/**
+ * delivery-receipts — a pi extension the runner loads into every spawned
+ * `pi --mode rpc` child from the package (see `runner.ts:spawnPi`), never
+ * from the agent folder, so an agent can't lose or edit it.
+ *
+ * Every input the runner sends carries `EventId: <row id>` in its
+ * `<harness-metadata>` block. For each user message pi saves, this reports
+ * `{ entryId, eventIds }`: the saved session entry and the queue rows it
+ * contains. That one receipt answers both "did the row reach pi?" and "which
+ * saved message is it?", so the two can't disagree.
+ *
+ * Transport: `pi.appendEntry(RECEIPT_TYPE, { entryId, eventIds })`. Pi saves
+ * it as a custom session entry (kept out of the model's context) and reports
+ * it on stdout as an `entry_appended` event, which `PiRpcClient` routes to the
+ * runner. Saved receipts also let recovery rebuild row-to-entry links from
+ * the session file.
+ *
+ * Pi emits `message_end` before it appends the message to the session, so the
+ * entry id doesn't exist yet there. Instead we re-scan the entries on the
+ * events that follow and report each entry once. Entries already in the file
+ * when pi starts are history from earlier batches (their receipts were sent
+ * then, or the session predates saved receipts), so they're never reported
+ * again — otherwise every spawn would append duplicate receipts.
+ */
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+
+export const RECEIPT_TYPE = "cognisphere.delivery";
+
+/** Row ids named by `EventId:` lines inside `<harness-metadata>` blocks. */
+export function eventIdsIn(text: string): number[] {
+  const ids: number[] = [];
+  for (const block of text.matchAll(/<harness-metadata>([\s\S]*?)<\/harness-metadata>/g)) {
+    const m = /^EventId: (\d+)$/m.exec(block[1]!);
+    if (m) ids.push(Number(m[1]));
+  }
+  return ids;
+}
+
+function messageText(entry: SessionEntry): string | null {
+  if (entry.type !== "message" || entry.message.role !== "user") return null;
+  const { content } = entry.message;
+  if (typeof content === "string") return content;
+  return content.map((c) => (c.type === "text" ? c.text : "")).join("\n");
+}
+
+export default function deliveryReceipts(pi: ExtensionAPI): void {
+  const reported = new Set<string>();
+
+  pi.on("session_start", (_event, ctx) => {
+    for (const entry of ctx.sessionManager.getEntries()) reported.add(entry.id);
+  });
+
+  const sweep = (_event: unknown, ctx: ExtensionContext): void => {
+    for (const entry of ctx.sessionManager.getEntries()) {
+      if (reported.has(entry.id)) continue;
+      const text = messageText(entry);
+      if (text === null) continue;
+      reported.add(entry.id);
+      const eventIds = eventIdsIn(text);
+      if (eventIds.length === 0) continue;
+      pi.appendEntry(RECEIPT_TYPE, { entryId: entry.id, eventIds });
+    }
+  };
+
+  pi.on("message_start", sweep);
+  pi.on("turn_start", sweep);
+  pi.on("turn_end", sweep);
+  pi.on("agent_end", sweep);
+}

package/src/core/pi-models-sync.ts

@@ -1,7 +1,7 @@
 /**
  * Mirror `.secrets/models.json` `modelOverrides` into pi's own models.json
- * (`<getAgentDir()>/models.json`, i.e. `~/.pi/agent/models.json` unless
- * `PI_CODING_AGENT_DIR` overrides it). Pi children re-read that file on
+ * (`<getAgentDir()>/models.json`; the harness points `PI_CODING_AGENT_DIR`
+ * at its own `.secrets/pi/`, see `main.ts`). Pi children re-read that file on
  * every spawn, so overrides configured in the harness Models settings take
  * effect natively inside pi — model registry, ContextUsage reporting, and
  * pi's own compaction thresholds all see the overridden contextWindow /

package/src/core/queue.ts

@@ -68,8 +68,8 @@ export interface EventRow {
 /**
  * Derive a re-dispatch {@link RetryMode} from a row's persisted state. No
  * dedicated column: a row that was delivered to the model has its
- * `pi_entry_id` written in real time (by the runner, from the harness-bridge
- * extension), so its presence on a retried row means "already in pi's
+ * `pi_entry_id` written in real time (by the runner, from a delivery receipt),
+ * so its presence on a retried row means "already in pi's
  * history → continue, don't resend".
  */
 function deriveRetryMode(row: EventRow): RetryMode | undefined {
@@ -278,17 +278,13 @@ export class AgentDb {
 
   /**
    * Bind a row to its position in pi's session JSONL. Called by the runner in
-   * real time as the harness-bridge extension reports each user-message entry
-   * id (so the link exists even for rows whose batch later fails, and without
-   * waiting for pi to exit). COALESCE on the session id preserves a value from
-   * a prior attempt; the entry id is written outright (the latest delivery
-   * wins).
+   * real time as delivery receipts name the row (so the link exists even for
+   * rows whose batch later fails, and without waiting for pi to exit).
+   * COALESCE on the session id preserves a value from a prior attempt.
    */
   setRowEntryId(rowId: number, sessionId: string, entryId: string): void {
-    // Defensive: never rebind a row whose pi_entry_id is already set. The
-    // runner already dedups entryIds per batch, but this guards against a row
-    // being bound twice (e.g. a stale absolute-index report or a logic error)
-    // — once a row carries an entry id it stays put.
+    // Never rebind: receipts re-report history on every batch, so the first
+    // (earliest) saved copy of a row keeps the link.
     this.db
       .prepare(
         `UPDATE events
@@ -300,20 +296,6 @@ export class AgentDb {
       .run(sessionId, entryId, Date.now(), rowId);
   }
 
-  /** All distinct `pi_entry_id`s already bound to rows on this thread. The
-   *  runner pre-seeds its per-batch seen-set with these so the harness-bridge's
-   *  re-report of historical entries (it sweeps the whole reused session JSONL)
-   *  is ignored — only entryIds new to this thread bind to this batch's rows. */
-  entryIdsForThread(threadId: string): string[] {
-    const rows = this.db
-      .prepare<unknown[], { pi_entry_id: string }>(
-        `SELECT DISTINCT pi_entry_id FROM events
-          WHERE thread_id = ? AND pi_entry_id IS NOT NULL`,
-      )
-      .all(threadId);
-    return rows.map((r) => r.pi_entry_id);
-  }
-
   /**
    * Mark every id done. `sessionId` (when non-null) is written to all rows.
    * Per-row `pi_entry_id`s are no longer threaded through here — they are

package/src/core/rpc.ts

@@ -1,6 +1,7 @@
 import type { ChildProcess } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import type { Logger } from "./logger.js";
+import { RECEIPT_TYPE } from "./pi-delivery-receipts.js";
 
 interface RpcResponse {
   type: "response";
@@ -16,14 +17,14 @@ interface ExtensionUiRequest {
   id: string;
   method: string;
   title?: string;
-  /** Present on fire-and-forget `setStatus` requests (the harness-bridge
-   *  extension uses these to report session entry ids — see {@link onHarnessEntry}). */
-  statusKey?: string;
-  statusText?: string;
 }
 
+/** What pi did with a `prompt`/`steer` frame. `handled` = an extension
+ *  `input` handler consumed it: no session entry, so no receipt will come. */
+export type InputDisposition = "started" | "queued" | "handled";
+
 /**
- * Minimal shape of an entry in `agent_end.messages` / `message_start.message`.
+ * Minimal shape of an entry in `agent_end.messages`.
  * The harness only inspects the final message's `role` and (for assistants)
  * `stopReason` / `errorMessage` to decide turn completion; the full pi message
  * type isn't needed here.
@@ -34,11 +35,12 @@ export interface PiMessage {
   errorMessage?: string;
 }
 
-/** Reported by the harness-bridge extension via `setStatus("cognisphere", …)`. */
-export interface HarnessEntryReport {
-  kind: "user_entry";
-  index: number;
+/** Reported by the delivery-receipts extension (`pi-delivery-receipts.ts`)
+ *  as a custom session entry: pi saved the queue rows `eventIds` as session
+ *  entry `entryId`. */
+export interface DeliveryReceipt {
   entryId: string;
+  eventIds: number[];
 }
 
 type RpcMessage =
@@ -46,7 +48,8 @@ type RpcMessage =
   | ExtensionUiRequest
   | { type: "agent_start" }
   | { type: "agent_end"; messages?: PiMessage[] }
-  | { type: "message_start"; message?: PiMessage }
+  | { type: "agent_settled" }
+  | { type: "entry_appended"; entry?: { type?: string; customType?: string; data?: unknown } }
   | { type: string; [k: string]: unknown };
 
 /**
@@ -70,8 +73,8 @@ export class PiRpcClient {
   >();
   private nextId = 1;
   private agentEndHandler: ((messages: PiMessage[]) => void) | undefined;
-  private userMessageStartHandler: (() => void) | undefined;
-  private harnessEntryHandler: ((report: HarnessEntryReport) => void) | undefined;
+  private agentSettledHandler: (() => void) | undefined;
+  private deliveryReceiptHandler: ((receipt: DeliveryReceipt) => void) | undefined;
   private exitPromise: Promise<{ code: number | null; signal: NodeJS.Signals | null }>;
 
   constructor(child: ChildProcess, log: Logger) {
@@ -111,24 +114,24 @@ export class PiRpcClient {
     });
   }
 
-  /** Fires once per run when pi's agent loop ends. Receives the run's
-   *  messages so the caller can inspect the final message's shape (role +
-   *  stopReason) to decide whether the turn completed. */
+  /** Fires each time one low-level pi run ends. Pi may still retry, recover
+   *  from overflow or run a late steer afterwards — wait for
+   *  {@link onAgentSettled} — so the caller keeps the latest run's messages
+   *  and judges completion from the final message's role + stopReason. */
   onAgentEnd(h: (messages: PiMessage[]) => void): void {
     this.agentEndHandler = h;
   }
 
-  /** Fires each time pi appends a *user* message (the initial prompt and each
-   *  steer). The caller counts these in dispatch order to know which rows
-   *  actually reached the model. */
-  onUserMessageStart(h: () => void): void {
-    this.userMessageStartHandler = h;
+  /** Fires when pi is fully settled: no retry, compaction or queued
+   *  continuation remains. */
+  onAgentSettled(h: () => void): void {
+    this.agentSettledHandler = h;
   }
 
-  /** Fires when the harness-bridge extension reports a user-message session
-   *  entry id over the `setStatus("cognisphere", …)` channel. */
-  onHarnessEntry(h: (report: HarnessEntryReport) => void): void {
-    this.harnessEntryHandler = h;
+  /** Fires when the delivery-receipts extension reports that pi saved a user
+   *  message containing these queue rows. */
+  onDeliveryReceipt(h: (receipt: DeliveryReceipt) => void): void {
+    this.deliveryReceiptHandler = h;
   }
 
   waitExit() {
@@ -139,7 +142,7 @@ export class PiRpcClient {
     return this.stderrBuf;
   }
 
-  async sendPrompt(text: string): Promise<void> {
+  async sendPrompt(text: string): Promise<InputDisposition> {
     const id = `p${this.nextId++}`;
     // Pi acks a prompt frame immediately (the agent loop runs after), so a
     // missing ack means the child is wedged. Without the timeout, the runner
@@ -151,11 +154,15 @@ export class PiRpcClient {
       60_000,
     );
     if (!r.success) throw new Error(`pi rejected prompt: ${r.error ?? "unknown"}`);
+    return dispositionOf(r);
   }
 
-  sendSteer(text: string): void {
+  /** Rejects if the frame can't be written, pi rejects it, or no ack comes. */
+  async sendSteer(text: string): Promise<InputDisposition> {
     const id = `s${this.nextId++}`;
-    this.writeFrame({ id, type: "steer", message: text });
+    const r = await this.writeAndAwait(id, { id, type: "steer", message: text }, 60_000);
+    if (!r.success) throw new Error(`pi rejected steer: ${r.error ?? "unknown"}`);
+    return dispositionOf(r);
   }
 
   sendAbort(): void {
@@ -295,9 +302,20 @@ export class PiRpcClient {
       this.agentEndHandler?.(messages);
       return;
     }
-    if (p.type === "message_start") {
-      const role = (p as { message?: PiMessage }).message?.role;
-      if (role === "user") this.userMessageStartHandler?.();
+    if (p.type === "agent_settled") {
+      this.agentSettledHandler?.();
+      return;
+    }
+    if (p.type === "entry_appended") {
+      const entry = (p as { entry?: { type?: string; customType?: string; data?: unknown } }).entry;
+      if (entry?.type === "custom" && entry.customType === RECEIPT_TYPE) {
+        const r = entry.data as Partial<DeliveryReceipt> | undefined;
+        if (typeof r?.entryId === "string" && Array.isArray(r.eventIds)) {
+          this.deliveryReceiptHandler?.({ entryId: r.entryId, eventIds: r.eventIds });
+        } else {
+          this.log.debug({ data: entry.data }, "bad delivery receipt payload");
+        }
+      }
       return;
     }
     if (p.type === "extension_ui_request") {
@@ -336,25 +354,6 @@ export class PiRpcClient {
   }
 
   private handleExtensionUi(req: ExtensionUiRequest): void {
-    // The harness-bridge extension reports session entry ids as a
-    // fire-and-forget `setStatus` keyed "cognisphere". Intercept those and
-    // route to the harness-entry handler instead of treating them as UI.
-    if (req.method === "setStatus" && req.statusKey === "cognisphere") {
-      if (req.statusText == null) return;
-      try {
-        const report = JSON.parse(req.statusText) as HarnessEntryReport;
-        if (
-          report.kind === "user_entry" &&
-          typeof report.index === "number" &&
-          typeof report.entryId === "string"
-        ) {
-          this.harnessEntryHandler?.(report);
-        }
-      } catch {
-        this.log.debug({ statusText: req.statusText }, "bad cognisphere setStatus payload");
-      }
-      return;
-    }
     const dialog = new Set(["select", "confirm", "input", "editor"]);
     if (dialog.has(req.method)) {
       this.log.warn({ method: req.method }, "auto-cancel extension_ui_request");
@@ -372,3 +371,10 @@ export class PiRpcClient {
     this.pending.clear();
   }
 }
+
+/** Pi (0.99+) reports `data.disposition` on successful prompt/steer acks.
+ *  Missing → treat as a normal accepted input. */
+function dispositionOf(r: RpcResponse): InputDisposition {
+  const d = (r.data as { disposition?: unknown } | undefined)?.disposition;
+  return d === "handled" || d === "queued" ? d : "started";
+}