@neta-art/cohub-cli 8.2.0 → 8.3.1

package/dist/runtime/supervisor.js

@@ -12,9 +12,10 @@ import { discoverHarnesses } from "./harness.js";
 import { RuntimeDiagnostics, serializeDiagnosticError } from "./diagnostics.js";
 import { ownRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
 import { createDiagnosticConsole } from "./presentation.js";
-import { RuntimeSessionStore } from "./session-store.js";
-import { captureNativeSession, flushNativeSessions, nativeWebSocketTransport, summarizeNativeSyncErrors } from "./native-sync.js";
-import { serveNativeDaemon } from "./native-ipc.js";
+import { join } from "node:path";
+import { RuntimeArchiveStore } from "./archive-store.js";
+import { readNativeConfig, runtimeStateRoot } from "./native/config.js";
+import { NativeRuntime } from "./native/daemon.js";
 export function sandboxOutputLevel(value, stream) {
     const level = typeof value === "string" ? value.toLowerCase() : "";
     if (["debug", "info", "warn", "error"].includes(level))
@@ -29,19 +30,28 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     process.once("SIGTERM", stop);
     const client = createClient();
     const space = client.space(config.spaceId);
-    const store = new RuntimeSessionStore(config.spaceId, { projectionSource: space, archiveTransport: space });
+    const stateRoot = runtimeStateRoot(config.spaceId);
+    const archives = new RuntimeArchiveStore(join(stateRoot, "archives"), space);
     const consoleSink = config.background ? undefined : createDiagnosticConsole(config.verbose);
     const diagnostics = new RuntimeDiagnostics({
-        root: store.root, spaceId: config.spaceId, runtimeId: randomUUID(),
+        root: stateRoot, spaceId: config.spaceId, runtimeId: randomUUID(),
         onEvent: (event) => { consoleSink?.(event); onDiagnostic?.(event); },
     });
-    store.setDiagnostics(diagnostics);
+    archives.setErrorReporter((error, index) => diagnostics.log("warn", "archive.upload_pending", { error: serializeDiagnosticError(error) }, {
+        component: "archive", sessionId: index?.sessionId, turnId: index?.turnId, harness: index?.harness,
+    }));
+    const native = new NativeRuntime({
+        spaceId: config.spaceId, root: config.root, stateRoot, harnesses: config.harnesses, executables: config.executables,
+        identity: config.identity, config: await readNativeConfig(stateRoot, config.identity).catch(() => null),
+        archives, projectionSource: space, diagnostics,
+    });
     let status = {
         spaceId: config.spaceId, root: config.root, runtimeId: diagnostics.runtimeId,
         pid: process.pid, harnesses: config.harnesses, background: config.background,
         state: "starting", harnessConnected: false, workspaceConnected: false,
         diagnosticsPath: diagnostics.directory,
     };
+    const summary = () => ({ ...status, native: native.status() });
     let hasBeenReady = false;
     const update = (patch) => {
         const next = { ...status, ...patch };
@@ -59,9 +69,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     };
     let closeInstance;
     let bridgeTask;
-    let nativeSyncTask;
-    let closeNativeDaemon;
-    let nativeSend = null;
+    let nativeStarted = false;
     let tokenInFlight = null;
     const token = (forceRefresh = false) => {
         tokenInFlight ??= (async () => {
@@ -77,15 +85,15 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
         return tokenInFlight;
     };
     try {
-        closeInstance = await ownRuntimeInstance(runtimeInstanceDirectory(config.identity, config.spaceId), () => status, async (force) => {
+        closeInstance = await ownRuntimeInstance(runtimeInstanceDirectory(config.identity, config.spaceId), summary, async (force) => {
             if (!force)
-                for await (const batch of store.pendingExecutionBatches()) {
+                for await (const batch of native.executor.results.pendingBatches()) {
                     if (batch.length)
                         throw new Error("Unconfirmed executions remain. Use down --yes to stop; results and files are retained");
                 }
             update({ state: "stopping" });
             setTimeout(stop, 30);
-        });
+        }, (action, message) => native.control(action, message));
         onState({ ...status });
         diagnostics.log("info", "runtime.cli_started", { platform: process.platform, node: process.versions.node, harnesses: config.harnesses });
         const [binary, capabilities] = await Promise.all([
@@ -220,105 +228,22 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
             }
         };
         bridgeTask = runBridge();
-        // Native reconciliation is event-driven: captures and channel reconnects wake it, while failures
-        // get bounded exponential retries so idle Runtimes do not scan every few seconds.
-        let nativeWakePending = true;
-        let nativeWake = null;
-        let nativeRetryTimer;
-        let nativeRetryDelay = 1000;
-        const wakeNativeSync = () => {
-            nativeWakePending = true;
-            // A new capture may wake healthy work, but it must not cancel a failed receipt's backoff.
-            if (!nativeRetryTimer) {
-                nativeWake?.();
-                nativeWake = null;
-            }
-        };
-        const waitForNativeWake = async () => {
-            if (nativeWakePending && !nativeRetryTimer) {
-                nativeWakePending = false;
-                return;
-            }
-            await new Promise((resolve) => {
-                const finish = () => {
-                    signal.removeEventListener("abort", finish);
-                    if (nativeWake === finish)
-                        nativeWake = null;
-                    resolve();
-                };
-                nativeWake = finish;
-                signal.addEventListener("abort", finish, { once: true });
-                if (signal.aborted)
-                    finish();
-            });
-            nativeWakePending = false;
-        };
-        nativeSyncTask = (async () => {
-            let lastFailureLogAt = 0;
-            let failureStartedAt = 0;
-            let accumulatedErrors = [];
-            while (!signal.aborted) {
-                await waitForNativeWake();
-                if (signal.aborted)
-                    break;
-                if (!nativeSend)
-                    continue;
-                let failed = false;
-                const cycleErrors = [];
-                try {
-                    failed = await flushNativeSessions(config.spaceId, config.identity, signal, (error) => cycleErrors.push(error), nativeWebSocketTransport(config.spaceId, config.identity, nativeSend));
-                }
-                catch (error) {
-                    if (!signal.aborted) {
-                        cycleErrors.push(error);
-                        failed = true;
-                    }
-                }
-                if (cycleErrors.length && !signal.aborted) {
-                    const now = Date.now();
-                    failureStartedAt ||= now;
-                    accumulatedErrors.push(...cycleErrors);
-                    if (!lastFailureLogAt || now - lastFailureLogAt >= 60_000) {
-                        diagnostics.log("warn", "native.sync_pending", {
-                            failedStores: accumulatedErrors.length,
-                            retryInMs: nativeRetryDelay,
-                            errors: summarizeNativeSyncErrors(accumulatedErrors),
-                        });
-                        accumulatedErrors = [];
-                        lastFailureLogAt = now;
-                    }
-                }
-                else if (!signal.aborted && !failed && failureStartedAt) {
-                    diagnostics.log("info", "native.sync_recovered", { durationMs: Date.now() - failureStartedAt });
-                    failureStartedAt = 0;
-                    lastFailureLogAt = 0;
-                    accumulatedErrors = [];
-                }
-                if (failed && !signal.aborted) {
-                    nativeWakePending = false;
-                    if (!nativeRetryTimer)
-                        nativeRetryTimer = setTimeout(() => { nativeRetryTimer = undefined; wakeNativeSync(); }, nativeRetryDelay);
-                    nativeRetryDelay = Math.min(30_000, nativeRetryDelay * 2);
-                }
-                else if (!failed) {
-                    nativeRetryDelay = 1000;
-                }
-            }
-            if (nativeRetryTimer)
-                clearTimeout(nativeRetryTimer);
-        })();
-        closeNativeDaemon = await serveNativeDaemon({ runtimeRoot: store.root, handle: async (request) => {
-                const result = { store: await captureNativeSession(request) };
-                if (result.store)
-                    wakeNativeSync();
-                return result;
-            } });
+        await native.start(signal);
+        nativeStarted = true;
+        let importRequested = Boolean(config.importHistory);
         await serveRuntime({
             spaceId: config.spaceId, cwd: config.root, url: url.toString(), capabilities,
-            harnesses: config.executables, runtimeId: status.runtimeId, diagnostics, token, signal, store,
+            runtimeId: status.runtimeId, diagnostics, token, signal, executor: native.executor,
             onReady: () => update({ harnessConnected: true }),
-            onDisconnected: () => { nativeSend = null; update({ harnessConnected: false }); },
-            onNativeChannel: (send) => { nativeSend = send; wakeNativeSync(); },
+            onDisconnected: () => { native.connect(null); update({ harnessConnected: false }); },
+            onNativeStop: (stop) => { native.stop(stop.sessionId, stop.turnId); },
+            onNativeChannel: (send) => {
+                native.connect(send);
+                if (!importRequested)
+                    return;
+                importRequested = false;
+                void native.control("import", { command: "start" }).catch((error) => diagnostics.log("warn", "native.import_failed", { error: serializeDiagnosticError(error) }));
+            },
         });
     }
     catch (error) {
@@ -331,8 +256,9 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     finally {
         controller.abort();
         try {
-            await Promise.all([bridgeTask, nativeSyncTask]);
-            await closeNativeDaemon?.();
+            await bridgeTask;
+            if (nativeStarted)
+                await native.close(AbortSignal.timeout(5_000));
         }
         finally {
             try {

package/dist/runtime/turn-projection.d.ts

@@ -30,14 +30,12 @@ export type SessionTurnProjectionClient = {
     };
 };
 export type ProjectionSourceTurn = CanonicalProjectionTurn;
-export declare function hydrateSessionTurn(turn: SessionTurnRecord, client: ReturnType<SessionTurnProjectionClient["session"]>, signal?: AbortSignal): Promise<CanonicalProjectionTurn>;
 export declare function listSessionProjectionTurns(source: SessionTurnProjectionClient, sessionId: string, options?: {
     afterSequence?: number | null;
     throughSequence?: number | null;
     excludeTurnId?: string | null;
     signal?: AbortSignal;
 }): Promise<ProjectionSourceTurn[]>;
-export declare function getSessionProjectionTurn(source: SessionTurnProjectionClient, sessionId: string, turnId: string, signal?: AbortSignal): Promise<CanonicalProjectionTurn>;
 export declare function projectTurnBatch(input: Omit<ProjectionInput, "turns"> & {
     turns: ProjectionSourceTurn[];
-}, target: ProjectionTarget, includeHeader?: boolean): import("@neta-art/cohub").NativeProjection;
+}, target: ProjectionTarget): import("@neta-art/cohub").NativeProjection;

package/dist/runtime/turn-projection.js

@@ -57,7 +57,7 @@ async function mapWithConcurrency(items, concurrency, mapper) {
     await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
     return results;
 }
-export async function hydrateSessionTurn(turn, client, signal) {
+async function hydrateSessionTurn(turn, client, signal) {
     const sourceId = sourceSessionId(turn);
     const messages = [];
     if (turn.userContent.length) {
@@ -115,13 +115,6 @@ export async function listSessionProjectionTurns(source, sessionId, options = {}
     }
     return mapWithConcurrency(turns, 4, (turn) => hydrateSessionTurn(turn, client, options.signal));
 }
-export async function getSessionProjectionTurn(source, sessionId, turnId, signal) {
-    const client = source.session(sessionId);
-    return hydrateSessionTurn((await client.turns.get(turnId, { signal })).turn, client, signal);
-}
-export function projectTurnBatch(input, target, includeHeader = true) {
-    const projection = projectNativeSession(input, target);
-    if (includeHeader)
-        return projection;
-    return { ...projection, records: projection.records.filter((record) => record.sourceTurnId !== null) };
+export function projectTurnBatch(input, target) {
+    return projectNativeSession(input, target);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.2.0",
+  "version": "8.3.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -22,7 +22,8 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.21.1"
+    "ws": "^8.21.3",
+    "@neta-art/cohub": "8.22.0"
   },
   "publishConfig": {
     "access": "public"
@@ -30,8 +31,7 @@
   "devDependencies": {
     "@types/node": "^26.4.0",
     "@types/ws": "^8.18.1",
-    "typescript": "^7.0.2",
-    "ws": "^8.21.3"
+    "typescript": "^7.0.2"
   },
   "optionalDependencies": {
     "@napi-rs/canvas": "^1.0.8"
@@ -42,7 +42,6 @@
     "test": "node ../../scripts/test/run.mjs 'tests/**/*.test.ts'",
     "test:runtime": "node --import tsx --test tests/runtime-*.integration.ts",
     "test:runtime:native": "node --import tsx tests/runtime-native.smoke.ts",
-    "test:runtime:plugins": "node scripts/test-native-plugins.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }

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

@@ -1,28 +0,0 @@
-import { type NativeSyncConfig } from "./native-sync.js";
-type Harness = "pi" | "codex";
-export type NativeSyncReport = {
-    enabled: boolean;
-    harnesses: Harness[];
-    note?: string;
-};
-/** Already enabled for this exact directory and every requested Harness: installation is idempotent. */
-export declare function nativeSyncSatisfied(config: NativeSyncConfig | null, input: {
-    spaceId: string;
-    root: string;
-    harnesses: Harness[];
-}): boolean;
-/** One explicit consent prompt, defaulting to yes; native history may contain secrets. */
-export declare function askNativeSyncConsent(harnesses: Harness[], ask?: (question: string) => Promise<string>): Promise<boolean>;
-/** Enable native sync after consent; capability or write failures warn and never block the Runtime. */
-export declare function ensureNativeSync(input: {
-    root: string;
-    spaceId: string;
-    identity: string;
-    harnesses: Harness[];
-    yes?: boolean;
-    executables?: {
-        pi?: string;
-        codex?: string;
-    };
-}, log?: (line: string) => void): Promise<NativeSyncReport>;
-export {};

package/dist/runtime/native-attach.js

@@ -1,47 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { installNativeSync } from "./native-install.js";
-import { nativeRuntimeRoot, readNativeSyncConfig } from "./native-sync.js";
-import { serializeDiagnosticError } from "./diagnostics.js";
-/** Already enabled for this exact directory and every requested Harness: installation is idempotent. */
-export function nativeSyncSatisfied(config, input) {
-    return Boolean(config && config.spaceId === input.spaceId && config.root === input.root && input.harnesses.every((harness) => config.harnesses.includes(harness)));
-}
-/** One explicit consent prompt, defaulting to yes; native history may contain secrets. */
-export async function askNativeSyncConsent(harnesses, ask = defaultAsk) {
-    const answer = await ask(`Sync native ${harnesses.join(" / ")} chats in this folder and upload their history (may contain secrets) to this Space? [Y/n] `);
-    return /^(|y(es)?)$/i.test(answer.trim());
-}
-async function defaultAsk(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    try {
-        return await rl.question(question);
-    }
-    finally {
-        rl.close();
-    }
-}
-/** Enable native sync after consent; capability or write failures warn and never block the Runtime. */
-export async function ensureNativeSync(input, log = (line) => process.stderr.write(line)) {
-    const config = await readNativeSyncConfig(nativeRuntimeRoot(input.spaceId), input.identity).catch(() => null);
-    if (nativeSyncSatisfied(config, input))
-        return { enabled: true, harnesses: config?.harnesses ?? [] };
-    if (!input.yes) {
-        // Non-interactive sessions cannot consent; they continue without sync instead of failing `up`.
-        if (!process.stdin.isTTY) {
-            log("Native sync off · rerun interactively or with --yes to enable\n");
-            return { enabled: false, harnesses: input.harnesses, note: "non-interactive" };
-        }
-        if (!await askNativeSyncConsent(input.harnesses))
-            return { enabled: false, harnesses: input.harnesses, note: "declined" };
-    }
-    try {
-        const result = await installNativeSync(input);
-        log(`Native sync enabled. Reload Pi or restart Codex and review its hook trust prompt.\n${result.configPath}`);
-        return { enabled: true, harnesses: result.harnesses };
-    }
-    catch (error) {
-        const message = serializeDiagnosticError(error).message;
-        log(`Native sync unavailable; Runtime continues without it — ${message}\n`);
-        return { enabled: false, harnesses: input.harnesses, note: message };
-    }
-}

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

@@ -1 +0,0 @@
-export declare function runCodexNativeHook(payload: unknown): Promise<void>;

package/dist/runtime/native-codex-hook.js

@@ -1,28 +0,0 @@
-import { pathToFileURL } from "node:url";
-import { requestNativeDaemon } from "./native-ipc.js";
-export async function runCodexNativeHook(payload) {
-    if (process.env.COHUB_TURN_ID || process.env.COHUB_EXECUTION_TOKEN)
-        return;
-    const value = payload;
-    if (!value || typeof value.cwd !== "string" || typeof value.session_id !== "string")
-        throw new Error("Invalid Codex hook identity");
-    if (typeof value.transcript_path !== "string" || !value.transcript_path)
-        return;
-    const result = await requestNativeDaemon({ harness: "codex", cwd: value.cwd, path: value.transcript_path, nativeSessionId: value.session_id });
-    if (!result.ok && !result.skipped)
-        throw new Error(result.message);
-}
-async function main() {
-    let input = "";
-    for await (const chunk of process.stdin) {
-        input += chunk.toString();
-        if (Buffer.byteLength(input) > 4 * 1024 * 1024)
-            throw new Error("Codex hook input is too large");
-    }
-    await runCodexNativeHook(JSON.parse(input));
-}
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-    void main().catch((error) => {
-        process.stderr.write(`Cohub sync pending; native execution continues: ${error instanceof Error ? error.message : String(error)}\n`);
-    });
-}

package/dist/runtime/native-install.d.ts

@@ -1,21 +0,0 @@
-export declare function codexNativeHookBlock(node: string, hook: string): string;
-export declare function verifyNativeSyncSupport(harnesses: ("pi" | "codex")[], cwd: string, executables?: {
-    pi?: string;
-    codex?: string;
-}): Promise<void>;
-/** Install once in the user's native configuration; data collection remains explicitly project-scoped. */
-export declare function installNativeSync(input: {
-    root: string;
-    spaceId: string;
-    identity: string;
-    harnesses: ("pi" | "codex")[];
-    disabled?: boolean;
-    executables?: {
-        pi?: string;
-        codex?: string;
-    };
-}): Promise<{
-    configPath: string;
-    harnesses: ("codex" | "pi")[];
-    enabled: boolean;
-}>;

package/dist/runtime/native-install.js

@@ -1,130 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { lstat, mkdir, open, readFile, rename, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { atomicRuntimeJson } from "./archive-store.js";
-import { nativeRuntimeRoot, nativeSyncConfigPath, readNativeSyncConfig } from "./native-sync.js";
-import { withRuntimeSpaceBindingsLock } from "./space-binding.js";
-const START = "# BEGIN COHUB NATIVE SYNC";
-const END = "# END COHUB NATIVE SYNC";
-const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
-const missing = (error) => error.code === "ENOENT";
-export function codexNativeHookBlock(node, hook) {
-    const command = `${shellQuote(node)} ${shellQuote(hook)}`;
-    return `${START}\n${["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "Interrupt", "SessionEnd"].map((event) => `[[hooks.${event}]]\n[[hooks.${event}.hooks]]\ntype = "command"\ncommand = ${JSON.stringify(command)}\ntimeout = ${event === "SessionEnd" || event === "Interrupt" ? 3 : 10}\n`).join("\n")}${END}\n`;
-}
-async function installText(path, update) {
-    await withRuntimeSpaceBindingsLock(async () => {
-        const info = await lstat(path).catch((error) => { if (missing(error))
-            return null; throw error; });
-        if (info && (!info.isFile() || info.isSymbolicLink()))
-            throw new Error(`Refusing to replace a non-regular file: ${path}`);
-        const original = info ? await readFile(path, "utf8") : null;
-        const next = update(original);
-        if (next === original)
-            return;
-        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-        if (original !== null) {
-            const backup = `${path}.cohub-backup-${createHash("sha256").update(original).digest("hex").slice(0, 16)}`;
-            const file = await open(backup, "wx", 0o600).catch((error) => { if (error.code === "EEXIST")
-                return null; throw error; });
-            if (file) {
-                try {
-                    await file.writeFile(original);
-                    await file.sync();
-                }
-                finally {
-                    await file.close();
-                }
-            }
-        }
-        const temporary = `${path}.${randomUUID()}.tmp`;
-        try {
-            const file = await open(temporary, "wx", info?.mode ?? 0o600);
-            try {
-                await file.writeFile(next);
-                await file.sync();
-            }
-            finally {
-                await file.close();
-            }
-            const current = await readFile(path, "utf8").catch((error) => { if (missing(error))
-                return null; throw error; });
-            if (current !== original)
-                throw new Error(`Configuration changed during installation: ${path}`);
-            await rename(temporary, path);
-            const directory = await open(dirname(path), "r");
-            try {
-                await directory.sync();
-            }
-            finally {
-                await directory.close();
-            }
-        }
-        finally {
-            await rm(temporary, { force: true });
-        }
-    }, { lockPath: `${path}.cohub-lock` });
-}
-export async function verifyNativeSyncSupport(harnesses, cwd, executables = {}) {
-    for (const harness of harnesses) {
-        const { stdout } = await promisify(execFile)(executables[harness] || harness, harness === "pi" ? ["--version"] : ["features", "list"], { cwd, encoding: "utf8", timeout: 15_000, maxBuffer: 1024 * 1024 });
-        if (harness === "pi") {
-            const version = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(stdout);
-            if (!version || Number(version[1]) === 0 && (Number(version[2]) < 85 || Number(version[2]) === 85 && Number(version[3]) < 1))
-                throw new Error("Native sync requires Pi 0.85.1+");
-        }
-        else if (!/^hooks\s+stable\s+true\s*$/m.test(stdout))
-            throw new Error("Install a Codex version with stable Hooks and enable hooks first");
-    }
-}
-/** Install once in the user's native configuration; data collection remains explicitly project-scoped. */
-export async function installNativeSync(input) {
-    if (!input.disabled)
-        await verifyNativeSyncSupport(input.harnesses, input.root, input.executables);
-    const runtimeRoot = nativeRuntimeRoot(input.spaceId);
-    const configPath = nativeSyncConfigPath(runtimeRoot, input.identity);
-    const extension = new URL(import.meta.url.endsWith(".ts") ? "./native-pi-extension.ts" : "./native-pi-extension.js", import.meta.url);
-    const hook = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./native-codex-hook.ts" : "./native-codex-hook.js", import.meta.url));
-    if (!input.disabled)
-        for (const harness of input.harnesses) {
-            if (harness === "pi") {
-                const content = `// Cohub native Turn sync\nexport { default } from ${JSON.stringify(extension.href)};\n`;
-                await installText(join(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"), "extensions", "cohub.ts"), (existing) => {
-                    if (existing !== null && existing !== content)
-                        throw new Error("Pi Cohub extension already exists; preserve it and review manually");
-                    return content;
-                });
-            }
-            else {
-                const block = codexNativeHookBlock(process.execPath, hook);
-                await installText(join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "config.toml"), (existing) => {
-                    if (existing?.includes(block))
-                        return existing;
-                    if (existing?.includes(START) || existing?.includes(END))
-                        throw new Error("Codex Cohub hook block differs; preserve it and review manually");
-                    if (existing && /^\s*hooks\s*=/m.test(existing))
-                        throw new Error("Inline Codex hooks require manual merging");
-                    return `${existing ?? ""}${existing?.endsWith("\n") ? "\n" : "\n\n"}${block}`;
-                });
-            }
-        }
-    await withRuntimeSpaceBindingsLock(async () => {
-        const previous = await readNativeSyncConfig(runtimeRoot, input.identity);
-        if (previous && previous.root !== input.root)
-            throw new Error("Space native sync belongs to another directory");
-        const harnesses = new Set(previous?.harnesses ?? []);
-        for (const harness of input.harnesses) {
-            if (input.disabled)
-                harnesses.delete(harness);
-            else
-                harnesses.add(harness);
-        }
-        const config = { version: 1, identity: input.identity, spaceId: input.spaceId, root: input.root, harnesses: [...harnesses] };
-        await atomicRuntimeJson(configPath, config);
-    }, { path: configPath });
-    return { configPath, harnesses: input.harnesses, enabled: !input.disabled };
-}

package/dist/runtime/native-ipc.d.ts

@@ -1,37 +0,0 @@
-import type { NativeSyncStore } from "./native-sync-store.js";
-type NativeIpcRequest = {
-    type: "native.capture";
-    harness: "pi" | "codex";
-    cwd: string;
-    path: string;
-    nativeSessionId: string;
-    settled?: boolean;
-    leafId?: string | null;
-    sessionStartedAt?: string;
-    origin?: "local_import";
-};
-export type NativeIpcResponse = {
-    ok: true;
-    pendingTurns: number;
-} | {
-    ok: false;
-    skipped?: true;
-    message: string;
-};
-/**
- * `store: null` means the request was valid but nothing was applicable yet (an unbound
- * workspace, or a transcript a harness has not written). That is not a sync failure, so
- * clients stay silent instead of warning about it.
- */
-export declare function nativeCaptureResponse(result: {
-    store: NativeSyncStore | null;
-}): Promise<NativeIpcResponse>;
-export declare function nativeDaemonSocketFor(cwd: string): Promise<string | null>;
-export declare function requestNativeDaemon(input: Omit<NativeIpcRequest, "type">): Promise<NativeIpcResponse>;
-export declare function serveNativeDaemon(input: {
-    runtimeRoot: string;
-    handle: (request: NativeIpcRequest) => Promise<{
-        store: NativeSyncStore | null;
-    }>;
-}): Promise<() => Promise<void>>;
-export {};