@neta-art/cohub-cli 10.6.0 → 10.8.0

package/dist/runtime/harnesses/pi.js

@@ -242,6 +242,6 @@ export const piHarness = {
         replyEnded: (turn) => PI_ENDED.includes(turn.messages.at(-1)?.stopReason ?? ""),
         userFinalMarked: false,
         globalTurnKeys: false,
+        marksCohubTurns: true,
     },
-    nativeSync: true,
 };

package/dist/runtime/harnesses/stream-json.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeTurnInput } from "@neta-art/cohub";
+import type { ContentBlock, RuntimeMessage, RuntimeTurnInput } from "@neta-art/cohub";
 import type { Executor } from "../native/execution.js";
 import type { HarnessModel, HarnessRun, HarnessTurn } from "./types.js";
 /** Runs without `--model`, so the CLI's own configuration and account default apply. */
@@ -14,13 +14,19 @@ export type StreamJsonProfile = {
     projectDirectory(cwd: string): string;
     /** Thinking levels accepted by `--effort`. */
     effortLevels: readonly string[];
+    /** The CLI keeps a stream-json prompt's `uuid` as its record id, so the file names the Cohub Turn. */
+    promptUuid: boolean;
 };
 /** The CLI's help, after checking it offers every flag a Turn uses. */
 export declare function streamJsonHelp(profile: StreamJsonProfile, executable: string, cwd: string): Promise<string>;
 export declare function streamJsonModel(profile: StreamJsonProfile, id: string, name: string, options: {
     reasoning: boolean;
     isDefault?: boolean;
+    provider?: string;
+    effortLevels?: readonly string[];
 }): HarnessModel;
+export declare function streamContent(value: unknown): ContentBlock[];
+export declare function streamUsage(value: unknown, cost: unknown): RuntimeMessage["usage"];
 /**
  * One Turn per process. Unattended execution never grants an approval: workspace edits follow
  * `acceptEdits` and every other tool follows the user's own permission rules.

package/dist/runtime/harnesses/stream-json.js

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
 import { access, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
@@ -29,10 +30,11 @@ export async function streamJsonHelp(profile, executable, cwd) {
     return stdout;
 }
 export function streamJsonModel(profile, id, name, options) {
+    const effortLevels = options.effortLevels ?? profile.effortLevels;
     return {
-        harness: profile.harness, provider: profile.provider, id, name,
+        harness: profile.harness, provider: options.provider ?? profile.provider, id, name,
         ...(options.isDefault ? { isDefault: true } : {}),
-        ...(options.reasoning ? { reasoning: true, thinkingLevelMap: Object.fromEntries(THINKING_LEVELS.map((level) => [level, profile.effortLevels.includes(level) ? level : null])) } : {}),
+        ...(options.reasoning ? { reasoning: true, thinkingLevelMap: Object.fromEntries(THINKING_LEVELS.map((level) => [level, effortLevels.includes(level) ? level : null])) } : {}),
     };
 }
 /** A session's file is found by id; the project directory naming is only the fast path. */
@@ -57,7 +59,7 @@ async function findSession(profile, nativeSessionId, cwd) {
     }
     return null;
 }
