@neta-art/cohub-cli 7.0.1 → 7.1.0

package/dist/runtime/diagnostics.js

@@ -0,0 +1,382 @@
+import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, open, readdir, rename, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+const DEFAULT_LOG_FLUSH_INTERVAL_MS = 250;
+const MAX_PENDING_LOG_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_LOG_FILE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_TOTAL_LOG_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_LOG_FILE_AGE_MS = 60 * 60 * 1_000;
+const MAX_VALUE_STRING_LENGTH = 4_096;
+const MAX_EVENT_BYTES = 48 * 1024;
+const SENSITIVE_KEY = /authorization|cookie|password|secret|token|access[_-]?key|refresh[_-]?token/i;
+const TRACEPARENT = /^[0-9a-f]{2}-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/i;
+const diagnosticsDirectoryName = "diagnostics";
+export const runtimeDiagnosticsDirectory = (root) => join(root, diagnosticsDirectoryName);
+export const runtimeDiagnosticsPath = (root, runtimeId) => join(runtimeDiagnosticsDirectory(root), `${runtimeId}.jsonl`);
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function redactUrl(value) {
+    try {
+        const url = new URL(value);
+        for (const key of [...url.searchParams.keys()]) {
+            if (SENSITIVE_KEY.test(key))
+                url.searchParams.set(key, "[REDACTED]");
+        }
+        return url.toString();
+    }
+    catch {
+        return value;
+    }
+}
+export function redactDiagnosticString(value) {
+    const shortened = value.length > MAX_VALUE_STRING_LENGTH
+        ? `${value.slice(0, MAX_VALUE_STRING_LENGTH)}…`
+        : value;
+    return shortened
+        .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
+        .replace(/\b(rediss?|https?|wss?):\/\/[^\s]+/gi, (url) => redactUrl(url))
+        .replace(/\b(authorization|password|secret|token|access[_-]?key|refresh[_-]?token)([\s:=]+)([^\s,;]+)/gi, "$1$2[REDACTED]");
+}
+function redactValue(value, seen = new WeakSet(), depth = 0) {
+    if (value == null || typeof value === "boolean" || typeof value === "number")
+        return value;
+    if (typeof value === "string")
+        return redactDiagnosticString(value);
+    if (depth > 5)
+        return "[Truncated]";
+    if (typeof value !== "object")
+        return String(value);
+    if (seen.has(value))
+        return "[Circular]";
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.slice(0, 64).map((item) => redactValue(item, seen, depth + 1));
+    const output = {};
+    for (const [key, nested] of Object.entries(value)) {
+        output[key] = SENSITIVE_KEY.test(key) ? "[REDACTED]" : redactValue(nested, seen, depth + 1);
+    }
+    return output;
+}
+function normalizeDiagnosticTraceContext(value) {
+    if (!isRecord(value))
+        return undefined;
+    const requestId = typeof value.requestId === "string" && /^[a-zA-Z0-9._:-]{1,128}$/.test(value.requestId)
+        ? value.requestId
+        : undefined;
+    const traceId = typeof value.traceId === "string" && /^[0-9a-f]{32}$/i.test(value.traceId) ? value.traceId : undefined;
+    const spanId = typeof value.spanId === "string" && /^[0-9a-f]{16}$/i.test(value.spanId) ? value.spanId : undefined;
+    const traceparent = typeof value.traceparent === "string" && TRACEPARENT.test(value.traceparent) ? value.traceparent : undefined;
+    if (!requestId && !traceId && !spanId && !traceparent)
+        return undefined;
+    return {
+        ...(requestId ? { requestId } : {}),
+        ...(traceId ? { traceId } : {}),
+        ...(spanId ? { spanId } : {}),
+        ...(traceparent ? { traceparent } : {}),
+    };
+}
+export function serializeDiagnosticError(error) {
+    if (!(error instanceof Error))
+        return { message: redactDiagnosticString(String(error)) };
+    const source = error;
+    const result = {
+        message: error.message || error.name || "Unknown error",
+        ...(error.name ? { name: error.name } : {}),
+        ...(error.stack ? { stack: error.stack } : {}),
+    };
+    for (const key of ["code", "status", "syscall", "hostname"]) {
+        const value = source[key];
+        if (typeof value === "string" || typeof value === "number")
+            result[key] = value;
+    }
+    const cause = isRecord(source.cause) ? source.cause : null;
+    const traceContext = normalizeDiagnosticTraceContext(source.traceContext);
+    if (traceContext)
+        result.traceContext = traceContext;
+    if (typeof cause?.code === "string")
+        result.causeCode = cause.code;
+    if (typeof cause?.message === "string")
+        result.causeMessage = cause.message;
+    if (typeof cause?.syscall === "string")
+        result.causeSyscall = cause.syscall;
+    if (typeof cause?.hostname === "string")
+        result.causeHostname = cause.hostname;
+    return redactValue(result);
+}
+function compactEvent(event) {
+    let result = redactValue(event);
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") <= MAX_EVENT_BYTES)
+        return result;
+    result = {
+        ...result,
+        data: { truncated: true },
+        ...(result.error ? { error: { ...result.error, stack: undefined } } : {}),
+    };
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") <= MAX_EVENT_BYTES)
+        return result;
+    return {
+        ...result,
+        data: undefined,
+        error: result.error ? { message: result.error.message, name: result.error.name } : undefined,
+    };
+}
+function compareDiagnosticEvents(left, right) {
+    if (left.runtimeId === right.runtimeId)
+        return left.sequence - right.sequence;
+    return left.timestamp.localeCompare(right.timestamp) || left.runtimeId.localeCompare(right.runtimeId) || left.sequence - right.sequence;
+}
+export class RuntimeDiagnostics {
+    runtimeId;
+    directory;
+    logPath;
+    spaceId;
+    component;
+    logFlushIntervalMs;
+    maxLogFileBytes;
+    maxTotalLogBytes;
+    startedAtMs = Date.now();
+    ready;
+    logFile = null;
+    logFileSize = 0;
+    logFileStartedAt = 0;
+    writeChain = Promise.resolve();
+    writeBuffer = [];
+    writeBufferBytes = 0;
+    droppedWriteEvents = 0;
+    writeTimer = null;
+    sequence = 0;
+    closed = false;
+    constructor(options) {
+        this.runtimeId = options.runtimeId ?? randomUUID();
+        this.spaceId = options.spaceId;
+        this.component = options.component ?? "runtime";
+        this.logFlushIntervalMs = options.logFlushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
+        this.maxLogFileBytes = options.maxLogFileBytes ?? DEFAULT_MAX_LOG_FILE_BYTES;
+        this.maxTotalLogBytes = options.maxTotalLogBytes ?? DEFAULT_MAX_TOTAL_LOG_BYTES;
+        this.directory = runtimeDiagnosticsDirectory(options.root);
+        this.logPath = runtimeDiagnosticsPath(options.root, this.runtimeId);
+        this.ready = mkdir(this.directory, { recursive: true, mode: 0o700 }).then(() => undefined);
+    }
+    log(level, event, data, context = {}) {
+        if (this.closed)
+            return;
+        const traceContext = normalizeDiagnosticTraceContext(context.traceContext ?? (context.requestId ? { requestId: context.requestId } : undefined));
+        const rawError = data?.error;
+        const diagnosticError = rawError instanceof Error
+            ? serializeDiagnosticError(rawError)
+            : isRecord(rawError) && typeof rawError.message === "string"
+                ? redactValue(rawError)
+                : typeof rawError === "string"
+                    ? { message: redactDiagnosticString(rawError) }
+                    : undefined;
+        const eventTraceContext = traceContext ?? normalizeDiagnosticTraceContext(diagnosticError?.traceContext);
+        const eventData = data ? Object.fromEntries(Object.entries(data).filter(([key]) => key !== "error")) : undefined;
+        const value = compactEvent({
+            schemaVersion: 1,
+            sequence: this.sequence++,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - this.startedAtMs,
+            level,
+            component: context.component ?? this.component,
+            event,
+            runtimeId: this.runtimeId,
+            ...(context.connectionId ? { connectionId: context.connectionId } : {}),
+            spaceId: context.spaceId ?? this.spaceId,
+            ...(context.sessionId ? { sessionId: context.sessionId } : {}),
+            ...(context.turnId ? { turnId: context.turnId } : {}),
+            ...(context.harness ? { harness: context.harness } : {}),
+            ...(eventTraceContext ? { traceContext: eventTraceContext } : {}),
+            ...(eventData && Object.keys(eventData).length > 0 ? { data: eventData } : {}),
+            ...(diagnosticError ? { error: diagnosticError } : {}),
+        });
+        this.enqueueWrite(value);
+    }
+    async close() {
+        this.closed = true;
+        if (this.writeTimer)
+            clearTimeout(this.writeTimer);
+        this.writeTimer = null;
+        await this.flushLogBuffer();
+        await this.writeChain;
+        if (this.logFile) {
+            const file = this.logFile;
+            this.logFile = null;
+            await file.sync().catch(() => undefined);
+            await file.close().catch(() => undefined);
+        }
+    }
+    enqueueWrite(event) {
+        let nextEvent = event;
+        if (this.droppedWriteEvents > 0) {
+            nextEvent = { ...event, data: { ...(event.data ?? {}), droppedDiagnosticsBeforeWrite: this.droppedWriteEvents } };
+            this.droppedWriteEvents = 0;
+        }
+        const line = `${JSON.stringify(nextEvent)}\n`;
+        const bytes = Buffer.byteLength(line, "utf8");
+        while (this.writeBufferBytes + bytes > MAX_PENDING_LOG_BYTES && this.writeBuffer.length > 0) {
+            const index = this.writeBuffer.findIndex(({ event: queued }) => queued.level === "debug" || queued.level === "info");
+            const removed = this.writeBuffer.splice(index >= 0 ? index : 0, 1)[0];
+            if (removed) {
+                this.writeBufferBytes -= removed.bytes;
+                this.droppedWriteEvents += 1;
+            }
+        }
+        if (this.writeBufferBytes + bytes > MAX_PENDING_LOG_BYTES && nextEvent.level !== "error") {
+            this.droppedWriteEvents += 1;
+            return;
+        }
+        this.writeBuffer.push({ event: nextEvent, line, bytes });
+        this.writeBufferBytes += bytes;
+        if (nextEvent.level === "error" || this.writeBufferBytes >= 64 * 1024)
+            void this.flushLogBuffer();
+        else
+            this.scheduleLogFlush();
+    }
+    scheduleLogFlush() {
+        if (this.writeTimer || this.closed)
+            return;
+        this.writeTimer = setTimeout(() => {
+            this.writeTimer = null;
+            void this.flushLogBuffer();
+        }, this.logFlushIntervalMs);
+    }
+    async flushLogBuffer() {
+        if (this.writeBuffer.length === 0)
+            return this.writeChain;
+        const entries = this.writeBuffer;
+        this.writeBuffer = [];
+        this.writeBufferBytes = 0;
+        this.writeChain = this.writeChain.then(() => this.writeEntries(entries)).catch(() => {
+            // Local diagnostics must never take down the Runtime.
+        });
+        return this.writeChain;
+    }
+    async writeEntries(entries) {
+        await this.ready;
+        for (const entry of entries) {
+            await this.ensureLogFile();
+            const shouldRotate = this.logFileSize > 0 && (this.logFileSize + entry.bytes > this.maxLogFileBytes ||
+                Date.now() - this.logFileStartedAt >= DEFAULT_MAX_LOG_FILE_AGE_MS);
+            if (shouldRotate) {
+                await this.rotateLog(entry.event.sequence);
+                await this.ensureLogFile();
+            }
+            await this.logFile?.write(entry.line);
+            this.logFileSize += entry.bytes;
+        }
+        await this.logFile?.sync();
+    }
+    async ensureLogFile() {
+        if (this.logFile)
+            return;
+        this.logFile = await open(this.logPath, "a", 0o600);
+        await this.logFile.chmod(0o600).catch(() => undefined);
+        this.logFileSize = (await stat(this.logPath)).size;
+        this.logFileStartedAt = Date.now();
+    }
+    async rotateLog(nextSequence) {
+        const file = this.logFile;
+        this.logFile = null;
+        if (file) {
+            await file.sync();
+            await file.close();
+        }
+        await rename(this.logPath, join(this.directory, `${this.runtimeId}-${nextSequence}-${Date.now()}.jsonl`));
+        this.logFileSize = 0;
+        this.logFileStartedAt = 0;
+        await this.enforceLogCapacity();
+    }
+    async enforceLogCapacity() {
+        const names = await readdir(this.directory).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        const files = await Promise.all(names.filter((name) => name.endsWith(".jsonl") && name !== `${this.runtimeId}.jsonl`).map(async (name) => {
+            const path = join(this.directory, name);
+            const info = await stat(path).catch(() => null);
+            return info ? { path, size: info.size, mtimeMs: info.mtimeMs } : null;
+        }));
+        let total = this.logFileSize + files.reduce((sum, file) => sum + (file?.size ?? 0), 0);
+        for (const file of files.filter((value) => value !== null).sort((left, right) => left.mtimeMs - right.mtimeMs)) {
+            if (total <= this.maxTotalLogBytes)
+                break;
+            await rm(file.path, { force: true });
+            total -= file.size;
+        }
+    }
+}
+export class RuntimeDiagnosticReader {
+    root;
+    files = new Map();
+    lastSequenceByRuntime = new Map();
+    initialized = false;
+    constructor(root) {
+        this.root = root;
+    }
+    async read(options = {}) {
+        const directory = runtimeDiagnosticsDirectory(this.root);
+        const names = await readdir(directory).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        const fileEntries = await Promise.all(names.filter((value) => value.endsWith(".jsonl")).map(async (name) => {
+            const path = join(directory, name);
+            const info = await stat(path).catch(() => null);
+            return info ? { path, size: info.size, mtimeMs: info.mtimeMs } : null;
+        }));
+        const events = [];
+        for (const file of fileEntries.filter((value) => value !== null).sort((left, right) => left.mtimeMs - right.mtimeMs)) {
+            const state = this.files.get(file.path) ?? { offset: 0, partial: "", decoder: new StringDecoder("utf8") };
+            if (file.size < state.offset) {
+                state.offset = 0;
+                state.partial = "";
+                state.decoder = new StringDecoder("utf8");
+            }
+            const stream = createReadStream(file.path, { start: state.offset });
+            let bytesRead = 0;
+            let text = state.partial;
+            for await (const chunk of stream) {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                bytesRead += buffer.length;
+                text += state.decoder.write(buffer);
+            }
+            state.offset += bytesRead;
+            const lines = text.split("\n");
+            state.partial = lines.pop() ?? "";
+            this.files.set(file.path, state);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const value = JSON.parse(line);
+                    if (isRecord(value) && value.schemaVersion === 1 && typeof value.sequence === "number")
+                        events.push(value);
+                }
+                catch {
+                    // Ignore only the damaged line; source files remain untouched.
+                }
+            }
+        }
+        events.sort(compareDiagnosticEvents);
+        const fresh = events.filter((event) => event.sequence > (this.lastSequenceByRuntime.get(event.runtimeId) ?? -1));
+        for (const event of fresh)
+            this.lastSequenceByRuntime.set(event.runtimeId, event.sequence);
+        if (!this.initialized) {
+            this.initialized = true;
+            const limit = options.limit ?? 100;
+            return limit > 0 ? fresh.slice(-limit) : fresh;
+        }
+        return fresh;
+    }
+}
+export async function readRuntimeDiagnosticEvents(root, options = {}) {
+    return new RuntimeDiagnosticReader(root).read(options);
+}
+export function isValidRuntimeTraceparent(value) {
+    return typeof value === "string" && TRACEPARENT.test(value);
+}

