@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-hermes-memory/tests/handlers/review-memory-ops.test.ts

@@ -2,6 +2,7 @@ import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
+import * as http from "node:http";
 import * as path from "node:path";
 import { MemoryStore } from "../../src/store/memory-store.js";
 import type { Api, Model } from "@earendil-works/pi-ai";
@@ -15,7 +16,13 @@ import {
 import { DatabaseManager } from "../../src/store/db.js";
 import { getMemories, reconcileMarkdownMemoryScope } from "../../src/store/sqlite-memory-store.js";
 import { acquireMarkdownMutationLock } from "../../src/store/markdown-mutation-lock.js";
-import { MEMORY_FILE } from "../../src/constants.js";
+import {
+  DIRECT_CONSOLIDATION_SYSTEM_PROMPT,
+  DIRECT_CORRECTION_SYSTEM_PROMPT,
+  DIRECT_FLUSH_SYSTEM_PROMPT,
+  DIRECT_REVIEW_SYSTEM_PROMPT,
+  MEMORY_FILE,
+} from "../../src/constants.js";
 
 function mockModel(reasoning: boolean): Model<Api> {
   return {
@@ -38,6 +45,7 @@ describe("buildDirectReviewCompletionOptions", () => {
       },
       "minimal",
       signal,
+      undefined,
     );
 
     assert.strictEqual(options.apiKey, "sk-test");
@@ -54,12 +62,14 @@ describe("buildDirectReviewCompletionOptions", () => {
       { apiKey: "sk-test" },
       "off",
       signal,
+      undefined,
     );
     const nonReasoning = buildDirectReviewCompletionOptions(
       mockModel(false),
       { apiKey: "sk-test" },
       "high",
       signal,
+      undefined,
     );
 
     assert.strictEqual(off.reasoning, undefined);
@@ -99,6 +109,8 @@ describe("provider auth resolution", () => {
         ok: true as const,
         headers: headers[Math.min(authCalls++, headers.length - 1)],
       }),
+      hasConfiguredAuth: () => false,
+      isUsingOAuth: () => false,
       getAll: () => [mockModel(false)],
       getAvailable: () => [mockModel(false)],
       get authCalls() { return authCalls; },
@@ -183,6 +195,36 @@ describe("provider auth resolution", () => {
     });
   }
 
+  // real shape for amazon-bedrock with AWS_PROFILE: pi returns { ok: true } and nothing else
+  function ambientRegistry(isUsingOAuth: boolean) {
+    return {
+      getApiKeyAndHeaders: async () => ({ ok: true as const }),
+      hasConfiguredAuth: () => true,
+      isUsingOAuth: () => isUsingOAuth,
+      getAll: () => [mockModel(false)],
+      getAvailable: () => [mockModel(false)],
+    };
+  }
+
+  it("runs direct review for providers with ambient credentials", async () => {
+    const { usedKeys, complete } = completionStub(() => emptyOperations);
+
+    const result = await runReview(ambientRegistry(false), complete);
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(usedKeys, [undefined]);
+  });
+
+  it("rejects configured OAuth that resolves to no credentials", async () => {
+    const { usedKeys, complete } = completionStub(() => emptyOperations);
+
+    const result = await runReview(ambientRegistry(true), complete);
+
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(result.fallbackReason, "no_auth");
+    assert.deepStrictEqual(usedKeys, []);
+  });
+
   it("re-resolves credentials after a provider auth rejection", async () => {
     const { modelRegistry } = registryWithAuthResponses("revoked-key", "rotated-key");
     const { usedKeys, complete } = completionStub((_key, attempt) => {
@@ -507,6 +549,59 @@ describe("parseReviewOperations", () => {
       { action: "add", target: "user", content: "prefers dark mode" },
     ]);
   });
+
+  it("prefers the last operations object when CoT restates the schema first (#197)", () => {
+    const parsed = parseReviewOperations(
+      'The schema is {"operations":[]} but I will save:\n{"operations":[{"action":"add","target":"user","content":"prefers dark mode"}]}',
+    );
+
+    assert.deepStrictEqual(parsed, [
+      { action: "add", target: "user", content: "prefers dark mode" },
+    ]);
+  });
+
+  it("still parses a single object surrounded by prose via the first-to-last slice", () => {
+    const parsed = parseReviewOperations(
+      'Sure — here it is:\n{"operations":[{"action":"add","target":"user","content":"prefers dark mode"}]}\nDone.',
+    );
+
+    assert.deepStrictEqual(parsed, [
+      { action: "add", target: "user", content: "prefers dark mode" },
+    ]);
+  });
+
+  it("returns null when no candidate object carries an operations array", () => {
+    assert.strictEqual(parseReviewOperations("checked {\"a\":1} and {\"b\":2} — nothing worth saving"), null);
+  });
+
+  it("does not parse live operations out of any direct prompt (schema echo, #197)", () => {
+    for (const prompt of [
+      DIRECT_REVIEW_SYSTEM_PROMPT,
+      DIRECT_FLUSH_SYSTEM_PROMPT,
+      DIRECT_CONSOLIDATION_SYSTEM_PROMPT,
+      DIRECT_CORRECTION_SYSTEM_PROMPT,
+    ]) {
+      const parsed = parseReviewOperations(prompt);
+      assert.ok(
+        parsed === null || parsed.length === 0,
+        `direct prompt must not contain a parseable operations example, got ${JSON.stringify(parsed)}`,
+      );
+    }
+  });
+
+  it("parses a trailing answer when a fenced non-ops object comes first (#235)", () => {
+    // The fence holds a well-formed object without an `operations` array. It
+    // must be declined so the slice/scan paths can reach the real answer —
+    // claiming it here would recreate the parse_error → subprocess
+    // double-spend on a response that contains a valid answer.
+    const parsed = parseReviewOperations(
+      '```json\n{"note":"no ops here"}\n```\nFinal:\n{"operations":[{"action":"add","target":"user","content":"real answer"}]}',
+    );
+
+    assert.deepStrictEqual(parsed, [
+      { action: "add", target: "user", content: "real answer" },
+    ]);
+  });
 });
 
 describe("applyReviewOperations", () => {
@@ -1064,3 +1159,751 @@ describe("applyReviewOperations", () => {
     }
   });
 });
+
+describe("response channel fallbacks (#197)", () => {
+  function registry() {
+    return {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+      getAll: () => [mockModel(true)],
+      getAvailable: () => [mockModel(true)],
+    };
+  }
+
+  async function runReview(complete: unknown) {
+    return runDirectMemoryCompletion(
+      { model: mockModel(true), modelRegistry: registry() } as never,
+      null as never,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+  }
+
+  it("parses ops from thinking blocks when content has no text blocks", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "thinking", thinking: JSON.stringify({ operations: [] }) },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // "empty" (not "empty_response") proves the ops JSON inside the thinking
+    // block reached the parser and parsed cleanly.
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty" });
+  });
+
+  it("prefers text blocks over thinking blocks when both are present", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "text", text: "not json at all" },
+        { type: "thinking", thinking: JSON.stringify({ operations: [] }) },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // Valid ops in thinking must not mask an unparseable text answer.
+    assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "parse_error" });
+  });
+
+  it("returns empty_response on a clean stop with neither text nor thinking", async () => {
+    const complete = async () => ({ stopReason: "stop", content: [] });
+
+    const result = await runReview(complete);
+
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty_response" });
+  });
+
+  it("keeps parse_error when a truncated (length) response has no content", async () => {
+    const complete = async () => ({ stopReason: "length", content: [] });
+
+    const result = await runReview(complete);
+
+    // Truncation means the model may not have finished; the fallback chain
+    // (next model / subprocess) must still get a chance to retry.
+    assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "parse_error" });
+  });
+
+  it("logs the provider-misconfiguration notice once per state for thinking-only answers", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [{ type: "thinking", thinking: JSON.stringify({ operations: [] }) }],
+    });
+    const lines: string[] = [];
+    const state = { logged: false };
+    const runWithDeps = (overrides: Record<string, unknown> = {}) =>
+      runDirectMemoryCompletion(
+        { model: mockModel(true), modelRegistry: registry() } as never,
+        null as never,
+        null,
+        { userPrompt: "u", systemPrompt: "s", config: {} },
+        null,
+        null,
+        {
+          completeSimple: complete as never,
+          onProviderNotice: (message: string) => lines.push(message),
+          providerNoticeState: state,
+          ...overrides,
+        },
+      );
+
+    await runWithDeps();
+    assert.strictEqual(lines.length, 1);
+    assert.match(lines[0]!, /Provider misconfiguration/);
+    assert.match(lines[0]!, /thinking channel/);
+    assert.match(lines[0]!, /Ask your Pi to fix this as well/);
+
+    // A second review sharing the state stays silent: the notice is log-once.
+    await runWithDeps();
+    assert.strictEqual(lines.length, 1);
+
+    // A fresh state (a new process or session) logs again.
+    await runWithDeps({ providerNoticeState: { logged: false } });
+    assert.strictEqual(lines.length, 2);
+  });
+
+  it("does not log the provider notice for a normal text-channel answer", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [{ type: "text", text: JSON.stringify({ operations: [] }) }],
+    });
+    const lines: string[] = [];
+
+    await runDirectMemoryCompletion(
+      { model: mockModel(true), modelRegistry: registry() } as never,
+      null as never,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      {
+        completeSimple: complete as never,
+        onProviderNotice: (message: string) => lines.push(message),
+        providerNoticeState: { logged: false },
+      },
+    );
+
+    assert.strictEqual(lines.length, 0);
+  });
+
+  it("treats a redacted-only completion as empty_response, not parse_error", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "thinking", thinking: "encrypted redacted payload", redacted: true },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // The redacted block is skipped — nothing parseable, nothing emitted in
+    // the clear: same clean-stop empty_response as a silent model, rather
+    // than a parse_error that would burn the subprocess fallback (#197).
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty_response" });
+  });
+
+  it("skips redacted thinking blocks but still recovers a clear one", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "thinking", thinking: "encrypted redacted payload", redacted: true },
+        { type: "thinking", thinking: JSON.stringify({ operations: [] }) },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty" });
+  });
+
+  it("falls back to thinking when the text block is whitespace only", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "text", text: "   \n\t" },
+        { type: "thinking", thinking: JSON.stringify({ operations: [] }) },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // Whitespace-only text must not mask recoverable thinking output.
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty" });
+  });
+
+  it("settles empty_response when thinking output parses to nothing on a clean stop (#235)", async () => {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        { type: "thinking", thinking: 'reasoned about { braces } and "quotes" but produced no operations' },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // Brace-heavy prose with no ops object: the answer never left the
+    // reasoning channel, and a subprocess would run the same model against
+    // the same server-side thinking default and fail the same way.
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty_response" });
+  });
+
+  it("keeps parse_error when unparseable thinking output is truncated (#235)", async () => {
+    const complete = async () => ({
+      stopReason: "length",
+      content: [
+        { type: "thinking", thinking: 'reasoned about { braces } and got cut off mid-obj' },
+      ],
+    });
+
+    const result = await runReview(complete);
+
+    // Truncation means the model may not have finished; the chain (next
+    // model / subprocess) must still get a chance to retry.
+    assert.deepStrictEqual(result, { ok: false, appliedCount: 0, fallbackReason: "parse_error" });
+  });
+});
+
+describe("thinking-channel CoT recovery (#197)", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "review-cot-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  function registry() {
+    return {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+      getAll: () => [mockModel(true)],
+      getAvailable: () => [mockModel(true)],
+    };
+  }
+
+  it("applies the trailing answer when CoT restates the schema first", async () => {
+    const store = new MemoryStore({
+      memoryDir: tmpDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      autoConsolidate: true,
+    });
+    await store.loadFromDisk();
+
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [
+        {
+          type: "thinking",
+          thinking:
+            'The schema is {"operations":[]} but I will save:\n{"operations":[{"action":"add","target":"user","content":"prefers dark mode"}]}',
+        },
+      ],
+    });
+
+    const result = await runDirectMemoryCompletion(
+      { model: mockModel(true), modelRegistry: registry() } as never,
+      store,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.appliedCount, 1);
+    assert.ok(store.getUserEntries().some((entry) => entry.includes("prefers dark mode")));
+  });
+});
+
+describe("thinking-channel trust rules (#235)", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "review-235-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  function registry() {
+    return {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+      getAll: () => [mockModel(true)],
+      getAvailable: () => [mockModel(true)],
+    };
+  }
+
+  const makeStore = async () => {
+    const store = new MemoryStore({
+      memoryDir: tmpDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      autoConsolidate: true,
+    });
+    await store.loadFromDisk();
+    return store;
+  };
+
+  async function runThinking(thinking: string, store: MemoryStore) {
+    const complete = async () => ({
+      stopReason: "stop",
+      content: [{ type: "thinking", thinking }],
+    });
+    return runDirectMemoryCompletion(
+      { model: mockModel(true), modelRegistry: registry() } as never,
+      store,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+  }
+
+  it("picks the trailing answer over an earlier fenced draft, and the draft's remove is not applied", async () => {
+    const store = await makeStore();
+    await applyReviewOperations(store, null, [
+      { action: "add", target: "memory", content: "draft old entry" },
+    ]);
+
+    // The shared cascade would let the fenced draft (a remove) win before
+    // the end-scan runs. The thinking path must pick the trailing answer,
+    // and the draft's remove must never execute.
+    const result = await runThinking(
+      '```json\n{"operations":[{"action":"remove","target":"memory","old_text":"draft old entry"}]}\n```\nFinal answer:\n{"operations":[{"action":"add","target":"user","content":"prefers dark mode"}]}',
+      store,
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.appliedCount, 1);
+    assert.ok(store.getUserEntries().some((entry) => entry.includes("prefers dark mode")));
+    assert.ok(store.getMemoryEntries().some((entry) => entry.includes("draft old entry")));
+  });
+
+  it("applies only adds from a non-trailing (draft-grade) candidate", async () => {
+    const store = await makeStore();
+    await applyReviewOperations(store, null, [
+      { action: "add", target: "memory", content: "draft old entry" },
+    ]);
+
+    // The candidate is followed by more reasoning, so it is draft-grade:
+    // the add is recovered, the remove is dropped.
+    const result = await runThinking(
+      '{"operations":[{"action":"add","target":"user","content":"prefers dark mode"},{"action":"remove","target":"memory","old_text":"draft old entry"}]}\nOn reflection, keep the store as it is.',
+      store,
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.appliedCount, 1);
+    assert.ok(store.getUserEntries().some((entry) => entry.includes("prefers dark mode")));
+    assert.ok(store.getMemoryEntries().some((entry) => entry.includes("draft old entry")));
+  });
+
+  it("recovers the answer when an unbalanced brace in prose precedes it", async () => {
+    const store = await makeStore();
+
+    // A top-level-only scanner loses every object after an unclosed brace;
+    // recording balanced regions at any depth still finds the answer.
+    const result = await runThinking(
+      'thinking about { this brace never closes\n{"operations":[{"action":"add","target":"user","content":"prefers dark mode"}]}',
+      store,
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.appliedCount, 1);
+    assert.ok(store.getUserEntries().some((entry) => entry.includes("prefers dark mode")));
+  });
+
+  it("settles empty when the trailing candidate is empty, without reaching back to an earlier draft", async () => {
+    const store = await makeStore();
+
+    const result = await runThinking(
+      'draft {"operations":[{"action":"add","target":"user","content":"never applied"}]} but finally:\n{"operations":[]}',
+      store,
+    );
+
+    // The trailing empty candidate is the model's final word: applying the
+    // earlier draft would execute an operation it may have rejected.
+    assert.deepStrictEqual(result, { ok: true, appliedCount: 0, fallbackReason: "empty" });
+    assert.ok(!store.getUserEntries().some((entry) => entry.includes("never applied")));
+  });
+
+  it("walks to a healthy fallback model after a silent primary and applies its operations", async () => {
+    const store = await makeStore();
+    const m1 = { id: "m1", provider: "p1", api: "openai-completions", reasoning: true } as Model<Api>;
+    const m2 = { id: "m2", provider: "p2", api: "openai-completions", reasoning: true } as Model<Api>;
+    const chainRegistry = {
+      getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+      getAll: () => [m1, m2],
+      getAvailable: () => [m1, m2],
+    };
+    const attempted: string[] = [];
+    const complete = async (model: Model<Api>) => {
+      attempted.push(model.id);
+      if (model.id === "m1") {
+        // Silent primary: clean stop, nothing in either channel.
+        return { stopReason: "stop", content: [] };
+      }
+      return {
+        stopReason: "stop",
+        content: [{ type: "text", text: JSON.stringify({ operations: [{ action: "add", target: "user", content: "prefers dark mode" }] }) }],
+      };
+    };
+
+    const result = await runDirectMemoryCompletion(
+      { model: m1, modelRegistry: chainRegistry } as never,
+      store,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: { llmModelOverride: "p1/m1", llmFallbackModels: ["p2/m2"] } },
+      null,
+      null,
+      { completeSimple: complete as never },
+    );
+
+    // empty_response walks llmFallbackModels like parse_error does: a silent
+    // primary must not end the review while a configured fallback may answer.
+    assert.deepStrictEqual(attempted, ["m1", "m2"]);
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.appliedCount, 1);
+    assert.ok(store.getUserEntries().some((entry) => entry.includes("prefers dark mode")));
+  });
+});
+
+describe("opencode session header (#250)", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "review-250-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  async function makeStore() {
+    const store = new MemoryStore({
+      memoryDir: tmpDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      autoConsolidate: true,
+    });
+    await store.loadFromDisk();
+    return store;
+  }
+
+  // Stands in for the OpenCode Go gateway, which rejects any request without
+  // x-opencode-session before the model is ever reached.
+  async function startGateway() {
+    const seen: Array<string | string[] | undefined> = [];
+    const server = http.createServer((req, res) => {
+      const session = req.headers["x-opencode-session"];
+      seen.push(session);
+      if (session === undefined) {
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(JSON.stringify({ type: "error", error: { type: "invalid_request_error", message: "missing_session_id" } }));
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/event-stream" });
+      const send = (event: string, data: unknown) => res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+      const body = JSON.stringify({ operations: [{ action: "add", target: "memory", content: "gateway requires a session" }] });
+      send("message_start", {
+        type: "message_start",
+        message: { id: "msg_1", type: "message", role: "assistant", model: "mimo", content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 1, output_tokens: 1 } },
+      });
+      send("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } });
+      send("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: body } });
+      send("content_block_stop", { type: "content_block_stop", index: 0 });
+      send("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 5 } });
+      send("message_stop", { type: "message_stop" });
+      res.end();
+    });
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (address === null || typeof address === "string") throw new Error("gateway did not bind a TCP port");
+    return { server, seen, baseUrl: `http://127.0.0.1:${address.port}` };
+  }
+
+  it("saves the memory entry the gateway accepted, without stubbing the transport", async () => {
+    const { server, seen, baseUrl } = await startGateway();
+    const store = await makeStore();
+    const model = {
+      id: "mimo-v2.6",
+      name: "mimo-v2.6",
+      provider: "opencode-go",
+      api: "anthropic-messages",
+      baseUrl,
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 200000,
+      maxTokens: 4096,
+    } as Model<Api>;
+
+    try {
+      const result = await runDirectMemoryCompletion(
+        {
+          model,
+          modelRegistry: {
+            getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+            hasConfiguredAuth: () => true,
+            isUsingOAuth: () => false,
+            getAll: () => [model],
+            getAvailable: () => [model],
+          },
+          sessionManager: { getSessionId: () => "ses_opencode_route" },
+        } as never,
+        store,
+        null,
+        { userPrompt: "u", systemPrompt: "s", config: {} },
+        null,
+        null,
+      );
+
+      assert.ok(seen.length > 0, "gateway saw no request at all");
+      assert.ok(
+        seen.every((value) => value === "ses_opencode_route"),
+        `every request must carry the pi session id, saw ${JSON.stringify(seen)}`,
+      );
+      assert.strictEqual(result.ok, true);
+      assert.strictEqual(result.appliedCount, 1);
+      assert.ok(store.getMemoryEntries().some((entry) => entry.includes("gateway requires a session")));
+    } finally {
+      server.close();
+    }
+  });
+
+  it("leaves other providers and the registry's own header object untouched", async () => {
+    const registryHeaders = { Authorization: "Bearer k" };
+    const captured: Array<Record<string, string | null> | undefined> = [];
+    const model = { ...mockModel(false), provider: "anthropic", api: "anthropic-messages" } as Model<Api>;
+
+    const result = await runDirectMemoryCompletion(
+      {
+        model,
+        modelRegistry: {
+          getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test", headers: registryHeaders }),
+          hasConfiguredAuth: () => true,
+          isUsingOAuth: () => false,
+          getAll: () => [model],
+          getAvailable: () => [model],
+        },
+        sessionManager: { getSessionId: () => "ses_opencode_route" },
+      } as never,
+      null as never,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      {
+        completeSimple: (async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+          captured.push(options.headers);
+          return { stopReason: "stop", content: [{ type: "text", text: JSON.stringify({ operations: [] }) }] };
+        }) as never,
+      },
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(captured, [registryHeaders]);
+    assert.deepStrictEqual(registryHeaders, { Authorization: "Bearer k" });
+  });
+
+  it("keeps an operator-configured session header instead of overwriting it", async () => {
+    const configured = { "X-OpenCode-Session": "operator-chosen" };
+    const captured: Array<Record<string, string | null> | undefined> = [];
+    const model = { ...mockModel(false), provider: "opencode-go", api: "openai-completions" } as Model<Api>;
+
+    const result = await runDirectMemoryCompletion(
+      {
+        model,
+        modelRegistry: {
+          getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test", headers: configured }),
+          hasConfiguredAuth: () => true,
+          isUsingOAuth: () => false,
+          getAll: () => [model],
+          getAvailable: () => [model],
+        },
+        sessionManager: { getSessionId: () => "ses_opencode_route" },
+      } as never,
+      null as never,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      {
+        completeSimple: (async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+          captured.push(options.headers);
+          return { stopReason: "stop", content: [{ type: "text", text: JSON.stringify({ operations: [] }) }] };
+        }) as never,
+      },
+    );
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(captured, [configured]);
+    assert.deepStrictEqual(configured, { "X-OpenCode-Session": "operator-chosen" });
+  });
+
+  it("scopes the header per model so a mixed-provider chain sends it only to opencode", async () => {
+    const primary = { ...mockModel(false), id: "claude-x", provider: "anthropic", api: "anthropic-messages" } as Model<Api>;
+    const fallback = { ...mockModel(false), id: "deepseek", provider: "opencode-go", api: "openai-completions" } as Model<Api>;
+    const attempted: Array<{ model: string; headers: Record<string, string | null> | undefined }> = [];
+    const store = await makeStore();
+
+    const result = await runDirectMemoryCompletion(
+      {
+        model: primary,
+        modelRegistry: {
+          getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+          hasConfiguredAuth: () => true,
+          isUsingOAuth: () => false,
+          getAll: () => [primary, fallback],
+          getAvailable: () => [primary, fallback],
+        },
+        sessionManager: { getSessionId: () => "ses_opencode_route" },
+      } as never,
+      store,
+      null,
+      {
+        userPrompt: "u",
+        systemPrompt: "s",
+        config: { llmModelOverride: "anthropic/claude-x", llmFallbackModels: ["opencode-go/deepseek"] },
+      },
+      null,
+      null,
+      {
+        completeSimple: (async (model: { id: string }, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+          attempted.push({ model: model.id, headers: options.headers });
+          if (model.id === "claude-x") return { stopReason: "error", content: [], errorMessage: "upstream busy" };
+          return {
+            stopReason: "stop",
+            content: [{ type: "text", text: JSON.stringify({ operations: [{ action: "add", target: "memory", content: "chain hop reached opencode" }] }) }],
+          };
+        }) as never,
+      },
+    );
+
+    assert.deepStrictEqual(attempted.map((a) => a.model), ["claude-x", "deepseek"]);
+    assert.strictEqual(attempted[0]?.headers?.["x-opencode-session"], undefined);
+    assert.strictEqual(attempted[1]?.headers?.["x-opencode-session"], "ses_opencode_route");
+    assert.ok(store.getMemoryEntries().some((entry) => entry.includes("chain hop reached opencode")));
+  });
+});
+
+describe("opencode scoping and session-id degradation", () => {
+  function capturingRun(model: Model<Api>, sessionManager: unknown) {
+    const captured: Array<Record<string, string | null> | undefined> = [];
+    const run = runDirectMemoryCompletion(
+      {
+        model,
+        modelRegistry: {
+          getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "sk-test" }),
+          hasConfiguredAuth: () => true,
+          isUsingOAuth: () => false,
+          getAll: () => [model],
+          getAvailable: () => [model],
+        },
+        sessionManager,
+      } as never,
+      null as never,
+      null,
+      { userPrompt: "u", systemPrompt: "s", config: {} },
+      null,
+      null,
+      {
+        completeSimple: (async (_model: unknown, _request: unknown, options: { headers?: Record<string, string | null> }) => {
+          captured.push(options.headers);
+          return { stopReason: "stop", content: [{ type: "text", text: JSON.stringify({ operations: [] }) }] };
+        }) as never,
+      },
+    );
+    return { run, captured };
+  }
+
+  function modelWith(provider: string, baseUrl: string): Model<Api> {
+    return {
+      ...mockModel(false),
+      provider,
+      baseUrl,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 200000,
+      maxTokens: 4096,
+    } as Model<Api>;
+  }
+
+  const ok = { getSessionId: () => "ses_opencode_route" };
+
+  // Removing the baseUrl clause of the scoping rule leaves every other test in
+  // this file green, so it needs its own coverage.
+  it("scopes by baseUrl host when the provider id is not an opencode one", async () => {
+    const { run, captured } = capturingRun(
+      modelWith("my-opencode-proxy", "https://opencode.ai/zen/go/v1"),
+      ok,
+    );
+
+    const result = await run;
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(captured[0]?.["x-opencode-session"], "ses_opencode_route");
+    assert.strictEqual(captured[0]?.["x-opencode-client"], "pi");
+  });
+
+  it("scopes by provider id even when the host is somewhere else", async () => {
+    const { run, captured } = capturingRun(
+      modelWith("opencode-go", "https://gateway.internal.example/v1"),
+      ok,
+    );
+
+    await run;
+
+    assert.strictEqual(captured[0]?.["x-opencode-session"], "ses_opencode_route");
+  });
+
+  it("leaves a foreign provider on a foreign host untouched", async () => {
+    const { run, captured } = capturingRun(
+      modelWith("my-proxy", "https://gateway.internal.example/v1"),
+      ok,
+    );
+
+    await run;
+
+    assert.strictEqual(captured[0]?.["x-opencode-session"], undefined);
+    assert.strictEqual(captured[0]?.["x-opencode-client"], undefined);
+  });
+
+  it("adds no header when the session id is empty", async () => {
+    const { run, captured } = capturingRun(
+      modelWith("opencode-go", "https://opencode.ai/zen/go/v1"),
+      { getSessionId: () => "" },
+    );
+
+    const result = await run;
+
+    assert.strictEqual(result.ok, true, "the attempt still goes out, degraded");
+    assert.strictEqual(captured[0]?.["x-opencode-session"], undefined);
+  });
+
+  it("adds no header and still completes when reading the session id throws", async () => {
+    const { run, captured } = capturingRun(
+      modelWith("opencode-go", "https://opencode.ai/zen/go/v1"),
+      {
+        getSessionId: () => {
+          throw new Error("session gone");
+        },
+      },
+    );
+
+    const result = await run;
+
+    assert.strictEqual(result.ok, true, "a throw here must not break the job");
+    assert.strictEqual(captured[0]?.["x-opencode-session"], undefined);
+  });
+});