mason: verify historian host requests and preserve headless wrapup

Carry the host lifetime into Pi/OMP wrapup historian calls so headless RPC does not schedule a detached second turn. Add print, RPC UI-shim, and interactive regression cases; removing the lifetime argument makes them red. Existing behavior expectations are retained.

Extend the real-host harness with Pi, explicit release pins, native OpenCode 2 provider-body options, raw request bytes, cutoff controls, and an authored provider timeout. The private report and not-run paid operator scripts are carried separately under .cortexkit. Truncated OpenCode 1 turn two remains fail-closed without an immediate retry; retry policy is intentionally unchanged.

Co-authored-by: Alfonso <alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/pi-plugin/src/commands/ctx-wrapup.test.ts

@@ -238,6 +238,48 @@ function deps(
 }
 
 describe("Pi /ctx-wrapup", () => {
+	it.each([
+		{ name: "print", hasUI: false, mode: undefined, expected: false },
+		{ name: "RPC with UI shims", hasUI: true, mode: "rpc", expected: false },
+		{ name: "interactive", hasUI: true, mode: undefined, expected: true },
+	])("passes $name lifetime to the historian", async ({
+		hasUI,
+		mode,
+		expected,
+	}) => {
+		const db = createDb();
+		try {
+			const sessionId = `wrapup-lifetime-${String(mode)}-${hasUI}`;
+			const seen: Array<boolean | undefined> = [];
+			const configured = deps(db, {
+				runPiHistorianForWrapup: mock(async (args) => {
+					seen.push(args.hasUI);
+					appendRange(
+						db,
+						sessionId,
+						1,
+						args.boundarySnapshot.eligibleEndOrdinal - 1,
+					);
+				}),
+			});
+			await runPiWrapup(
+				pi().api,
+				configured,
+				{
+					...(ctx(sessionId, 8) as object),
+					hasUI,
+					mode,
+					ui: { setStatus() {}, notify() {} },
+				} as never,
+				sessionId,
+				2,
+			);
+			expect(seen).toEqual([expected]);
+		} finally {
+			closeQuietly(db);
+		}
+	});
+
 	it("parses optional positive messages_to_keep", () => {
 		expect(parseWrapupArgs("")).toEqual({ ok: true, messagesToKeep: 20 });
 		expect(parseWrapupArgs(" 7 ")).toEqual({ ok: true, messagesToKeep: 7 });

packages/pi-plugin/src/commands/ctx-wrapup.ts

@@ -469,6 +469,10 @@ export async function runPiWrapup(
 					const runHistorian = deps.runPiHistorianForWrapup ?? runPiHistorian;
 					await runHistorian({
 						db: deps.db,
+						// RPC can expose UI methods without a persistent interactive host.
+						// A detached second turn would outlive the wrapup command's caller.
+						hasUI:
+							ctx.hasUI === true && (ctx as { mode?: string }).mode !== "rpc",
 						sessionId,
 						directory: ctx.cwd,
 						provider,

packages/plugin/scripts/two-pass-activation-runs/event-observer.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { underRoot } from "./activation-driver";
 
 /** Sidecars only record host events; they register no tools and change no model input. */
-export function stageEventObserver(root: string, lane: "opencode-1" | "opencode-2" | "omp") {
+export function stageEventObserver(root: string, lane: "opencode-1" | "opencode-2" | "pi" | "omp") {
     const directory = underRoot(root, join(root, "host-event-observer"));
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const eventsPath = underRoot(root, join(directory, "events.jsonl"));

packages/plugin/scripts/two-pass-activation-runs/host-adapters.ts

@@ -10,7 +10,7 @@ import { mockMeteringProxy } from "./provider-meter";
 import { readHostEvents, stageEventObserver } from "./event-observer";
 import { redactedLines } from "./credential-protocol";
 
-export type HostLane = "opencode-1" | "opencode-2" | "omp";
+export type HostLane = "opencode-1" | "opencode-2" | "pi" | "omp";
 export interface HostAdapterOptions {
     sourceRoot: string;
     mockProviderURL: string;
@@ -22,8 +22,13 @@ export interface HostAdapterOptions {
     classify?(path: string, body: string): CallBound["kind"];
     magicContext: Record<string, unknown>;
     outputCeiling: number;
+    /** Pin an explicitly installed release when comparing host versions. */
+    hostVersion?: string;
+    modelOptions?: Record<string, unknown>;
+    reasoning?: boolean;
     timeoutMs?: number;
     startupTimeoutMs?: number;
+    providerTimeoutMs?: number;
     expectTurnTwo?: boolean;
     /** Synthetic probes can add a second foreground turn and explicitly request wrapup. */
     forceWrapup?: boolean;
@@ -51,8 +56,9 @@ export function hostAdapter(lane: HostLane, options: HostAdapterOptions): Activa
     let hostPid: number | undefined;
     const processProofs = new Map<number, Isolation>();
     const logFilters: ReturnType<typeof redactedLines>[] = [];
-    const binary = (root: string) => join(root, "host-dist/node_modules/.bin", lane === "omp" ? "omp" : "opencode");
-    const entrypoint = (root: string) => join(root, lane === "omp" ? "packages/pi-plugin/dist/index.js" : lane === "opencode-2" ? "packages/plugin/dist/v2/server.js" : "packages/plugin/dist/index.js");
+    const isPi = lane === "pi" || lane === "omp";
+    const binary = (root: string) => join(root, "host-dist/node_modules/.bin", isPi ? lane : "opencode");
+    const entrypoint = (root: string) => join(root, isPi ? "packages/pi-plugin/dist/index.js" : lane === "opencode-2" ? "packages/plugin/dist/v2/server.js" : "packages/plugin/dist/index.js");
     return processActivationTransport({
         stage: (root) => ({ argv: [process.execPath, installer, "stage", options.sourceRoot, root, lane], cwd: root }),
         build: (root) => ({ argv: [process.execPath, installer, "build", options.sourceRoot, root, lane], cwd: root }),
@@ -77,12 +83,13 @@ export function hostAdapter(lane: HostLane, options: HostAdapterOptions): Activa
             const result = spawnSync(binary(input.installRoot), ["--version"], { cwd: work, env: { PATH: process.env.PATH, ...versionEnv }, encoding: "utf8" });
             versionOutput = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
             version = versionOutput.match(/\d+\.\d+\.\d+/)?.[0] ?? "";
-            if (result.status !== 0 || (lane === "opencode-1" ? !/^1\.18\.(3[1-9]|[4-9]\d|\d{3,})$/.test(version) : lane === "opencode-2" ? version !== "2.0.22" : !/18\.12\.\d+/.test(version)))
+            if (result.status !== 0 || (options.hostVersion ? version !== options.hostVersion : lane === "opencode-1" ? !/^1\.18\.(3[1-9]|[4-9]\d|\d{3,})$/.test(version) : lane === "opencode-2" ? version !== "2.0.22" : lane === "pi" ? version !== "1.4.0" : !/18\.12\.\d+/.test(version)))
                 throw new Error("host_version_not_pinned");
             proxy = await mockMeteringProxy({ upstream: options.mockProviderURL, meter: input.meter,
                 secrets, forwardCredentials: !!options.providerKeyEnv || !!options.grantFree, paidProvider: options.paidProvider,
                 onProviderAttempt: options.onProviderAttempt,
-                outputCeiling: options.outputCeiling,
+                 outputCeiling: options.outputCeiling,
+                timeoutMs: options.providerTimeoutMs,
                 // Prompt text can mention another stage; it is not evidence of this dispatch's purpose.
                 classify: options.classify ?? (() => "unclassified"),
                 async beforeDispatch() {
@@ -96,7 +103,7 @@ export function hostAdapter(lane: HostLane, options: HostAdapterOptions): Activa
             observer = stageEventObserver(root, lane);
             input.env.MC_HOST_EVENT_JSONL = observer.eventsPath;
             writeConfigs(lane, input.installRoot, work, hostEnv, proxy.url, options, observer);
-            return { argv: lane === "omp" ? [binary(input.installRoot), "--mode", "rpc", "--extension", entrypoint(input.installRoot), "--extension", observer.entrypoint]
+            return { argv: isPi ? [binary(input.installRoot), "--mode", "rpc", "--extension", entrypoint(input.installRoot), "--extension", observer.entrypoint]
                 : [binary(input.installRoot), "serve", "--hostname", "127.0.0.1", "--port", "0", "--print-logs"], cwd: work };
         },
         async connect(input) {
@@ -113,7 +120,7 @@ export function hostAdapter(lane: HostLane, options: HostAdapterOptions): Activa
             let observedStore: string | null = null;
             let sessionId = "";
             let prompt: (text: string) => Promise<unknown>;
-            if (lane === "omp") {
+            if (isPi) {
                 const lines = createInterface({ input: input.stdout });
                 const pending = new Map<string, { resolve(value: any): void; reject(error: Error): void }>();
                 const settled: Array<() => void> = [];
@@ -143,6 +150,7 @@ export function hostAdapter(lane: HostLane, options: HostAdapterOptions): Activa
                     for (;;) {
                         if (Date.now() >= end) throw new Error("omp_settlement_timeout");
                         const value = (await rpc("get_state")).data;
+                        if (lane === "pi" && value?.isStreaming === false) return value;
                         if (typeof value?.isSettled !== "boolean" || typeof value?.hasPendingAsyncWork !== "boolean")
                             throw new Error("omp_settlement_unobservable");
                         if (value.isSettled && !value.isStreaming && !value.hasPendingAsyncWork) return {
@@ -305,37 +313,39 @@ async function deadline<T>(promise: Promise<T>, timeout: number): Promise<T> {
     finally { clearTimeout(timer!); }
 }
 
-function writeConfigs(lane: HostLane, install: string, work: string, env: Record<string, string>, endpoint: string, options: HostAdapterOptions, observer: ReturnType<typeof stageEventObserver>) {
+export function writeConfigs(lane: HostLane, install: string, work: string, env: Record<string, string>, endpoint: string, options: HostAdapterOptions, observer: ReturnType<typeof stageEventObserver>) {
+    const isPi = lane === "pi" || lane === "omp";
     const providerId = options.providerId ?? "mock";
     const model = `${providerId}/${options.modelId}`;
     const plugin = lane === "opencode-2" ? join(install, "packages/plugin") : pathToFileURL(join(install, "packages/plugin/dist/index.js")).href;
     const limits = { context: 200_000, output: options.outputCeiling };
     // OpenCode's grant-free Zen path uses the public marker, not an account credential.
-    const apiKey = options.grantFree ? "public" : options.providerKeyEnv ? (lane === "omp" ? options.providerKeyEnv : `{env:${options.providerKeyEnv}}`) : "mock-only-key";
+    const apiKey = options.grantFree ? "public" : options.providerKeyEnv ? (isPi ? options.providerKeyEnv : `{env:${options.providerKeyEnv}}`) : "mock-only-key";
     const config = lane === "opencode-2" ? { plugins: [plugin, observer.directory], model,
-        providers: { [providerId]: { package: options.providerPackage ?? "@ai-sdk/openai-compatible", settings: { baseURL: `${endpoint}/v1`, apiKey }, models: { [options.modelId]: { name: options.modelId, limit: limits } } } },
+        providers: { [providerId]: { package: options.providerPackage ?? "@opencode/ai/providers/openai-compatible", settings: { baseURL: `${endpoint}/v1`, apiKey }, ...(options.modelOptions ? { body: options.modelOptions } : {}), models: { [options.modelId]: { name: options.modelId, limit: limits } } } },
         compaction: { auto: false },
     } : { plugin: [plugin, pathToFileURL(observer.entrypoint).href], model, small_model: model, enabled_providers: [providerId], autoupdate: false,
-        provider: { [providerId]: { npm: options.providerPackage ?? "@ai-sdk/openai-compatible", options: { baseURL: `${endpoint}/v1`, apiKey }, models: { [options.modelId]: { name: options.modelId, limit: limits } } } },
+        provider: { [providerId]: { npm: options.providerPackage ?? "@ai-sdk/openai-compatible", options: { baseURL: `${endpoint}/v1`, apiKey }, models: { [options.modelId]: { name: options.modelId, limit: limits, options: options.modelOptions, reasoning: options.reasoning } } } },
         compaction: { auto: false, prune: false }, agent: { title: { disable: true }, summary: { disable: true } },
     };
-    if (lane === "omp") {
+    if (isPi) {
         mkdirSync(env.PI_CODING_AGENT_DIR, { recursive: true });
         writeFileSync(join(env.PI_CODING_AGENT_DIR, "config.yml"), JSON.stringify({ defaultProvider: providerId, defaultModel: options.modelId,
             enabledModels: [model], retry: { enabled: false }, compaction: { enabled: false }, quietStartup: true, enableInstallTelemetry: false, tools: { xdev: false, intentTracing: false } }));
         const models = JSON.stringify({ providers: { [providerId]: { api: options.piApi ?? "anthropic-messages", baseUrl: endpoint, apiKey,
             ...(options.piAuth ? { auth: options.piAuth } : {}),
-            models: [{ id: options.modelId, name: options.modelId, input: ["text"], contextWindow: 200_000, maxTokens: options.outputCeiling, reasoning: false, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }] } } });
+            models: [{ id: options.modelId, name: options.modelId, input: ["text"], contextWindow: 200_000, maxTokens: options.outputCeiling, reasoning: options.reasoning ?? false, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }] } } });
         // OMP 18.12 reads YAML first; updating only JSON leaves a previously imported endpoint active.
         writeFileSync(join(env.PI_CODING_AGENT_DIR, "models.yml"), models);
         writeFileSync(join(env.PI_CODING_AGENT_DIR, "models.json"), models);
+        if (lane === "pi") writeFileSync(join(env.PI_CODING_AGENT_DIR, "settings.json"), JSON.stringify({ defaultProvider: providerId, defaultModel: options.modelId, compaction: { enabled: false }, retry: { enabled: false } }));
     } else if (lane === "opencode-2") writeFileSync(join(work, "opencode.json"), JSON.stringify(config));
     else {
         if (existsSync(join(work, "opencode.json"))) unlinkSync(join(work, "opencode.json"));
         writeFileSync(join(env.XDG_CONFIG_HOME, "opencode.json"), JSON.stringify(config));
     }
     const settings = { enabled: true, memory: { enabled: true, auto_search: { enabled: false }, git_commit_indexing: { enabled: false } },
-        embedding: { provider: "off" }, dreamer: { disable: true }, historian: { [lane === "omp" ? "omp" : "opencode"]: { model } }, ...options.magicContext };
+        embedding: { provider: "off" }, dreamer: { disable: true }, historian: { [isPi ? lane : "opencode"]: { model } }, ...options.magicContext };
     mkdirSync(join(env.XDG_CONFIG_HOME, "cortexkit"), { recursive: true });
     writeFileSync(join(env.XDG_CONFIG_HOME, "cortexkit/magic-context.jsonc"), JSON.stringify(settings));
 }

packages/plugin/scripts/two-pass-activation-runs/host-request-config.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeConfigs, type HostLane } from "./host-adapters";
+import { mockProvider } from "./mock-provider";
+import { mockMeteringProxy } from "./provider-meter";
+
+describe("host request check configuration", () => {
+    for (const lane of ["opencode-1", "opencode-2", "pi", "omp"] as HostLane[]) {
+        it(`writes documented ${lane} thinking and output settings`, () => {
+            const root = mkdtempSync(join(tmpdir(), "host-request-config-"));
+            try {
+                const env = { XDG_CONFIG_HOME: join(root, "config"), PI_CODING_AGENT_DIR: join(root, "agent") };
+                mkdirSync(env.XDG_CONFIG_HOME, { recursive: true });
+                const thinking = { thinking: { type: "enabled" } };
+                writeConfigs(lane, root, root, env, "http://127.0.0.1:1234", {
+                    sourceRoot: root, mockProviderURL: "http://127.0.0.1:1234", modelId: "deepseek-v4-flash",
+                    providerId: "deepseek", outputCeiling: 65536, reasoning: true, modelOptions: thinking,
+                    magicContext: { historian: { maxTokens: 65536, [lane === "pi" || lane === "omp" ? lane : "opencode"]: { model: "deepseek/deepseek-v4-flash" } } },
+                }, { directory: root, entrypoint: join(root, "observer.js"), eventsPath: join(root, "events.jsonl") });
+                const read = (path: string) => JSON.parse(readFileSync(path, "utf8"));
+                if (lane === "pi" || lane === "omp") {
+                    const model = read(join(env.PI_CODING_AGENT_DIR, "models.json")).providers.deepseek.models[0];
+                    expect(model.reasoning).toBe(true);
+                    expect(model.maxTokens).toBe(65536);
+                } else {
+                    const config = read(join(lane === "opencode-1" ? env.XDG_CONFIG_HOME : root, "opencode.json"));
+                    const provider = (config.providers ?? config.provider).deepseek;
+                    expect(provider.models["deepseek-v4-flash"].limit.output).toBe(65536);
+                    expect(lane === "opencode-2" ? provider.body : provider.models["deepseek-v4-flash"].options).toEqual(thinking);
+                }
+            } finally { rmSync(root, { recursive: true, force: true }); }
+        });
+    }
+});
+
+describe("capturing provider truncation", () => {
+    it("honors the configured provider timeout", async () => {
+        const upstream = Bun.serve({ hostname: "127.0.0.1", port: 0, async fetch() {
+            await Bun.sleep(200);
+            return Response.json({ usage: { prompt_tokens: 1, completion_tokens: 1 } });
+        } });
+        const proxy = await mockMeteringProxy({ upstream: upstream.url.href.replace(/\/$/, ""), timeoutMs: 20,
+            outputCeiling: 64, classify: () => "unclassified", meter: { beforeSend: () => 0, settle() {} } });
+        try {
+            const response = await fetch(proxy.url, { method: "POST", body: "{}" });
+            expect(response.status).toBe(502);
+            expect(proxy.receipts).toHaveLength(0);
+            expect(proxy.failures).toEqual(["provider_dispatch_failed"]);
+        } finally { await proxy.close(); upstream.stop(true); }
+    });
+
+    for (const stream of [false, true]) {
+        it(`captures exact bytes and emits length with stream=${stream}`, async () => {
+            const server = mockProvider(() => "complete but capped JSON", undefined, undefined, () => "length");
+            try {
+                const raw = `{ "model": "deepseek-v4-flash", "stream": ${stream}, "messages": [] }`;
+                const response = await fetch(`${server.url}/v1/chat/completions`, { method: "POST", body: raw });
+                const body = await response.text();
+                expect(server.requests[0]?.rawBody).toBe(raw);
+                expect(body).toContain('"finish_reason":"length"');
+                expect(body).not.toContain('"finish_reason":"stop"');
+            } finally { server.close(); }
+        });
+    }
+});

packages/plugin/scripts/two-pass-activation-runs/install-host.ts

@@ -5,6 +5,7 @@ import { spawnSync } from "node:child_process";
 export const hostPackages = {
     "opencode-1": "opencode-ai@1.18.31",
     "opencode-2": "@opencode/cli@2.0.22",
+    pi: "@earendil-works/pi-coding-agent@1.4.0",
     omp: "@oh-my-pi/pi-coding-agent@18.12.3",
 } as const;
 
@@ -25,14 +26,14 @@ if (import.meta.main) {
         };
         run([process.execPath, "install", "--frozen-lockfile"], root);
         run([process.execPath, "run", "--cwd", "packages/plugin", "build"], root);
-        if (lane === "omp") run([process.execPath, "run", "--cwd", "packages/pi-plugin", "build"], root);
+        if (lane === "omp" || lane === "pi") run([process.execPath, "run", "--cwd", "packages/pi-plugin", "build"], root);
         const host = join(root, "host-dist");
         mkdirSync(host, { recursive: true });
         const pinned = hostPackages[lane as keyof typeof hostPackages];
         writeFileSync(join(host, "package.json"), JSON.stringify({ private: true, trustedDependencies: [pinned.slice(0, pinned.lastIndexOf("@"))] }));
         run([process.execPath, "add", "--exact", hostPackages[lane as keyof typeof hostPackages]], host);
         if (lane === "opencode-2") run([process.execPath, join(host, "node_modules/@opencode/cli/postinstall.mjs")], host);
-        if (lane !== "omp") {
+        if (lane !== "omp" && lane !== "pi") {
             // OpenCode otherwise installs its plugin SDK on first directory initialization,
             // which cannot finish when the proof container has external networking disabled.
             const config = process.env.XDG_CONFIG_HOME;