package/dist/runtime/harness.d.ts

@@ -1,6 +1,7 @@
 import type { ContentBlock, RuntimeCapabilities, RuntimeExecutionEvent, RuntimeTurnInput } from "@neta-art/cohub";
 import { type JsonRecord } from "./json-rpc.js";
 import type { RuntimeSessionStore, NativeSession } from "./session-store.js";
+import { type RuntimeDiagnostics, type RuntimeDiagnosticContext } from "./diagnostics.js";
 export type HarnessOptions = {
     pi?: string;
     codex?: string;
@@ -14,6 +15,6 @@ export type HarnessResult = {
 export declare function piContent(value: unknown): ContentBlock[];
 export declare function promptText(content: ContentBlock[]): string;
 export declare function discoverHarnesses(harnesses: ("pi" | "codex")[], options: HarnessOptions, cwd: string): Promise<RuntimeCapabilities>;
-export declare function executePi(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal): Promise<HarnessResult>;
+export declare function executePi(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal, diagnostics?: RuntimeDiagnostics, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessResult>;
 export declare function codexItemContent(item: JsonRecord): ContentBlock[];
-export declare function executeCodex(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal): Promise<HarnessResult>;
+export declare function executeCodex(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal, diagnostics?: RuntimeDiagnostics, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessResult>;

package/dist/runtime/harness.js

@@ -2,6 +2,7 @@ import { JsonRpcProcess, record } from "./json-rpc.js";
 import { codexModelCatalog } from "./model-catalog.js";
 import { codexTokenTotals, codexUsage, subtractCodexTokens } from "./codex-usage.js";
 import { downloadPublicImage } from "../safe-remote-image.js";
+import { serializeDiagnosticError } from "./diagnostics.js";
 const runtimeEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
 const array = (value) => Array.isArray(value) ? value : [];
 const text = (value) => typeof value === "string" ? value : "";
@@ -47,8 +48,8 @@ function createAbortEscalation(rpc, signal, interrupt) {
     };
 }
 /** Native files stay authoritative; archival failure only degrades cross-host resume. */
-async function finishHarnessTurn(store, state, message, resume, turnId) {
-    const archive = await store.archive(state, turnId).catch((error) => { console.error("Native archive unavailable; local files retained:", error); return null; });
+async function finishHarnessTurn(store, state, message, resume, turnId, diagnosticContext) {
+    const archive = await store.archive(state, turnId, diagnosticContext).catch((error) => { console.error("Native archive unavailable; local files retained:", error); return null; });
     return { state, event: { type: "turn.end", message, resume, archive } };
 }
 export async function discoverHarnesses(harnesses, options, cwd) {
@@ -88,7 +89,7 @@ export async function discoverHarnesses(harnesses, options, cwd) {
     }));
     return { harnesses, models };
 }
-export async function executePi(input, options, cwd, store, emit, signal) {
+export async function executePi(input, options, cwd, store, emit, signal, diagnostics, diagnosticContext) {
     if (input.accessMode === "read_only")
         throw new Error("Pi cannot enforce read-only access; select Cohub or Codex");
     signal.throwIfAborted();
@@ -99,6 +100,12 @@ export async function executePi(input, options, cwd, store, emit, signal) {
     let currentContent = [];
     let last = { ordinal: 0, content: [] };
     const abortEscalation = createAbortEscalation(rpc, signal, () => { void rpc.request("abort").catch(() => undefined); });
+    const stopFailureLogging = diagnostics
+        ? rpc.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "harness" }))
+        : () => undefined;
+    const stopTimeoutLogging = diagnostics
+        ? rpc.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...diagnosticContext, component: "harness" }))
+        : () => undefined;
     try {
         if (input.model) {
             let provider = input.provider;
@@ -193,11 +200,19 @@ export async function executePi(input, options, cwd, store, emit, signal) {
     }
     finally {
         abortEscalation.clear();
+        stopFailureLogging();
+        stopTimeoutLogging();
         await rpc.close();
     }
     if (signal.aborted)
         last = { ...last, stopReason: "aborted" };
-    return finishHarnessTurn(store, state, last, resume, input.turnId);
+    return finishHarnessTurn(store, state, last, resume, input.turnId, {
+        component: "harness",
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        harness: "pi",
+        traceContext: input.traceContext,
+    });
 }
 export function codexItemContent(item) {
     if (item.type === "agentMessage" || item.type === "plan")
@@ -216,11 +231,17 @@ export function codexItemContent(item) {
         { type: "tool_result", tool_use_id: id, content: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : JSON.stringify(item.result ?? item.error ?? item.changes ?? item), is_error: item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 },
     ];
 }
-export async function executeCodex(input, options, cwd, store, emit, signal) {
+export async function executeCodex(input, options, cwd, store, emit, signal, diagnostics, diagnosticContext) {
     signal.throwIfAborted();
     const { state, resume } = await store.prepare(input, cwd, signal);
     signal.throwIfAborted();
     const rpc = new JsonRpcProcess(options.codex || "codex", ["app-server", "--listen", "stdio://"], cwd, "codex", runtimeEnvironment(input));
+    const stopFailureLogging = diagnostics
+        ? rpc.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "harness" }))
+        : () => undefined;
+    const stopTimeoutLogging = diagnostics
+        ? rpc.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...diagnosticContext, component: "harness" }))
+        : () => undefined;
     let nativeTurnId = null;
     let ordinal = -1;
     const ordinals = new Map();
