@neta-art/cohub-cli 8.2.0 → 8.3.1

package/dist/runtime/instance.js

@@ -32,10 +32,10 @@ async function readRecord(directory) {
         throw error;
     }
 }
-function request(record, action, force = false) {
+function request(record, action, payload, timeoutMs) {
     return new Promise((resolve, reject) => {
         const socket = createConnection(record.socket);
-        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Runtime control timed out")); }, 3000);
+        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Runtime control timed out")); }, timeoutMs);
         let buffer = "";
         let settled = false;
         const finish = (error, value) => {
@@ -49,7 +49,7 @@ function request(record, action, force = false) {
             else if (value)
                 resolve(value);
         };
-        socket.on("connect", () => socket.write(`${JSON.stringify({ nonce: record.nonce, action, force })}\n`));
+        socket.on("connect", () => socket.write(`${JSON.stringify({ ...payload, nonce: record.nonce, action })}\n`));
         socket.on("error", (error) => finish(error));
         socket.on("close", () => finish(new Error("Runtime control closed")));
         socket.on("data", (chunk) => {
@@ -67,7 +67,7 @@ function request(record, action, force = false) {
                 else if (response.nonce !== record.nonce || response.status?.pid !== record.pid)
                     finish(new Error("Runtime identity changed"));
                 else
-                    finish(undefined, response.status);
+                    finish(undefined, { status: response.status, result: response.result });
             }
             catch (error) {
                 finish(error instanceof Error ? error : new Error(String(error)));
@@ -76,11 +76,15 @@ function request(record, action, force = false) {
     });
 }
 export async function requestRuntimeInstance(directory, action = "status", force = false) {
+    return (await controlRuntimeInstance(directory, action, { force }))?.status ?? null;
+}
+/** Send a control action to the running Runtime; `null` when none runs. */
+export async function controlRuntimeInstance(directory, action, payload = {}, timeoutMs = 3000) {
     const record = await readRecord(directory);
     if (!record || !alive(record.pid))
         return null;
     try {
-        return await request(record, action, force);
+        return await request(record, action, payload, timeoutMs);
     }
     catch (error) {
         // A reused PID is not proof of ownership. Missing/refused endpoints cannot
@@ -91,7 +95,7 @@ export async function requestRuntimeInstance(directory, action = "status", force
     }
 }
 /** Private local IPC is both the single-instance guard and the control surface. */
-export async function ownRuntimeInstance(directory, status, stop) {
+export async function ownRuntimeInstance(directory, status, stop, control = async () => { throw new Error("Unknown Runtime control request"); }) {
     await mkdir(directory, { recursive: true, mode: 0o700 });
     return withRuntimeSpaceBindingsLock(async () => {
         if (await requestRuntimeInstance(directory))
@@ -118,17 +122,20 @@ export async function ownRuntimeInstance(directory, status, stop) {
                 if (!input.includes("\n"))
                     return;
                 socket.removeAllListeners("data");
+                // The request arrived; answering it may take longer than an idle client is allowed.
+                socket.setTimeout(0);
                 void (async () => {
                     const message = JSON.parse(input.slice(0, input.indexOf("\n")));
                     if (message.nonce !== record.nonce) {
                         socket.destroy();
                         return;
                     }
+                    let result;
                     if (message.action === "stop")
                         await stop(message.force === true);
                     else if (message.action !== "status")
-                        throw new Error("Unknown Runtime control request");
-                    socket.end(`${JSON.stringify({ nonce: record.nonce, status: status() })}\n`);
+                        result = await control(String(message.action), message);
+                    socket.end(`${JSON.stringify({ nonce: record.nonce, status: status(), ...(result === undefined ? {} : { result }) })}\n`);
                 })().catch((error) => socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`));
             });
         });

package/dist/runtime/launch.js

@@ -9,8 +9,8 @@ import { requireAccessToken } from "../auth.js";
 import { createClient } from "../client.js";
 import { currentIdentityKey, explicitSpace } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding, resolveRuntimeSpace } from "./space-binding.js";
-import { requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
-import { ensureNativeSync } from "./native-attach.js";
+import { controlRuntimeInstance, requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
+import { ensureNativeSync, repairIntegrations } from "./native/attach.js";
 import { createDiagnosticConsole, printRuntimeSummary, runtimeWebUrl } from "./presentation.js";
 import { runRuntime } from "./supervisor.js";
 export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(root) || "local-space";
@@ -93,7 +93,12 @@ export async function runtimeUp(program, dir, options) {
             }
             // `up` is the single idempotent entry: a reused instance adopts its running
             // Harnesses (unless explicitly overridden) and completes native sync setup.
-            await ensureNativeSync({ root, spaceId: existing.spaceId, identity, harnesses: options.harness.length ? harnesses : parseRuntimeHarnesses(existing.harnesses), yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
+            const native = await ensureNativeSync({ root, spaceId: existing.spaceId, identity, harnesses: options.harness.length ? harnesses : parseRuntimeHarnesses(existing.harnesses), yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
+            // The running Runtime applies consent given now without restarting.
+            const directory = runtimeInstanceDirectory(identity, existing.spaceId);
+            await controlRuntimeInstance(directory, "reload").catch(() => undefined);
+            if (native.importHistory)
+                await controlRuntimeInstance(directory, "import", { command: "start" }, 60_000).catch(() => undefined);
             printRuntimeSummary(existing, options.json, true);
             return;
         }
@@ -139,6 +144,7 @@ export async function runtimeUp(program, dir, options) {
     if (createNew && binding && await requestRuntimeInstance(runtimeInstanceDirectory(identity, binding.spaceId))) {
         throw new Error("Stop the existing Runtime before rebinding this directory");
     }
+    await repairIntegrations(options.pi);
     // Fail local preflight before creating remote state; the worker reuses this catalog.
     const capabilities = await discoverHarnesses(harnesses, options, root);
     const client = createClient();
@@ -153,8 +159,8 @@ export async function runtimeUp(program, dir, options) {
         },
     });
     // Consent (or --yes) precedes any user-level integration install; failure never blocks startup.
-    await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
-    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose };
+    const native = await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
+    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose, importHistory: native.importHistory };
     const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
     if (existing) {
         if (existing.root !== root)

package/dist/runtime/native/adapters.d.ts

@@ -0,0 +1,32 @@
+import { type NativeTranscript, type NativeTranscriptTurn } from "./transcript.js";
+export type { NativeTranscript, NativeTranscriptTurn };
+export type Harness = "pi" | "codex";
+/**
+ * Why a Codex thread exists. Codex writes every thread it starts into one rollout tree: the user's
+ * conversations, its own background work (guardian reviews, compaction, memory consolidation) and
+ * agents spawned from a conversation.
+ */
+export type ThreadKind = "user" | "internal" | "spawned";
+export type SessionHeader = {
+    harness: Harness;
+    nativeSessionId: string;
+    cwd: string;
+    thread: ThreadKind;
+};
+/** Directories holding this harness's transcripts; a transcript's header says which project it is. */
+export declare function transcriptRoots(harness: Harness): string[];
+/** Pi's encoding of a project directory into its session folder name. */
+export declare const piSessionDirectoryName: (cwd: string) => string;
+/** Whether a directory found under a root can hold transcripts of `cwd`. */
+export declare function acceptsDirectory(path: string, root: string, harness: Harness, cwd: string): boolean;
+/** Name-only check: can this path hold a transcript of this harness for `cwd`? */
+export declare function acceptsTranscript(path: string, harness: Harness, cwd: string): boolean;
+/** Codex's first line is the only place a thread's purpose is recorded. */
+export declare function codexThreadKind(payload: Record<string, unknown>): ThreadKind;
+/** The first line of a transcript: identity, project and purpose. Nothing else is read. */
+export declare function readSessionHeader(path: string, harness: Harness, signal?: AbortSignal): Promise<SessionHeader | null>;
+/**
+ * Parse a transcript into Turns. Codex records its own Turn boundary; a Pi Turn's end is inferred
+ * by the caller, so Pi is parsed as settled here and the caller withdraws a tail still in flight.
+ */
+export declare function readTranscript(path: string, harness: Harness, signal?: AbortSignal): Promise<NativeTranscript>;

package/dist/runtime/native/adapters.js

@@ -0,0 +1,79 @@
+import { createReadStream } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { codexArchivedSessionsDirectory, codexRolloutBytes, codexRolloutIdOf, codexSessionsDirectory, readNativeTranscript } from "./transcript.js";
+const text = (value) => typeof value === "string" ? value : "";
+const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const HEADER_MAX_BYTES = 1024 * 1024;
+/** Directories holding this harness's transcripts; a transcript's header says which project it is. */
+export function transcriptRoots(harness) {
+    if (harness === "codex")
+        return [codexSessionsDirectory(), codexArchivedSessionsDirectory()];
+    const custom = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
+    if (custom)
+        return [custom];
+    return [join(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"), "sessions")];
+}
+/** Pi's encoding of a project directory into its session folder name. */
+export const piSessionDirectoryName = (cwd) => `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+/** Whether a Pi project folder may hold sessions of `cwd` or a subdirectory of it. */
+function piProjectFolderMatches(folder, cwd) {
+    const project = piSessionDirectoryName(cwd).slice(0, -2);
+    const name = basename(folder);
+    return name === `${project}--` || name.startsWith(`${project}-`);
+}
+/** Whether a directory found under a root can hold transcripts of `cwd`. */
+export function acceptsDirectory(path, root, harness, cwd) {
+    if (harness === "codex" || process.env.PI_CODING_AGENT_SESSION_DIR?.trim() || dirname(path) !== root)
+        return true;
+    return piProjectFolderMatches(path, cwd);
+}
+/** Name-only check: can this path hold a transcript of this harness for `cwd`? */
+export function acceptsTranscript(path, harness, cwd) {
+    const name = basename(path);
+    if (harness === "codex")
+        return codexRolloutIdOf(name) !== null;
+    return name.endsWith(".jsonl") && (Boolean(process.env.PI_CODING_AGENT_SESSION_DIR?.trim()) || piProjectFolderMatches(dirname(path), cwd));
+}
+async function firstRecord(bytes) {
+    const chunks = [];
+    let buffered = 0;
+    for await (const chunk of bytes) {
+        chunks.push(chunk);
+        buffered += chunk.length;
+        const newline = chunk.indexOf(10);
+        if (newline >= 0)
+            return record(JSON.parse(Buffer.concat(chunks, buffered).subarray(0, buffered - chunk.length + newline).toString("utf8")));
+        if (buffered > HEADER_MAX_BYTES)
+            throw new Error("Native session header is too large");
+    }
+    throw new Error("Native transcript is empty");
+}
+/** Codex's first line is the only place a thread's purpose is recorded. */
+export function codexThreadKind(payload) {
+    const source = payload.source;
+    if (source && typeof source === "object")
+        return record(record(source).subagent).thread_spawn ? "spawned" : "internal";
+    return ["subagent", "guardian_review", "memory_consolidation"].includes(text(payload.thread_source)) ? "internal" : "user";
+}
+/** The first line of a transcript: identity, project and purpose. Nothing else is read. */
+export async function readSessionHeader(path, harness, signal) {
+    if (harness === "pi") {
+        const header = await firstRecord(createReadStream(path, { signal }));
+        if (header.type !== "session" || !text(header.id) || !text(header.cwd))
+            return null;
+        return { harness, nativeSessionId: text(header.id), cwd: text(header.cwd), thread: "user" };
+    }
+    const header = await firstRecord(codexRolloutBytes(path, null, signal));
+    const payload = record(header.payload);
+    if (header.type !== "session_meta" || !text(payload.id) || !text(payload.cwd))
+        return null;
+    return { harness, nativeSessionId: text(payload.id), cwd: text(payload.cwd), thread: codexThreadKind(payload) };
+}
+/**
+ * Parse a transcript into Turns. Codex records its own Turn boundary; a Pi Turn's end is inferred
+ * by the caller, so Pi is parsed as settled here and the caller withdraws a tail still in flight.
+ */
+export async function readTranscript(path, harness, signal) {
+    return await readNativeTranscript(path, harness, { settled: harness === "pi", signal });
+}

package/dist/runtime/{native-archive.d.ts → native/archive.d.ts}

@@ -1,9 +1,7 @@
-import { type CodexTokenTotals } from "./codex-usage.js";
 /** A structurally unrestorable archive (e.g. its history reference is not carried); never retried. */
 export declare class ArchiveNotRestorableError extends Error {
     constructor(message: string);
 }
-export declare function readCodexArchiveTotals(path: string): Promise<CodexTokenTotals | undefined>;
 /** Change only the header of a working copy. Raw archive bytes remain untouched. */
 export declare function importNativeArchive(input: {
     source: string;
@@ -16,5 +14,4 @@ export declare function importNativeArchive(input: {
 }): Promise<{
     checksum: string;
     nativeSessionId: string;
-    codexTokenTotals: CodexTokenTotals | undefined;
 }>;

package/dist/runtime/{native-archive.js → native/archive.js}

@@ -3,20 +3,10 @@ import { createReadStream } from "node:fs";
 import { link, mkdir, open, rm } from "node:fs/promises";
 import { dirname } from "node:path";
 import { RUNTIME_MAX_FRAME_BYTES } from "@neta-art/cohub";
-import { JsonLineDecoder } from "./json-rpc.js";
-import { codexArchiveTotals } from "./codex-usage.js";
 /** A structurally unrestorable archive (e.g. its history reference is not carried); never retried. */
 export class ArchiveNotRestorableError extends Error {
     constructor(message) { super(message); this.name = "ArchiveNotRestorableError"; }
 }
-export async function readCodexArchiveTotals(path) {
-    let totals;
-    const decoder = new JsonLineDecoder((row) => { totals = codexArchiveTotals([row]) ?? totals; });
-    for await (const bytes of createReadStream(path))
-        decoder.push(bytes);
-    decoder.end();
-    return totals;
-}
 /** Change only the header of a working copy. Raw archive bytes remain untouched. */
 export async function importNativeArchive(input) {
     await mkdir(dirname(input.target), { recursive: true, mode: 0o700 });
@@ -25,8 +15,6 @@ export async function importNativeArchive(input) {
     const digest = createHash("sha256");
     let headerReady = false, headerBytes = 0;
     const fragments = [];
-    let totals;
-    const decoder = input.harness === "codex" ? new JsonLineDecoder((row) => { totals = codexArchiveTotals([row]) ?? totals; }) : null;
     const write = async (bytes) => { digest.update(bytes); await file.writeFile(bytes); };
     const writeHeader = async () => {
         const header = JSON.parse(Buffer.concat(fragments).toString("utf8"));
@@ -39,8 +27,7 @@ export async function importNativeArchive(input) {
         else {
             if (header?.type !== "session_meta" || header.payload?.id !== input.nativeSessionId)
                 throw new Error("Codex archive identity mismatch");
-            // A leaf archive does not carry its ancestor rollout. Importing it as-is would resume with
-            // silently truncated history; failing lets the caller rebuild from durable cloud Turns.
+            // A leaf archive does not carry its ancestor rollout.
             if (header.payload?.history_base != null)
                 throw new ArchiveNotRestorableError("Codex archive references history it does not carry; rebuild from the Session instead");
             header.payload.id = input.id;
@@ -55,7 +42,6 @@ export async function importNativeArchive(input) {
     };
     try {
         for await (const bytes of createReadStream(input.source, { signal: input.signal })) {
-            decoder?.push(bytes);
             if (headerReady) {
                 await write(bytes);
                 continue;
@@ -73,7 +59,6 @@ export async function importNativeArchive(input) {
         }
         if (!headerReady)
             await writeHeader();
-        decoder?.end();
         input.signal?.throwIfAborted();
         await file.sync();
         await file.close();
@@ -87,7 +72,7 @@ export async function importNativeArchive(input) {
                 await directory.close();
             }
         }
-        return { checksum: digest.digest("hex"), nativeSessionId: input.harness === "pi" ? input.nativeSessionId : input.id, codexTokenTotals: totals };
+        return { checksum: digest.digest("hex"), nativeSessionId: input.harness === "pi" ? input.nativeSessionId : input.id };
     }
     finally {
         await file.close();

package/dist/runtime/native/attach.d.ts

@@ -0,0 +1,38 @@
+import type { Harness } from "./adapters.js";
+import { type NativeConfig } from "./config.js";
+export type NativeSyncReport = {
+    enabled: boolean;
+    harnesses: Harness[];
+    codexShared: boolean;
+    importHistory: boolean;
+    note?: string;
+};
+type Input = {
+    root: string;
+    spaceId: string;
+    identity: string;
+    harnesses: Harness[];
+    yes?: boolean;
+    executables?: {
+        pi?: string;
+        codex?: string;
+    };
+};
+type Ask = (question: string) => Promise<boolean>;
+/** Whether this directory already syncs every requested harness. */
+export declare function nativeSyncSatisfied(config: NativeConfig | null, input: {
+    spaceId: string;
+    root: string;
+    harnesses: Harness[];
+}): boolean;
+/**
+ * Enable native sync after consent. Native history may contain secrets, so nothing is read before
+ * the user agrees; a failure here never blocks the Runtime, it only leaves sessions read-only.
+ */
+export declare function ensureNativeSync(input: Input, log?: (line: string) => void, ask?: Ask): Promise<NativeSyncReport>;
+/**
+ * Before any harness starts, repair what earlier releases installed: an outdated Pi extension can keep
+ * Pi from starting, and legacy Codex hooks run a script that is gone. Both had consent back then.
+ */
+export declare function repairIntegrations(piBinary: string | undefined, log?: (line: string) => void): Promise<void>;
+export {};

package/dist/runtime/native/attach.js

@@ -0,0 +1,113 @@
+import { createInterface } from "node:readline/promises";
+import { serializeDiagnosticError } from "../diagnostics.js";
+import { CODEX_SHARED_MIN_VERSION, supportsSharedServer } from "./codex-link.js";
+import { PI_MIN_VERSION } from "./pi-link.js";
+import { atLeast, formatVersion, harnessVersion } from "./version.js";
+import { readNativeConfig, runtimeStateRoot, writeNativeConfig } from "./config.js";
+import { discoverTranscripts } from "./ingest.js";
+import { installPiExtension, piExtensionState, removeLegacyCodexHooks } from "./install.js";
+/** Whether this directory already syncs every requested harness. */
+export function nativeSyncSatisfied(config, input) {
+    return Boolean(config && config.spaceId === input.spaceId && config.root === input.root && input.harnesses.every((harness) => config.harnesses.includes(harness)));
+}
+async function defaultAsk(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return /^(|y(es)?)$/i.test((await rl.question(question)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Enable native sync after consent. Native history may contain secrets, so nothing is read before
+ * the user agrees; a failure here never blocks the Runtime, it only leaves sessions read-only.
+ */
+export async function ensureNativeSync(input, log = (line) => process.stderr.write(line), ask = defaultAsk) {
+    const stateRoot = runtimeStateRoot(input.spaceId);
+    const previous = await readNativeConfig(stateRoot, input.identity).catch(() => null);
+    if (previous && nativeSyncSatisfied(previous, input)) {
+        await maintain(previous, log, input.executables?.pi);
+        return { enabled: true, harnesses: previous.harnesses, codexShared: previous.codexShared, importHistory: false };
+    }
+    const interactive = process.stdin.isTTY === true;
+    const confirm = async (question) => input.yes ? true : interactive ? await ask(question) : false;
+    if (!input.yes && !interactive) {
+        log("Native sync off · rerun interactively or with --yes to enable\n");
+        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
+    }
+    const names = input.harnesses.map((harness) => harness === "pi" ? "Pi" : "Codex").join(" and ");
+    if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
+        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
+    }
+    let codexShared = previous?.codexShared ?? false;
+    if (input.harnesses.includes("codex") && !codexShared) {
+        const version = await harnessVersion(input.executables?.codex || "codex");
+        if (!supportsSharedServer(version)) {
+            log(`Codex ${formatVersion(version)} predates the shared app-server (${CODEX_SHARED_MIN_VERSION.join(".")}+); terminal Codex chats sync read-only\n`);
+        }
+        else {
+            codexShared = await confirm("Let terminal Codex and the web drive the same live sessions? Cohub starts Codex's shared app-server, which keeps running in the background. [Y/n] ");
+        }
+    }
+    const harnesses = [...new Set([...(previous?.root === input.root ? previous.harnesses : []), ...input.harnesses])];
+    const config = {
+        version: 2, identity: input.identity, spaceId: input.spaceId, root: input.root, harnesses,
+        // History is whatever existed before the first consent for this directory.
+        enabledAt: previous?.root === input.root ? previous.enabledAt : new Date().toISOString(),
+        codexShared,
+    };
+    try {
+        await writeNativeConfig(stateRoot, config);
+    }
+    catch (error) {
+        log(`Native sync unavailable; Runtime continues without it — ${serializeDiagnosticError(error).message}\n`);
+        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "config" };
+    }
+    await maintain(config, log, input.executables?.pi, true);
+    const history = (await discoverTranscripts(input.root, input.harnesses, { headers: true }).catch(() => []))
+        .filter((candidate) => candidate.mtimeMs < Date.parse(config.enabledAt)).length;
+    let importHistory = false;
+    if (history && !previous) {
+        importHistory = await confirm(`Import ${history} earlier conversation${history === 1 ? "" : "s"} from this folder? [Y/n] `);
+        if (!importHistory)
+            log("Import them later with cohub runtime import\n");
+    }
+    return { enabled: true, harnesses, codexShared, importHistory };
+}
+/** Keep integrations current on every `up`. */
+async function maintain(config, log, piBinary, announce = false) {
+    if (config.harnesses.includes("pi"))
+        await maintainPiExtension(piBinary, log, announce);
+}
+/**
+ * Before any harness starts, repair what earlier releases installed: an outdated Pi extension can keep
+ * Pi from starting, and legacy Codex hooks run a script that is gone. Both had consent back then.
+ */
+export async function repairIntegrations(piBinary, log = (line) => process.stderr.write(line)) {
+    await removeLegacyCodexHooks().catch(() => undefined);
+    if (await piExtensionState().catch(() => null) === "outdated")
+        await maintainPiExtension(piBinary, log);
+}
+/** Pi without the extension still syncs, read-only. */
+async function maintainPiExtension(piBinary, log, announce = false) {
+    const version = await harnessVersion(piBinary || "pi");
+    if (!atLeast(version, PI_MIN_VERSION)) {
+        log(`Pi ${formatVersion(version)} predates the Cohub extension (${PI_MIN_VERSION.join(".")}+); Pi chats sync read-only\n`);
+        return;
+    }
+    try {
+        const state = await piExtensionState();
+        if (state === "installed")
+            return;
+        if (state === "foreign" || state === "missing" && !announce) {
+            log("Pi extension not installed; Pi chats sync read-only. Install with cohub runtime attach --harness pi\n");
+            return;
+        }
+        await installPiExtension();
+        log(state === "outdated" ? "Pi extension updated; run /reload in open Pi sessions\n" : "Pi extension installed; run /reload in open Pi sessions to connect them\n");
+    }
+    catch (error) {
+        log(`Pi extension not installed — ${serializeDiagnosticError(error).message}; Pi chats sync read-only\n`);
+    }
+}

package/dist/runtime/native/codex-link.d.ts

@@ -0,0 +1,40 @@
+import { type JsonRpcProcess, type JsonRecord } from "../json-rpc.js";
+import { type Version } from "./version.js";
+/** First Codex release whose terminal client attaches to a shared app-server by default. */
+export declare const CODEX_SHARED_MIN_VERSION: Version;
+export type CodexEvent = {
+    method: string;
+    params: JsonRecord;
+};
+/** One JSON-RPC peer of an app-server, over either a shared control socket or a private stdio process. */
+export interface CodexChannel {
+    request(method: string, params?: JsonRecord, timeoutMs?: number): Promise<JsonRecord>;
+    refuse(id: string | number, message: string): void;
+    onEvent(listener: (event: CodexEvent & {
+        id?: string | number;
+    }) => void): () => void;
+    onClose(listener: (error: Error) => void): () => void;
+    close(): Promise<void>;
+    readonly shared: boolean;
+    readonly closed: boolean;
+}
+export declare const supportsSharedServer: (version: Version | null) => boolean;
+/** A private app-server over stdio, used when no shared one is available; it lives for one Turn. */
+export declare function openPrivateServer(rpc: JsonRpcProcess): Promise<CodexChannel>;
+/** The Runtime's connection to the shared app-server. */
+export declare class CodexShared {
+    private readonly binary;
+    private readonly cwd;
+    enabled: boolean;
+    private channel;
+    private opening;
+    private ensured;
+    private readonly connectListeners;
+    readonly driving: Set<string>;
+    constructor(binary: string, cwd: string, enabled: boolean);
+    get(): Promise<CodexChannel | null>;
+    onConnect(listener: (channel: CodexChannel) => void): () => void;
+    join(threadId: string): Promise<JsonRecord | null>;
+    interrupt(threadId: string, turnId: string): Promise<boolean>;
+    close(): Promise<void>;
+}