-function streamContent(value) {
+export function streamContent(value) {
     return array(value).flatMap((entry) => {
         const block = record(entry);
         if (block.type === "text")
@@ -72,7 +74,7 @@ function streamContent(value) {
         return [];
     });
 }
-function streamUsage(value, cost) {
+export function streamUsage(value, cost) {
     const usage = record(value);
     const count = (key) => typeof usage[key] === "number" ? usage[key] : 0;
     const input = count("input_tokens"), output = count("output_tokens"), cacheRead = count("cache_read_input_tokens"), cacheWrite = count("cache_creation_input_tokens");
@@ -80,14 +82,32 @@ function streamUsage(value, cost) {
         return undefined;
     return { input, output, cacheRead, cacheWrite, totalTokens: input + output + cacheRead + cacheWrite, ...(typeof cost === "number" && cost > 0 ? { cost: { total: cost } } : {}) };
 }
-async function prompt(input) {
+async function prompt(profile, input) {
     const content = await Promise.all(input.messages.flatMap((message) => message.content).map(async (block) => {
         if (block.type !== "image")
             return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block) };
         const image = await inlineImage(block);
         return { type: "image", source: { type: "base64", media_type: image.mimeType, data: image.data } };
     }));
-    return { type: "user", message: { role: "user", content } };
+    return { type: "user", ...(profile.promptUuid ? { uuid: input.turnId } : {}), message: { role: "user", content } };
+}
+/** Whether a session file already records this Turn's prompt (the CLI silently drops a repeated `uuid`). */
+async function holdsPrompt(path, turnId, signal) {
+    const token = Buffer.from(`"uuid":"${turnId}"`);
+    let tail = Buffer.alloc(0);
+    try {
+        for await (const chunk of createReadStream(path, { signal })) {
+            const bytes = Buffer.concat([tail, chunk]);
+            if (bytes.includes(token))
+                return true;
+            tail = bytes.subarray(Math.max(0, bytes.length - token.length + 1));
+        }
+    }
+    catch (error) {
+        if (!missing(error))
+            throw error;
+    }
+    return false;
 }
 /** Maps stream-json output onto Cohub's streaming protocol; sub-agent traffic stays in the native transcript. */
 function streamJsonTranslator(emit, identity) {
@@ -189,12 +209,15 @@ function streamJsonTranslator(emit, identity) {
  */
 export async function runStreamJson(profile, executor, turn) {
     const { input, signal, context } = turn;
-    const prepared = await executor.sessions.prepare({
+    const prepare = (resumable) => executor.sessions.prepare({
         sessionId: input.sessionId, turnId: input.turnId, harness: profile.harness, cwd: executor.cwd,
-        provider: input.provider, context: input.context, signal,
-        // Only a file Cohub wrote and advanced is continued; nothing else writes to it.
-        resumable: (transcript) => transcript.path !== turn.diverged && transcript.origin === "cohub",
+        provider: input.provider, context: input.context, signal, resumable,
     });
+    // Without a control plane, a terminal conversation is read-only: Cohub continues only files it wrote.
+    let prepared = await prepare((transcript) => transcript.path !== turn.diverged && transcript.origin === "cohub");
+    // A retried Turn whose prompt is already in the file would be dropped, so it continues from history.
+    if (profile.promptUuid && prepared.resume === "native" && await holdsPrompt(prepared.session.path, input.turnId, signal))
+        prepared = await prepare(() => false);
     let session = prepared.session;
     const effort = input.thinkingLevel && profile.effortLevels.includes(input.thinkingLevel) ? input.thinkingLevel : null;
     const args = [
@@ -204,11 +227,11 @@ export async function runStreamJson(profile, executor, turn) {
         ...(input.model && input.model !== DEFAULT_MODEL ? ["--model", input.model] : []),
         ...(effort ? ["--effort", effort] : []),
     ];
-    const content = await prompt(input);
+    const content = await prompt(profile, input);
     signal.throwIfAborted();
     const host = new JsonRpcProcess(...harnessCommand(executor.executables[profile.harness] || profile.binary, args, executor.cwd), executor.cwd, "stream", turnEnvironment(input));
     watchHost(host, executor.diagnostics, context);
-    const translator = streamJsonTranslator(turn.emit, { provider: profile.provider, model: input.model && input.model !== DEFAULT_MODEL ? input.model : null });
+    const translator = streamJsonTranslator(turn.emit, { provider: input.provider || profile.provider, model: input.model && input.model !== DEFAULT_MODEL ? input.model : null });
     let message = { ordinal: 0, content: [] };
     let begun = false;
     try {

package/dist/runtime/harnesses/types.d.ts

@@ -49,7 +49,8 @@ export type NativeSessionFormat = {
     project(input: ProjectionInput): NativeProjection;
     /** Rewrite the session identity of a full projection. */
     rebind(records: ProjectionRecord[], nativeSessionId: string): ProjectionRecord[];
-    archive: {
+    /** Absent when the native state is not one file Cohub can carry; history is then projected again. */
+    archive?: {
         /** Working-copy path of a restored archive; `id` is fresh, `nativeSessionId` the archived one. */
         target(input: {
             id: string;
@@ -71,7 +72,7 @@ export type NativeArchiveImport = {
     cwd: string;
     signal?: AbortSignal;
 };
-/** Reading a harness's own transcripts. Required for native sync and receipt-less recovery. */
+/** Reading a harness's own transcripts: native sync, import and receipt-less recovery. */
 export type NativeTranscriptFormat = {
     roots(): string[];
     /** Whether a directory found under a root can hold transcripts of `cwd`. */
@@ -91,6 +92,11 @@ export type NativeTranscriptFormat = {
     userFinalMarked: boolean;
     /** Turn keys are unique across sessions (forks share their history's Turns). */
     globalTurnKeys: boolean;
+    /**
+     * A Turn Cohub runs carries its Cohub Turn id in the file (`cloudTurnId`). Otherwise the ledger
+     * records which Turn Cohub is running, and a Cohub file's Turns up to its end are taken as the server's.
+     */
+    marksCohubTurns: boolean;
     /** Plain JSONL bytes for archival when the file itself is stored differently. */
     archiveSource?(path: string, cacheDirectory: string): Promise<string>;
 };
@@ -102,7 +108,6 @@ export type LocalHarnessAdapter = {
     models(executable: string, cwd: string): Promise<HarnessModel[]>;
     run(executor: Executor, turn: HarnessTurn): Promise<HarnessRun>;
     session: NativeSessionFormat;
-    transcript?: NativeTranscriptFormat;
-    /** Terminal conversations can be synced to the Space (requires `transcript`). */
-    nativeSync: boolean;
+    /** Every harness reads its own transcripts, so terminal conversations sync to the Space. */
+    transcript: NativeTranscriptFormat;
 };

package/dist/runtime/harnesses/workbuddy-transcript.d.ts

@@ -0,0 +1,8 @@
+import { type NativeTranscript } from "../native/transcript.js";
+export declare const WORKBUDDY_REPLY_ENDED: string[];
+/**
+ * CodeBuddy stores Responses-style items linked by `parentId`: a user message starts a Turn, and each
+ * model step (`providerData.messageId`) is one message. Interactive sessions record each end
+ * (`turn-metrics`, outside the chain); `-p` sessions do not.
+ */
+export declare function readWorkbuddyTranscript(path: string, nativeSessionId: string, signal?: AbortSignal): Promise<NativeTranscript>;

package/dist/runtime/harnesses/workbuddy-transcript.js

@@ -0,0 +1,127 @@
+import { record } from "../json-rpc.js";
+import { iso } from "../native/transcript.js";
+import { chainBranch, extendTurn, readChainedLines, startTurn } from "./chained-transcript.js";
+import { array, identifiable, text } from "./process.js";
+import { streamUsage } from "./stream-json.js";
+export const WORKBUDDY_REPLY_ENDED = ["stop", "aborted", "error"];
+const INTERRUPTED = "Interrupted by user";
+function items(value) {
+    return array(value).flatMap((entry) => {
+        const block = record(entry);
+        if (["input_text", "output_text", "text"].includes(text(block.type)))
+            return text(block.text) ? [{ type: "text", text: text(block.text) }] : [];
+        if (block.type === "reasoning_text")
+            return text(block.text) ? [{ type: "thinking", thinking: text(block.text) }] : [];
+        const image = text(block.image) || text(block.image_url);
+        if (block.type === "input_image" && image) {
+            const data = /^data:([^;]+);base64,(.*)$/s.exec(image);
+            return [{ type: "image", source: data ? { type: "base64", media_type: data[1] ?? "image/png", data: data[2] ?? "" } : { type: "url", url: image } }];
+        }
+        return [];
+    });
+}
+function toolOutput(value) {
+    if (typeof value === "string")
+        return value;
+    const output = record(value);
+    if (output.type === "text")
+        return text(output.text);
+    return Array.isArray(value) ? items(value) : JSON.stringify(value ?? null);
+}
+/**
+ * CodeBuddy stores Responses-style items linked by `parentId`: a user message starts a Turn, and each
+ * model step (`providerData.messageId`) is one message. Interactive sessions record each end
+ * (`turn-metrics`, outside the chain); `-p` sessions do not.
+ */
+export async function readWorkbuddyTranscript(path, nativeSessionId, signal) {
+    const read = await readChainedLines(path, signal);
+    const linked = (value) => value.type === "message" || "parentId" in value;
+    const branch = chainBranch(read.lines, (value) => linked(value) ? text(value.id) : "", (value) => text(value.parentId));
+    const metricsAt = read.lines.reduce((latest, line) => line.value.type === "turn-metrics" ? line.startBytes : latest, -1);
+    const turns = [];
+    const owners = new Map();
+    const steps = new Map();
+    let cwd = "", cloudSessionId = "", completedAt = "";
+    let current = null;
+    const finish = () => {
+        if (!current)
+            return;
+        const last = current.messages.at(-1);
+        const status = !last || last.stopReason === "aborted" || last.stopReason === "tool_use" ? "interrupted" : last.stopReason === "error" ? "failed" : "completed";
+        current.result = { messages: current.messages, completedAt: completedAt || current.startedAt, status };
+        turns.push(current);
+        current = null;
+    };
+    for (const line of branch) {
+        const value = line.value;
+        cwd ||= text(value.cwd);
+        if (value.type === "message" && value.role === "user") {
+            finish();
+            const cohub = record(value.cohub);
+            cloudSessionId ||= text(cohub.sessionId);
+            current = startTurn(line, text(value.id), turns.at(-1)?.key ?? null, items(value.content), text(cohub.turnId));
+            completedAt = current.startedAt;
+            owners.clear();
+            steps.clear();
+            continue;
+        }
+        if (!current)
+            continue;
+        const provider = record(value.providerData);
+        const step = text(provider.messageId);
+        const message = () => {
+            let target = step ? steps.get(step) : undefined;
+            if (!target) {
+                target = { content: [], provider: null, model: text(provider.model) || null, stopReason: null, errorMessage: null };
+                current?.messages.push(target);
+                if (step)
+                    steps.set(step, target);
+            }
+            return target;
+        };
+        if (value.type === "message" && value.role === "assistant") {
+            const target = message();
+            target.content.push(...items(value.content));
+            const usage = streamUsage(record(value.message).usage, undefined);
+            if (usage)
+                target.usage = usage;
+            const error = text(record(provider.error).message);
+            target.stopReason = value.status === "incomplete" ? error === INTERRUPTED ? "aborted" : "error" : "stop";
+            if (target.stopReason === "error")
+                target.errorMessage = error || "Turn failed";
+            if (target.stopReason === "aborted")
+                current.ended = true;
+        }
+        else if (value.type === "reasoning") {
+            message().content.push(...items(value.rawContent), ...items(value.content).filter((block) => block.type === "thinking"));
+        }
+        else if (value.type === "function_call" && identifiable(value.callId) && identifiable(value.name)) {
+            let input;
+            try {
+                input = record(JSON.parse(text(value.arguments)));
+            }
+            catch {
+                input = { raw: value.arguments };
+            }
+            const target = message();
+            target.content.push({ type: "tool_use", id: value.callId, name: value.name, input });
+            target.stopReason = "tool_use";
+            const usage = streamUsage(record(value.message).usage, undefined);
+            if (usage)
+                target.usage = usage;
+            owners.set(value.callId, target);
+        }
+        else if (value.type === "function_call_result") {
+            const id = text(value.callId);
+            owners.get(id)?.content.push({ type: "tool_result", tool_use_id: id, content: toolOutput(value.output) });
+        }
+        if (typeof value.timestamp === "number" || typeof value.timestamp === "string")
+            completedAt = iso(value.timestamp);
+        extendTurn(current, line, true);
+    }
+    const tail = current;
+    if (tail && metricsAt >= tail.contentEndBytes)
+        tail.ended = true;
+    finish();
+    return { nativeSessionId, cwd, ...(cloudSessionId ? { cloudSessionId } : {}), turns, prefixes: read.prefixes };
+}

package/dist/runtime/harnesses/workbuddy.d.ts

@@ -3,7 +3,7 @@ import type { LocalHarnessAdapter } from "./types.js";
 export declare function workbuddyProjectName(cwd: string): string;
 /** The CLI lists selectable models (built-in and `models.json`) in its `--model` help. */
 export declare function workbuddyModels(help: string): {
-    harness: "claude" | "codex" | "pi" | "workbuddy";
+    harness: "claude" | "codex" | "cursor" | "pi" | "workbuddy";
     provider: string;
     id: string;
     name: string;

package/dist/runtime/harnesses/workbuddy.js

@@ -1,17 +1,16 @@
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { copyNativeArchive } from "../native/archive.js";
 import { projectChainedSession, projectionMeta, projectionToolId, rebindSessionId, toolResultText } from "./chained-projection.js";
+import { chainedSessionHeader, projectDirectory as projectFolder, projectTranscript } from "./chained-transcript.js";
+import { readWorkbuddyTranscript, WORKBUDDY_REPLY_ENDED } from "./workbuddy-transcript.js";
 import { DEFAULT_MODEL, runStreamJson, streamJsonHelp, streamJsonModel } from "./stream-json.js";
 /** WorkBuddy's CLI is CodeBuddy Code; both share its data root. */
 const dataRoot = () => process.env.CODEBUDDY_CONFIG_DIR?.trim() || join(homedir(), ".codebuddy");
 const MAX_NAME_BYTES = 255;
 const TRUNCATED_NAME_BYTES = 180;
-/** Mirrors CodeBuddy's project naming, including its truncation hash for long paths. */
-export function workbuddyProjectName(cwd) {
-    const base = cwd.replace(/[/\\:]/g, "-").replace(/^-+/, "").replace(/-+$/, "").replace(/-+/g, "-");
-    if (Buffer.byteLength(base, "utf8") <= MAX_NAME_BYTES)
-        return base;
+const projectBase = (cwd) => cwd.replace(/[/\\:]/g, "-").replace(/^-+/, "").replace(/-+$/, "").replace(/-+/g, "-");
+function truncated(base) {
     let prefix = "", bytes = 0;
     for (const character of base) {
         const size = Buffer.byteLength(character, "utf8");
@@ -20,12 +19,23 @@ export function workbuddyProjectName(cwd) {
         bytes += size;
         prefix += character;
     }
+    return prefix;
+}
+/** Mirrors CodeBuddy's project naming, including its truncation hash for long paths. */
+export function workbuddyProjectName(cwd) {
+    const base = projectBase(cwd);
+    if (Buffer.byteLength(base, "utf8") <= MAX_NAME_BYTES)
+        return base;
+    const prefix = truncated(base);
     let hash = 5381;
     for (const byte of Buffer.from(base, "utf8"))
         hash = 33 * hash ^ byte;
     return `${prefix}-${(hash >>> 0).toString(36)}`;
 }
 const projectDirectory = (cwd) => join(dataRoot(), "projects", workbuddyProjectName(cwd));
+const projectsRoot = () => join(dataRoot(), "projects");
+/** Every subdirectory's project name starts with this, hashed long names included. */
+const projectPrefix = (cwd) => truncated(projectBase(cwd));
 const profile = {
     harness: "workbuddy",
     label: "WorkBuddy",
@@ -34,6 +44,7 @@ const profile = {
     dataRoot,
     projectDirectory,
     effortLevels: ["minimal", "low", "medium", "high", "xhigh", "max"],
+    promptUuid: false,
 };
 /** The CLI lists selectable models (built-in and `models.json`) in its `--model` help. */
 export function workbuddyModels(help) {
@@ -95,5 +106,18 @@ export const workbuddyHarness = {
             },
         },
     },
-    nativeSync: false,
+    transcript: {
+        roots: () => [projectsRoot()],
+        acceptsDirectory: (path, root, cwd) => projectFolder(path, root, projectPrefix(cwd)),
+        acceptsTranscript: (path, cwd) => projectTranscript(path, projectsRoot(), projectPrefix(cwd)),
+        header: (path, signal) => chainedSessionHeader(path, "workbuddy", signal),
+        read: (path, signal) => readWorkbuddyTranscript(path, basename(path, ".jsonl"), signal),
+        boundaries: ['"role":"user"', '"role":"assistant"', '"type":"turn-metrics"'],
+        turnEndRecorded: false,
+        replyEnded: (turn) => WORKBUDDY_REPLY_ENDED.includes(turn.messages.at(-1)?.stopReason ?? ""),
+        userFinalMarked: false,
+        globalTurnKeys: false,
+        // CodeBuddy keeps no field of a stream-json prompt, so Cohub's Turns are tracked in the ledger.
+        marksCohubTurns: false,
+    },
 };

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

@@ -41,6 +41,8 @@ export declare class JsonRpcProcess {
     request(method: string, params?: JsonRecord, timeoutMs?: number): Promise<JsonRecord>;
     /** Signal end of input; a stream-mode CLI flushes its transcript and exits. */
     endInput(): void;
+    /** Ask a CLI that stops on SIGINT to end its current Turn. Windows has no SIGINT, so the process tree is stopped. */
+    interrupt(): void;
     /** Whether the process exits within the timeout. */
     exited(timeoutMs: number): Promise<boolean>;
     onEvent(listener: (event: JsonRecord) => void): () => boolean;

package/dist/runtime/json-rpc.js

@@ -157,6 +157,15 @@ export class JsonRpcProcess {
         this.inputEnded = true;
         this.child.stdin.end();
     }
+    /** Ask a CLI that stops on SIGINT to end its current Turn. Windows has no SIGINT, so the process tree is stopped. */
+    interrupt() {
+        if (this.failure)
+            return;
+        if (process.platform === "win32")
+            void this.close().catch(() => undefined);
+        else
+            this.child.kill("SIGINT");
+    }
     /** Whether the process exits within the timeout. */
     async exited(timeoutMs) {
         let timer;

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

@@ -27,7 +27,7 @@ export declare function nativeSyncSatisfied(config: NativeConfig | null, input:
  * 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(requested: Input, log?: (line: string) => void, ask?: Ask): Promise<NativeSyncReport>;
+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.

package/dist/runtime/native/attach.js

@@ -1,7 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { LOCAL_HARNESS_SPECS } from "@neta-art/cohub";
 import { serializeDiagnosticError } from "../diagnostics.js";
-import { nativeSyncHarnesses } from "../harnesses/index.js";
 import { CODEX_SHARED_MIN_VERSION, sharedServerAvailable, supportsSharedServer } from "./codex-link.js";
 import { PI_MIN_VERSION } from "./pi-link.js";
 import { atLeast, formatVersion, harnessVersion } from "./version.js";
@@ -25,9 +24,7 @@ async function defaultAsk(question) {
  * 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(requested, log = (line) => process.stderr.write(line), ask = defaultAsk) {
-    // A harness without a native integration runs Cohub Turns only.
-    const input = { ...requested, harnesses: nativeSyncHarnesses(requested.harnesses) };
+export async function ensureNativeSync(input, log = (line) => process.stderr.write(line), ask = defaultAsk) {
     if (!input.harnesses.length)
         return { enabled: false, harnesses: [], codexShared: false, importHistory: false, note: "unsupported" };
     const stateRoot = runtimeStateRoot(input.spaceId);

package/dist/runtime/native/execution.js

@@ -7,13 +7,24 @@ export async function executeTurn(executor, input, emit, signal, requestId, cont
     signal.throwIfAborted();
     assertHarnessAccess(input.harness, input.accessMode);
     const diverged = await executor.results.admit(input);
-    const turn = { input, emit, signal, diverged, started: (session) => executor.results.start(session, input, requestId), context };
-    const run = await harnessAdapter(input.harness).run(executor, turn);
+    const started = async (session) => {
+        await executor.results.start(session, input, requestId);
+        executor.ingest.begin(session, input.sessionId, input.turnId);
+    };
+    const turn = { input, emit, signal, diverged, started, context };
+    let run;
+    try {
+        run = await harnessAdapter(input.harness).run(executor, turn);
+    }
+    catch (error) {
+        executor.ingest.end(input.turnId);
+        throw error;
+    }
     let uncertainCleanup;
     if (run.host)
         uncertainCleanup = await closeHost(run.host, run.message.errorMessage);
     const message = signal.aborted ? { ...run.message, stopReason: "aborted" } : run.message;
-    const archive = await executor.archives.stage({ sessionId: input.sessionId, harness: input.harness, nativeSessionId: run.session.nativeSessionId, path: run.session.path }, input.turnId).catch((error) => {
+    const archive = !harnessAdapter(input.harness).session.archive ? null : await executor.archives.stage({ sessionId: input.sessionId, harness: input.harness, nativeSessionId: run.session.nativeSessionId, path: run.session.path }, input.turnId).catch((error) => {
         // A missing archive only costs cross-machine native resume; the file itself is intact.
         executor.diagnostics?.log("warn", "archive.capture_failed", { error: serializeDiagnosticError(error) }, { ...context, component: "archive" });
         return null;

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

@@ -21,6 +21,8 @@ export type TranscriptState = {
     headTurnId: string | null;
     origin: "cohub" | "native";
     controllable?: boolean;
+    /** The Turn Cohub is running in this file, for formats that cannot mark it; kept across a crash. */
+    executingTurnId?: string | null;
 };
 export type ImportFilter = {
     harnesses?: Harness[];
@@ -118,6 +120,8 @@ export declare class NativeIngest {
     private readonly failures;
     private readonly aliveAt;
     private readonly runningPaths;
+    /** Files a live Cohub execution is writing in a format that cannot mark its Turn. */
+    private readonly executing;
     private writing;
     private readonly foreign;
     private importQueue;
@@ -152,6 +156,7 @@ export declare class NativeIngest {
     connect(transport: IngestTransport | null): void;
     /**
      * Record that Cohub created or chose this transcript for a Session, before any Turn of it runs.
+     * `through` says the server has the file's Turns up to `turnKey` (none when null) and `turnId` heads them.
      */
     adopt(session: {
         harness: Harness;
@@ -162,6 +167,15 @@ export declare class NativeIngest {
         turnKey: string | null;
         turnId: string | null;
     }): void;
+    /** A Cohub Turn starts writing this file; a format that cannot mark it is not read until it ends. */
+    begin(session: {
+        harness: Harness;
+        path: string;
+        nativeSessionId: string;
+        cwd: string;
+    }, sessionId: string, turnId: string): void;
+    /** A Cohub Turn ended, whether or not it produced a result. */
+    end(turnId: string): void;
     advance(path: string, turnId: string): void;
     touch(path: string): void;
     running(harness: Harness, nativeSessionId: string): TranscriptState | null;

package/dist/runtime/native/ingest.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { NATIVE_INGEST_MAX_TURNS, SETTLED_TURN_STATUSES } from "@neta-art/cohub";
 import { acceptsDirectory, acceptsTranscript, readSessionHeader, readTranscript, transcriptRoots } from "./adapters.js";
 import { nativeTurnId } from "./identity.js";
-import { transcriptFormat } from "../harnesses/index.js";
+import { harnessAdapter, transcriptFormat } from "../harnesses/index.js";
 import { containsNativePath } from "./paths.js";
 const missing = (error) => error?.code === "ENOENT";
 /** Transcripts read in parallel per lane. The live lane never waits behind a backfill. */
@@ -107,6 +107,8 @@ export class NativeIngest {
     failures = new Map();
     aliveAt = new Map();
     runningPaths = new Set();
+    /** Files a live Cohub execution is writing in a format that cannot mark its Turn. */
+    executing = new Set();
     writing = Promise.resolve();
     foreign = new Set();
     importQueue = [];
@@ -194,18 +196,49 @@ export class NativeIngest {
     }
     /**
      * Record that Cohub created or chose this transcript for a Session, before any Turn of it runs.
+     * `through` says the server has the file's Turns up to `turnKey` (none when null) and `turnId` heads them.
      */
     adopt(session, sessionId, through) {
         const state = this.states.get(session.path) ?? this.blank(session.path, session.nativeSessionId, session.cwd, session.harness, "user", { size: -1, mtimeMs: 0, ino: 0 });
         Object.assign(state, { sessionId, nativeSessionId: session.nativeSessionId });
-        if (through?.turnKey)
+        if (through)
             Object.assign(state, { throughTurnKey: through.turnKey, throughTurnId: through.turnId, headTurnId: through.turnId });
         if (!this.states.has(session.path))
             state.origin = "cohub";
+        // The harness wrote elsewhere than expected; the execution follows the file.
+        for (const other of this.states.values()) {
+            if (other === state || other.harness !== session.harness || other.nativeSessionId !== session.nativeSessionId || !other.executingTurnId)
+                continue;
+            state.executingTurnId = other.executingTurnId;
+            other.executingTurnId = null;
+            if (this.executing.delete(other.path))
+                this.executing.add(session.path);
+            this.markDirty(other.path);
+        }
         this.states.set(session.path, state);
         this.markDirty(session.path);
     }
+    /** A Cohub Turn starts writing this file; a format that cannot mark it is not read until it ends. */
+    begin(session, sessionId, turnId) {
+        if (transcriptFormat(session.harness).marksCohubTurns)
+            return;
+        this.adopt(session, sessionId);
+        const state = this.states.get(session.path);
+        state.executingTurnId = turnId;
+        this.executing.add(session.path);
+        this.markDirty(session.path);
+    }
+    /** A Cohub Turn ended, whether or not it produced a result. */
+    end(turnId) {
+        for (const state of this.states.values()) {
+            if (state.executingTurnId !== turnId)
+                continue;
+            this.executing.delete(state.path);
+            this.touch(state.path);
+        }
+    }
     advance(path, turnId) {
+        this.end(turnId);
         const state = this.states.get(path);
         if (!state)
             return;
@@ -469,7 +502,7 @@ export class NativeIngest {
         }
     }
     async read(path, lane, force) {
-        if (this.foreign.has(path))
+        if (this.foreign.has(path) || this.executing.has(path))
             return;
         const info = await stat(path).catch((error) => { if (missing(error))
             return null; throw error; });
@@ -565,6 +598,8 @@ export class NativeIngest {
         const certain = this.options.hooks?.settled?.(state, mtimeMs);
         if (certain != null)
             return certain;
+        if (tail.ended)
+            return true;
         if (!format.replyEnded?.(tail))
             return false;
         const idleMs = Date.now() - mtimeMs;
@@ -598,9 +633,20 @@ export class NativeIngest {
         const known = pending.length ? await this.known(transport, pending.flatMap((turn) => turn.cloudTurnId ? [turn.cloudTurnId, derived(turn)] : [derived(turn)])) : new Map();
         const cohub = (turn) => turn.cloudTurnId && known.has(turn.cloudTurnId) ? turn.cloudTurnId : null;
         const tail = turns.at(-1);
+        // A Cohub file whose latest Cohub Turn the file cannot name (its format marks none, or it predates
+        // the marker) holds only Turns the server already has, up to its current end.
+        const cohubHead = state.executingTurnId ?? state.headTurnId;
+        const unmarked = !transcriptFormat(state.harness).marksCohubTurns || state.size < 0;
+        if (state.origin === "cohub" && cohubHead && unmarked && state.throughTurnId !== cohubHead && !turns.some((turn) => turn.cloudTurnId === cohubHead)) {
+            const through = tail ? cohub(tail) ?? cohubHead : cohubHead;
+            Object.assign(state, { throughTurnKey: tail?.key ?? state.throughTurnKey, throughTurnId: through, headTurnId: through, executingTurnId: null });
+            return;
+        }
+        state.executingTurnId = null;
         const head = !tail ? null : pending.length ? cohub(tail) ?? derived(tail) : state.throughTurnId;
         const candidates = [];
-        let parentTurnId = from > 0 ? state.throughTurnId : null;
+        // A head adopted without a transcript key (Cohub's Turn left no record) still parents what follows.
+        let parentTurnId = from > 0 || !state.throughTurnKey ? state.throughTurnId : null;
         for (const [offset, turn] of pending.entries()) {
             const marked = cohub(turn);
             if (marked) {
@@ -726,7 +772,7 @@ export class NativeIngest {
         return Date.parse(turn.startedAt) < Date.parse(this.enabledAt);
     }
     async archive(state, turn, turnId) {
-        if (!state.sessionId)
+        if (!state.sessionId || !harnessAdapter(state.harness).session.archive)
             return;
         try {
             const source = turn.path ?? state.path;