@@ -250,10 +271,12 @@ export async function executeCodex(input, options, cwd, store, emit, signal) {
             ...(input.accessMode === "read_only" ? { sandbox: "read-only" } : {}),
         };
         const opened = resume === "native"
-            ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, excludeTurns: true })
+            ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
             : resume === "restored"
                 ? await rpc.request("thread/fork", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
-                : await rpc.request("thread/start", threadOptions);
+                : resume === "handoff"
+                    ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
+                    : await rpc.request("thread/start", threadOptions);
         const thread = record(opened.thread);
         if (typeof thread.id !== "string" || typeof thread.path !== "string")
             throw new Error("Codex did not provide a durable native thread");
@@ -393,11 +416,19 @@ export async function executeCodex(input, options, cwd, store, emit, signal) {
     }
     finally {
         abortEscalation.clear();
+        stopFailureLogging();
+        stopTimeoutLogging();
         await rpc.close();
     }
     if (signal.aborted)
         final = { ...final, stopReason: "aborted" };
     if (usage)
         final = { ...final, usage };
-    return finishHarnessTurn(store, state, final, resume, input.turnId);
+    return finishHarnessTurn(store, state, final, resume, input.turnId, {
+        component: "harness",
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        harness: "codex",
+        traceContext: input.traceContext,
+    });
 }

package/dist/runtime/json-rpc.d.ts

@@ -20,6 +20,7 @@ export declare class JsonRpcProcess {
     private pending;
     private listeners;
     private failureListeners;
+    private timeoutListeners;
     private failure;
     private nextId;
     private stderr;
@@ -32,6 +33,7 @@ export declare class JsonRpcProcess {
     request(method: string, params?: JsonRecord, timeoutMs?: number): Promise<JsonRecord>;
     onEvent(listener: (event: JsonRecord) => void): () => boolean;
     onFailure(listener: (error: Error) => void): () => boolean;
+    onTimeout(listener: (method: string, timeoutMs: number) => void): () => boolean;
     close(): Promise<void>;
     private closeProcessGroup;
 }

package/dist/runtime/json-rpc.js

@@ -53,6 +53,7 @@ export class JsonRpcProcess {
     pending = new Map();
     listeners = new Set();
     failureListeners = new Set();
+    timeoutListeners = new Set();
     failure = null;
     nextId = 0;
     stderr = "";
@@ -123,7 +124,12 @@ export class JsonRpcProcess {
             return Promise.reject(this.failure);
         const id = String(++this.nextId);
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`${method} timed out`)); }, timeoutMs);
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                for (const listener of this.timeoutListeners)
+                    listener(method, timeoutMs);
+                reject(new Error(`${method} timed out`));
+            }, timeoutMs);
             this.pending.set(id, { resolve, reject, timer });
             try {
                 this.write(this.mode === "pi" ? { ...params, id, type: method } : { id, method, params });
@@ -143,6 +149,10 @@ export class JsonRpcProcess {
                 listener(this.failure); });
         return () => this.failureListeners.delete(listener);
     }
+    onTimeout(listener) {
+        this.timeoutListeners.add(listener);
+        return () => this.timeoutListeners.delete(listener);
+    }
     close() {
         this.closing ??= this.closeProcessGroup();
         return this.closing;
@@ -159,6 +169,7 @@ export class JsonRpcProcess {
             this.fail(new Error("RPC process closed"));
             this.listeners.clear();
             this.failureListeners.clear();
+            this.timeoutListeners.clear();
         }
         await this.closed;
     }

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

@@ -0,0 +1,34 @@
+import { type NativeProjection, type ProjectionTarget } from "@neta-art/cohub";
+import { type ProjectionSourceTurn, type SessionTurnProjectionClient } from "./turn-projection.js";
+export type ProjectionCursorState = {
+    throughSequence: number | null;
+    throughTurnId: string | null;
+    sourceFingerprint: string | null;
+};
+export type ProjectionStoreInput = {
+    spaceId: string;
+    sessionId: string;
+    turnId: string;
+    nativeSessionId: string;
+    cwd: string;
+    provider?: string | null;
+    target: ProjectionTarget;
+    throughTurnId: string | null;
+    cursor: ProjectionCursorState | null;
+};
+export type ProjectionStoreResult = {
+    projection: NativeProjection;
+    turns: ProjectionSourceTurn[];
+    append: boolean;
+    cursor: ProjectionCursorState;
+};
+export declare function rebindProjectionNativeSession(result: ProjectionStoreResult, nativeSessionId: string): ProjectionStoreResult;
+/** Reads durable Cohub turns and materializes one harness-specific native projection batch. */
+export declare class ProjectionStore {
+    private readonly source;
+    constructor(source: SessionTurnProjectionClient);
+    project(input: ProjectionStoreInput, signal?: AbortSignal): Promise<ProjectionStoreResult>;
+    private sourceSequence;
+    cursorForTurn(sessionId: string, turnId: string, signal?: AbortSignal): Promise<ProjectionCursorState>;
+    private readTurns;
+}