@neta-art/cohub-cli 10.8.0 → 10.8.1

package/dist/board-kernel.js

@@ -27527,21 +27527,9 @@ function fitTextToWidth(text, value, width) {
 }
 //#endregion
 //#region ../sdk/src/board/render/text-resolution.ts
-const MAX_BOARD_RESOLUTION = 3;
-const MAX_BOARD_PIXELS = 8e6;
-const MAX_TEXT_RESOLUTION = 6;
-function getBoardResolution(size, devicePixelRatio = globalThis.devicePixelRatio) {
-	const density = Number.isFinite(devicePixelRatio) && devicePixelRatio > 0 ? devicePixelRatio : 1;
-	const pixels = size ? size.width * size.height : 0;
-	const budget = pixels > 0 ? Math.sqrt(MAX_BOARD_PIXELS / pixels) : MAX_BOARD_RESOLUTION;
-	return Math.min(density, MAX_BOARD_RESOLUTION, budget);
-}
-/**
-* Zoom buckets for text re-rasterisation. Pixi Text is a bitmap: at high zoom it
-* looks soft unless we raise its resolution. We quantise zoom into a few
-* buckets so small zoom changes don't thrash texture regeneration.
-*/
-const TEXT_ZOOM_BUCKETS = [
+const MIN_TEXT_RESOLUTION = .125;
+const MAX_TEXT_EDGE = 4096;
+const ZOOM_BUCKETS = [
 	.5,
 	1,
 	1.5,
@@ -27551,23 +27539,17 @@ const TEXT_ZOOM_BUCKETS = [
 ];
 function textZoomBucket(zoom) {
 	const clamped = Math.max(.1, Math.min(4, zoom));
-	for (const bucket of TEXT_ZOOM_BUCKETS) if (clamped <= bucket) return bucket;
-	return TEXT_ZOOM_BUCKETS[TEXT_ZOOM_BUCKETS.length - 1] ?? 4;
+	for (const bucket of ZOOM_BUCKETS) if (clamped <= bucket) return bucket;
+	return ZOOM_BUCKETS[ZOOM_BUCKETS.length - 1] ?? 4;
 }
 function boardCardDetailed(zoom) {
 	return textZoomBucket(zoom) >= 1;
 }
-/** Effective text resolution for a given camera zoom. */
-function textResolutionForZoom(zoom) {
-	const bucket = textZoomBucket(zoom);
-	return Math.min(getBoardResolution() * Math.max(1, bucket), MAX_TEXT_RESOLUTION);
-}
-/** Update a Pixi text texture only when zoom crosses a resolution bucket. */
-function syncTextResolution(text, state, zoom) {
-	const resolution = textResolutionForZoom(zoom);
-	if (resolution === state.resolution && resolution === text.resolution) return;
-	text.resolution = resolution;
-	state.resolution = resolution;
+function syncTextResolution(text, resolution) {
+	const { width, height } = text.bounds;
+	const limit = MAX_TEXT_EDGE / Math.max(1, Math.ceil(width + text.style.padding * 2), Math.ceil(height + text.style.padding * 2));
+	const next = Math.min(limit, Math.max(MIN_TEXT_RESOLUTION, resolution));
+	if (text.resolution !== next) text.resolution = next;
 }
 /** Defer expensive Pixi word-wrap rasterisation during a live resize. */
 function syncTextWrapWidth(text, state, width, defer) {
@@ -27749,13 +27731,15 @@ function createCardTag() {
 		icon,
 		text: null,
 		sig: "",
-		resolution: 0,
 		width: 0
 	};
 }
+function tagScale(zoom) {
+	return Math.min(MAX_GROWTH, Math.max(1, 1 / Math.max(zoom, .01)));
+}
 function zoomCardTag(tag, zoom) {
 	if (!tag.text || !tag.sig) return;
-	const scale = Math.min(MAX_GROWTH, Math.max(1, 1 / Math.max(zoom, .01)));
+	const scale = tagScale(zoom);
 	const span = 17 + tag.text.width;
 	tag.root.scale.set(scale);
 	tag.root.position.set(0, -18 * scale);
@@ -27769,7 +27753,6 @@ function syncCardTag(tag, input, context) {
 		return;
 	}
 	if (!tag.text) {
-		tag.resolution = textResolutionForZoom(context.zoom);
 		tag.text = new Text({
 			text: "",
 			style: {
@@ -27777,30 +27760,27 @@ function syncCardTag(tag, input, context) {
 				fontSize: 11,
 				fontWeight: "500"
 			},
-			resolution: tag.resolution,
 			roundPixels: true
 		});
 		tag.root.addChild(tag.text);
 	}
-	syncTextResolution(tag.text, tag, context.zoom);
 	const sig = [
 		input.glyph,
 		input.text,
 		input.width,
 		context.themeKey
 	].join("|");
-	if (sig === tag.sig) {
-		zoomCardTag(tag, context.zoom);
-		return;
-	}
-	tag.sig = sig;
-	const color = context.palette.muted;
-	const pixel = context.style.icons === "pixel";
-	drawCardGlyph(tag.icon.clear(), input.glyph, color, pixel);
-	tag.text.style.fill = color;
-	tag.text.style.fontFamily = context.style.font;
-	fitTextToWidth(tag.text, input.text, Math.max(1, input.width - ICON - GAP$2));
-	tag.text.position.set(17, (ICON - tag.text.height) / 2);
+	if (sig !== tag.sig) {
+		tag.sig = sig;
+		const color = context.palette.muted;
+		const pixel = context.style.icons === "pixel";
+		drawCardGlyph(tag.icon.clear(), input.glyph, color, pixel);
+		tag.text.style.fill = color;
+		tag.text.style.fontFamily = context.style.font;
+		fitTextToWidth(tag.text, input.text, Math.max(1, input.width - ICON - GAP$2));
+		tag.text.position.set(17, (ICON - tag.text.height) / 2);
+	}
+	syncTextResolution(tag.text, context.textResolution * tagScale(context.zoom));
 	zoomCardTag(tag, context.zoom);
 }
 //#endregion
@@ -28111,9 +28091,9 @@ function cardElevation(context, id) {
 }
 //#endregion
 //#region ../sdk/src/board/render/renderers/base-card-renderer.ts
-function createLabel(text, style) {
+function createLabel(text, style, resolution) {
 	return new Text({
-		resolution: getBoardResolution(),
+		resolution,
 		roundPixels: true,
 		text,
 		style: {
@@ -28270,12 +28250,15 @@ function audioKeyCenter(width, height) {
 function sync$13(container, item, context) {
 	const parts = partsByContainer$13.get(container);
 	if (!parts) return;
+	syncContent$1(parts, item, context);
+	syncTextResolution(parts.title, context.textResolution);
+}
+function syncContent$1(parts, item, context) {
 	positionShell(parts.root, item);
 	const { width, height } = item.frame;
 	const title = item.props.snapshot?.title ?? getMediaResourceTitle(item.props.src);
 	const durationMs = item.props.snapshot?.durationMs;
 	const detailed = boardCardDetailed(context.zoom);
-	syncTextResolution(parts.title, parts, context.zoom);
 	const elevation = cardElevation(context, item.id);
 	const sig = [
 		width,
@@ -28328,14 +28311,13 @@ const audioCardRenderer = {
 		const root = new Container();
 		const plate = new Graphics();
 		const wave = new Graphics();
-		const resolution = textResolutionForZoom(context.zoom);
 		const title = new Text({
 			text: "",
 			style: {
 				fontSize: 13,
 				fontWeight: "600"
 			},
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		root.addChild(plate, wave, title);
@@ -28344,8 +28326,7 @@ const audioCardRenderer = {
 			plate,
 			wave,
 			title,
-			sig: "",
-			resolution
+			sig: ""
 		});
 		if (item.type === "audio") sync$13(root, item, context);
 		return root;
@@ -28506,7 +28487,6 @@ function sync$11(container, item, context) {
 	parts.line.alpha = itemAlpha(context, style.stroke);
 	const color = itemColor(context, style.stroke, "brand");
 	const size = style.strokeWidth ?? 2.5;
-	syncTextResolution(parts.label, parts, context.zoom);
 	const resolved = resolveSceneArrow(item, context.scene);
 	const path = trimPolyline(resolved.path, style.trim);
 	const lineSig = [
@@ -28573,6 +28553,7 @@ function sync$11(container, item, context) {
 			border: context.palette.border
 		});
 	}
+	syncTextResolution(parts.label, context.textResolution);
 	const visible = props.label.length > 0 && (style.trim === void 0 || style.trim >= .5);
 	parts.label.visible = visible;
 	parts.backdrop.visible = visible;
@@ -28586,7 +28567,6 @@ const arrowCardRenderer = {
 	create: (item, context) => {
 		const root = new Container();
 		const line = new Graphics();
-		const resolution = textResolutionForZoom(context.zoom);
 		const label = new Text({
 			text: "",
 			style: {
@@ -28595,7 +28575,7 @@ const arrowCardRenderer = {
 				fontSize: 14,
 				fontWeight: "500"
 			},
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		label.anchor.set(.5);
@@ -28607,8 +28587,7 @@ const arrowCardRenderer = {
 			backdrop,
 			label,
 			lineSig: "",
-			labelSig: "",
-			resolution
+			labelSig: ""
 		});
 		if (item.type === "arrow") sync$11(root, item, context);
 		return root;
@@ -28618,7 +28597,7 @@ const arrowCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$11.get(container);
-		if (parts) syncTextResolution(parts.label, parts, context.zoom);
+		if (parts) syncTextResolution(parts.label, context.textResolution);
 	},
 	renderFar: (graphics, item, context) => {
 		if (item.type !== "arrow") return;
@@ -29003,6 +28982,14 @@ function syncClip(parts, rect, style) {
 function sync$8(container, item, context) {
 	const parts = partsByContainer$8.get(container);
 	if (!parts) return;
+	syncContent(parts, item, context);
+	for (const text of [
+		parts.title,
+		parts.excerpt,
+		parts.typeMark
+	]) syncTextResolution(text, context.textResolution);
+}
+function syncContent(parts, item, context) {
 	positionShell(parts.root, item);
 	const { width, height } = item.frame;
 	const detail = detailFor(context.zoom);
@@ -29020,9 +29007,6 @@ function sync$8(container, item, context) {
 	const kind = filePreviewKind(item.props.snapshot);
 	const category = fileCategory(item.props.src, item.props.snapshot?.mimeType);
 	const accent = fileCategoryAccent(category, context.palette);
-	syncTextResolution(parts.title, parts.titleRes, context.zoom);
-	syncTextResolution(parts.excerpt, parts.excerptRes, context.zoom);
-	syncTextResolution(parts.typeMark, parts.typeMarkRes, context.zoom);
 	const visualSig = [
 		key ?? "",
 		width,
@@ -29146,7 +29130,7 @@ const fileCardRenderer = {
 		const cover = new Sprite(Texture.EMPTY);
 		const coverMask = new Graphics();
 		cover.mask = coverMask;
-		const resolution = 1;
+		const resolution = context.textResolution;
 		const title = new Text({
 			text: "",
 			style: {
@@ -29203,10 +29187,7 @@ const fileCardRenderer = {
 			title,
 			excerpt,
 			visualSig: "",
-			textSig: "",
-			titleRes: { resolution },
-			excerptRes: { resolution },
-			typeMarkRes: { resolution }
+			textSig: ""
 		});
 		if (item.type === "file") sync$8(root, item, context);
 		return root;
@@ -29244,7 +29225,6 @@ function sync$7(container, item, context) {
 	if (!parts) return;
 	const { frame, style, props, locked } = item;
 	positionShell(parts.root, item);
-	syncTextResolution(parts.label, parts, context.zoom);
 	const fill = itemColor(context, style.fill ?? style.stroke, "neutral", "fill");
 	const fillAlpha = (style.fillOpacity ?? (style.fill ? 1 : DEFAULT_WASH)) * itemAlpha(context, style.fill ?? style.stroke);
 	const baseStroke = itemColor(context, style.stroke, "neutral");
@@ -29300,6 +29280,7 @@ function sync$7(container, item, context) {
 		parts.label.style.fill = labelColor;
 		parts.label.style.fontFamily = context.style.font;
 	}
+	syncTextResolution(parts.label, context.textResolution);
 	parts.label.position.set(4, -18);
 }
 const frameCardRenderer = {
@@ -29313,15 +29294,14 @@ const frameCardRenderer = {
 			fontFamily: BOARD_FONT_STACK,
 			fontSize: 12,
 			fontWeight: "600"
-		});
+		}, context.textResolution);
 		root.addChild(box, label);
 		partsByContainer$7.set(root, {
 			root,
 			box,
 			label,
 			visualSig: "",
-			textSig: "",
-			resolution: label.resolution
+			textSig: ""
 		});
 		if (item.type === "frame") sync$7(root, item, context);
 		return root;
@@ -29331,7 +29311,7 @@ const frameCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$7.get(container);
-		if (parts) syncTextResolution(parts.label, parts, context.zoom);
+		if (parts) syncTextResolution(parts.label, context.textResolution);
 	},
 	renderFar: (graphics, item, context) => {
 		if (item.type !== "frame" || item.props.decoration === "none") return;
@@ -29440,7 +29420,6 @@ function sync$6(container, item, context) {
 	const fillOpacity = (style.fillOpacity ?? (style.fill ? 1 : 0)) * itemAlpha(context, style.fill ?? style.stroke);
 	const strokeAlpha = itemAlpha(context, style.stroke ?? style.fill);
 	const strokeWidth = style.strokeWidth ?? 1.75;
-	syncTextResolution(parts.label, parts, context.zoom);
 	const visualSig = [
 		width,
 		height,
@@ -29499,6 +29478,7 @@ function sync$6(container, item, context) {
 		parts.label.style.align = props.align;
 	}
 	syncTextWrapWidth(parts.label, parts, Math.max(1, width - 16), context.resizingIds.has(item.id));
+	syncTextResolution(parts.label, context.textResolution);
 	parts.label.position.set(width / 2, height / 2);
 }
 const shapeCardRenderer = {
@@ -29507,7 +29487,6 @@ const shapeCardRenderer = {
 	create: (item, context) => {
 		const root = new Container();
 		const shape = new Graphics();
-		const resolution = textResolutionForZoom(context.zoom);
 		const label = new Text({
 			text: "",
 			style: {
@@ -29519,7 +29498,7 @@ const shapeCardRenderer = {
 				wordWrap: true,
 				lineHeight: 28
 			},
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		label.anchor.set(.5);
@@ -29530,8 +29509,7 @@ const shapeCardRenderer = {
 			label,
 			visualSig: "",
 			textSig: "",
-			wrapWidth: 0,
-			resolution
+			wrapWidth: 0
 		});
 		if (item.type === "shape") sync$6(root, item, context);
 		return root;
@@ -29541,7 +29519,7 @@ const shapeCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$6.get(container);
-		if (parts) syncTextResolution(parts.label, parts, context.zoom);
+		if (parts) syncTextResolution(parts.label, context.textResolution);
 	},
 	renderFar: (graphics, item, context) => {
 		if (item.type !== "shape") return;
@@ -29568,7 +29546,6 @@ function sync$5(container, item, context) {
 		parts.id = item.id;
 	}
 	positionShell(parts.root, item);
-	syncTextResolution(parts.label, parts.label, context.zoom);
 	const { width, height } = item.frame;
 	const texture = context.scripts?.frame(item, context.time) ?? null;
 	const error = context.scripts?.error(item.id) ?? null;
@@ -29586,19 +29563,21 @@ function sync$5(container, item, context) {
 		message,
 		context.themeKey
 	].join("|");
-	if (sig === parts.sig) return;
-	parts.sig = sig;
-	parts.placeholder.clear();
-	if (!ready || error) parts.placeholder.rect(0, 0, width, height).stroke({
-		color: context.palette.border,
-		width: 1,
-		alpha: .8
-	});
-	parts.label.visible = !ready || Boolean(error);
-	parts.label.text = message;
-	parts.label.style.fill = error ? context.colors.rose.stroke : context.palette.muted;
-	parts.label.style.wordWrapWidth = Math.max(40, width - 16);
-	parts.label.position.set(width / 2, height / 2);
+	if (sig !== parts.sig) {
+		parts.sig = sig;
+		parts.placeholder.clear();
+		if (!ready || error) parts.placeholder.rect(0, 0, width, height).stroke({
+			color: context.palette.border,
+			width: 1,
+			alpha: .8
+		});
+		parts.label.visible = !ready || Boolean(error);
+		parts.label.text = message;
+		parts.label.style.fill = error ? context.colors.rose.stroke : context.palette.muted;
+		parts.label.style.wordWrapWidth = Math.max(40, width - 16);
+		parts.label.position.set(width / 2, height / 2);
+	}
+	syncTextResolution(parts.label, context.textResolution);
 }
 const customCardRenderer = {
 	id: "custom-card",
@@ -29617,7 +29596,8 @@ const customCardRenderer = {
 				wordWrap: true,
 				breakWords: true
 			},
-			resolution: getBoardResolution()
+			resolution: context.textResolution,
+			roundPixels: true
 		});
 		label.anchor.set(.5);
 		root.addChild(sprite, placeholder, label);
@@ -29637,7 +29617,7 @@ const customCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$5.get(container);
-		if (parts) syncTextResolution(parts.label, parts.label, context.zoom);
+		if (parts) syncTextResolution(parts.label, context.textResolution);
 	},
 	renderFar: (graphics, item, context) => {
 		drawFarPlate(graphics, item.frame, {
@@ -30047,10 +30027,6 @@ function sync$3(container, item, context) {
 	const detailText = !full || !surface ? "" : status === "failed" ? snapshot.errorExcerpt ?? "" : working ? snapshot.promptExcerpt ?? "" : "";
 	const textArtifact = kind === "text" && artifact?.type === "text";
 	const bodyText = textArtifact ? artifact.textExcerpt : counting ? `${label} · ${elapsed}` : label;
-	syncTextResolution(parts.body, parts, context.zoom);
-	syncTextResolution(parts.detail, parts, context.zoom);
-	syncTextResolution(parts.meta, parts, context.zoom);
-	syncTextResolution(parts.badge, parts, context.zoom);
 	const textSig = [
 		counting ? label : bodyText,
 		detailText,
@@ -30081,6 +30057,12 @@ function sync$3(container, item, context) {
 		parts.badge.style.fill = context.palette.text;
 		if (parts.badge.text !== count) parts.badge.text = count;
 	}
+	for (const text of [
+		parts.body,
+		parts.detail,
+		parts.meta,
+		parts.badge
+	]) syncTextResolution(text, context.textResolution);
 	const badgeWidth = Math.max(22, parts.badge.width + 12);
 	const visualSig = [
 		width,
@@ -30198,7 +30180,6 @@ const taskCardRenderer = {
 		const previewMask = new Graphics();
 		const shimmer = new Graphics();
 		const previewArt = new Graphics();
-		const resolution = textResolutionForZoom(context.zoom);
 		const text = (fontFamily, fontSize, fontWeight) => new Text({
 			text: "",
 			style: {
@@ -30208,7 +30189,7 @@ const taskCardRenderer = {
 				wordWrap: true,
 				breakWords: true
 			},
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		const body = text(BOARD_FONT_STACK, 11.5, "500");
@@ -30242,7 +30223,6 @@ const taskCardRenderer = {
 			assetKey: null,
 			visualSig: "",
 			textSig: "",
-			resolution,
 			motion: {
 				itemId: "",
 				width: 0,
@@ -30319,7 +30299,6 @@ function sync$2(container, item, context) {
 	const anchorX = props.align === "center" ? .5 : props.align === "right" ? 1 : 0;
 	parts.body.anchor.set(anchorX, 0);
 	parts.body.position.set(item.frame.width * anchorX, 0);
-	syncTextResolution(parts.body, parts, context.zoom * Math.max(1, previewScale));
 	parts.body.alpha = itemAlpha(context, item.style.fill);
 	parts.caret.alpha = parts.body.alpha;
 	const ink = itemColor(context, item.style.fill, "neutral");
@@ -30349,6 +30328,7 @@ function sync$2(container, item, context) {
 			breakWords: true
 		});
 	}
+	syncTextResolution(parts.body, context.textResolution * previewScale);
 	syncCaret(parts, item, context);
 }
 const textCardRenderer = {
@@ -30356,11 +30336,10 @@ const textCardRenderer = {
 	canRender: (item) => item.type === "text",
 	create: (item, context) => {
 		const root = new Container();
-		const resolution = textResolutionForZoom(context.zoom);
 		const body = new Text({
 			text: "",
 			style: { fontFamily: BOARD_FONT_STACKS.sans },
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		const caret = new Graphics();
@@ -30369,7 +30348,6 @@ const textCardRenderer = {
 			root,
 			body,
 			caret,
-			resolution,
 			contentSig: ""
 		});
 		if (item.type === "text") sync$2(root, item, context);
@@ -30380,7 +30358,7 @@ const textCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$2.get(container);
-		if (parts) syncTextResolution(parts.body, parts, context.zoom * Math.max(1, parts.body.scale.x));
+		if (parts) syncTextResolution(parts.body, context.textResolution * parts.body.scale.x);
 	},
 	renderFar: (graphics, item, context) => {
 		if (item.type !== "text") return;
@@ -30403,7 +30381,6 @@ function sync$1(container, item, context) {
 	positionShell(parts.root, item);
 	const { width, height } = item.frame;
 	const realType = item.type;
-	syncTextResolution(parts.label, parts, context.zoom);
 	const elevation = cardElevation(context, item.id);
 	const visualSig = [
 		width,
@@ -30438,6 +30415,7 @@ function sync$1(container, item, context) {
 		parts.label.text = realType;
 		parts.label.style.fill = context.palette.muted;
 	}
+	syncTextResolution(parts.label, context.textResolution);
 	parts.label.position.set(width / 2, height / 2);
 }
 const unknownCardRenderer = {
@@ -30447,7 +30425,6 @@ const unknownCardRenderer = {
 		const root = new Container();
 		const box = new Graphics();
 		box.context.batchMode = "batch";
-		const resolution = textResolutionForZoom(context.zoom);
 		const label = new Text({
 			text: "",
 			style: {
@@ -30455,7 +30432,7 @@ const unknownCardRenderer = {
 				fontSize: 11,
 				fontWeight: "600"
 			},
-			resolution,
+			resolution: context.textResolution,
 			roundPixels: true
 		});
 		label.anchor.set(.5);
@@ -30465,8 +30442,7 @@ const unknownCardRenderer = {
 			box,
 			label,
 			visualSig: "",
-			textSig: "",
-			resolution
+			textSig: ""
 		});
 		sync$1(root, item, context);
 		return root;
@@ -30476,7 +30452,7 @@ const unknownCardRenderer = {
 	},
 	resolution: (container, _item, context) => {
 		const parts = partsByContainer$1.get(container);
-		if (parts) syncTextResolution(parts.label, parts, context.zoom);
+		if (parts) syncTextResolution(parts.label, context.textResolution);
 	},
 	renderFar: (graphics, item, context) => {
 		drawFarPlate(graphics, item.frame, {
@@ -31642,6 +31618,7 @@ function buildContext(input) {
 			themeKey: "export",
 			rendererType: "canvas",
 			zoom: input.scale,
+			textResolution: input.scale,
 			reducedMotion: true,
 			labels: DEFAULT_BOARD_RENDER_LABELS,
 			taskRun: () => null,

package/dist/runtime/connection.js

@@ -4,6 +4,7 @@ import { RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, runtimeCommandSchema
 import { describeError } from "../network-error.js";
 import { executeTurn } from "./native/execution.js";
 import { ContextRequiredError } from "./native/results.js";
+import { SizeLimitError } from "./native/transcript.js";
 import { ProcessCleanupUncertainError } from "./process-group.js";
 import { serializeDiagnosticError, } from "./diagnostics.js";
 export async function serveRuntime(options) {
@@ -11,6 +12,11 @@ export async function serveRuntime(options) {
     let backoff = 500;
     let attempt = 0;
     let conflictSince = null;
+    // Executions outlive a single transport so a dropped socket reconnects immediately
+    // instead of waiting for in-flight turns to finish.
+    const executions = new Map();
+    const seen = new Set();
+    const announce = { current: null };
     const uploads = new AbortController();
     const uploadSignal = AbortSignal.any([options.signal, uploads.signal]);
     const log = (level, event, data, context) => options.diagnostics?.log(level, event, data, context);
@@ -33,12 +39,16 @@ export async function serveRuntime(options) {
         while (!options.signal.aborted) {
             attempt += 1;
             let readyAt = 0;
+            const connectStartedAt = Date.now();
             let outcome;
             try {
                 outcome = await connect({
                     ...options,
                     runtimeId,
                     attempt,
+                    executions,
+                    seen,
+                    announce,
                     onReady: () => {
                         readyAt = Date.now();
                         conflictSince = null;
@@ -72,18 +82,40 @@ export async function serveRuntime(options) {
                 attempt: attempt || 1,
                 delayMs: backoff,
                 outcome: outcome.kind,
+                connectedMs: Date.now() - connectStartedAt,
+                readyMs: readyAt ? Date.now() - readyAt : null,
+                activeExecutions: executions.size,
             });
             await delay(backoff / 2 + Math.random() * backoff / 2, undefined, { signal: options.signal }).catch(() => undefined);
             backoff = Math.min(30_000, backoff * 2);
         }
     }
     finally {
+        for (const execution of executions.values())
+            execution.controller.abort();
+        await Promise.allSettled([...executions.values()].map((entry) => entry.promise));
         clearInterval(timer);
         uploads.abort();
         await flush();
         log("info", "runtime.stopped", { runtimeId });
     }
 }
+function frameIdentity(frame) {
+    const value = frame;
+    const event = value?.event;
+    const pick = (input) => typeof input === "string" ? input : undefined;
+    return {
+        frameType: pick(value?.type),
+        requestId: pick(value?.requestId),
+        eventType: pick(event?.type),
+        sessionId: pick(event?.sessionId) ?? pick(event?.input?.sessionId),
+        turnId: pick(event?.turnId) ?? pick(event?.input?.turnId),
+        harness: pick(event?.input?.harness),
+        nativeSessionId: pick(event?.input?.nativeSessionId),
+        turnCount: Array.isArray(event?.input?.turns) ? event.input.turns.length : undefined,
+        turnIds: Array.isArray(event?.input?.turns) ? event.input.turns.slice(0, 10).map((turn) => pick(turn?.turnId)).filter(Boolean) : undefined,
+    };
+}
 function executionContext(connectionId, input) {
     return {
         connectionId,
@@ -112,11 +144,13 @@ async function connect(options) {
     const runtimeUrl = new URL(options.url);
     runtimeUrl.searchParams.set("runtimeId", options.runtimeId);
     const socket = new WebSocket(runtimeUrl.toString());
-    const active = new Map();
-    const seen = new Set();
+    const active = options.executions;
+    const seen = options.seen;
     const disconnected = new AbortController();
     const contexts = new Map();
     let lastHeartbeat = Date.now();
+    let openedAt = 0;
+    let readyAt = 0;
     let connectionId = null;
     let fatal = false;
     let fatalCode = 0;
@@ -137,8 +171,10 @@ async function connect(options) {
         const data = JSON.stringify(frame);
         const bytes = Buffer.byteLength(data);
         if (bytes > RUNTIME_MAX_FRAME_BYTES) {
-            log("error", "runtime.frame_too_large", { bytes, maxBytes: RUNTIME_MAX_FRAME_BYTES }, { connectionId });
-            throw new Error("Runtime frame exceeds transfer limit");
+            const identity = frameIdentity(frame);
+            const execution = identity.requestId ? active.get(identity.requestId) : undefined;
+            log("error", "runtime.frame_too_large", { bytes, maxBytes: RUNTIME_MAX_FRAME_BYTES, ...identity }, execution ? executionContext(connectionId, execution) : { connectionId });
+            throw new SizeLimitError("Runtime frame exceeds transfer limit");
         }
         socket.send(data);
     };
@@ -173,8 +209,13 @@ async function connect(options) {
             log("error", "runtime.heartbeat_timeout", {
                 ageMs: heartbeatAgeMs,
                 activeExecutions: active.size,
+                readyState: socket.readyState,
+                bufferedBytes: socket.bufferedAmount,
             }, { connectionId });
             closeTransport();
+            // A half-open TCP path may never deliver the close event; stop waiting so reconnect can start.
+            if (heartbeatAgeMs > 45_000)
+                handleClose({ code: 1006, reason: "Runtime heartbeat timed out", wasClean: false }, true);
         }
         else if (connectionId) {
             try {
@@ -206,52 +247,108 @@ async function connect(options) {
             });
         }
     }, 10_000);
-    const closed = new Promise((resolve) => {
-        socket.addEventListener("close", (event) => {
-            unauthorized = event.code === 4401;
-            fatal = [4400, 4403].includes(event.code);
-            if (fatal) {
-                fatalCode = event.code;
-                fatalReason = event.reason;
+    const announceHere = (execution) => {
+        try {
+            send({ type: "runtime.recovery", executions: [execution] });
+            log("info", "runtime.detached_result_announced", undefined, executionContext(connectionId, execution));
+        }
+        catch {
+            // The next ready connection reports every pending receipt.
+        }
+    };
+    /** Replays a saved result, or answers explicitly that none is available; never leaves the server waiting. */
+    const replaySaved = async (requestId, input, context, executionRequestId) => {
+        let saved = null;
+        try {
+            saved = await options.executor.results.recover(input, executionRequestId);
+        }
+        catch (error) {
+            log("error", "runtime.recovery_failed", { error: serializeDiagnosticError(error) }, context);
+        }
+        if (saved)
+            for (const event of saved.events)
+                send({ type: "runtime.event", requestId, event });
+        else
+            send({ type: "runtime.event", requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained" } });
+    };
+    let closeHandled = false;
+    let resolveClosed = () => { };
+    const closed = new Promise((resolve) => { resolveClosed = resolve; });
+    const handleClose = (event, forced = false) => {
+        if (closeHandled)
+            return;
+        closeHandled = true;
+        unauthorized = event.code === 4401;
+        fatal = [4400, 4403].includes(event.code);
+        if (fatal) {
+            fatalCode = event.code;
+            fatalReason = event.reason;
+        }
+        conflict = event.code === 4409;
+        disconnected.abort();
+        const now = Date.now();
+        log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", fatal ? "runtime.websocket.rejected" : "runtime.websocket.closed", {
+            code: event.code,
+            reason: event.reason,
+            wasClean: event.wasClean,
+            forced,
+            durationMs: now - connectedAt,
+            openMs: openedAt ? now - openedAt : null,
+            readyMs: readyAt ? now - readyAt : null,
+            lastInboundAgeMs: now - lastHeartbeat,
+            bufferedBytes: socket.bufferedAmount,
+            activeExecutions: active.size,
+            fatal,
+            conflict,
+        }, { connectionId });
+        nativeChannelReady = false;
+        for (const pending of nativePending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Runtime native channel disconnected"));
+        }
+        nativePending.clear();
+        options.onDisconnected?.();
+        const executionMustStop = options.signal.aborted || fatal || conflict;
+        if (options.announce.current === announceHere)
+            options.announce.current = null;
+        for (const [requestId, execution] of active) {
+            if (executionMustStop) {
+                log("error", "runtime.execution_transport_invalidated", { code: event.code, reason: event.reason }, executionContext(connectionId, execution));
+                execution.controller.abort();
             }
-            conflict = event.code === 4409;
-            disconnected.abort();
-            log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", fatal ? "runtime.websocket.rejected" : "runtime.websocket.closed", {
-                code: event.code,
-                reason: event.reason,
-                durationMs: Date.now() - connectedAt,
-                activeExecutions: active.size,
-                fatal,
-                conflict,
-            }, { connectionId });
-            nativeChannelReady = false;
-            for (const pending of nativePending.values()) {
-                clearTimeout(pending.timer);
-                pending.reject(new Error("Runtime native channel disconnected"));
+            else if (execution.recovery) {
+                // The server re-asks on the next connection; a stale waiter must not hold a slot or its request id.
+                execution.controller.abort();
             }
-            nativePending.clear();
-            options.onDisconnected?.();
-            const executionMustStop = options.signal.aborted || fatal || conflict;
-            for (const execution of active.values()) {
-                log(executionMustStop ? "error" : "warn", executionMustStop ? "runtime.execution_transport_invalidated" : "runtime.execution_transport_detached", {
-                    code: event.code,
-                    reason: event.reason,
-                }, executionContext(connectionId, execution));
-                if (executionMustStop)
-                    execution.controller.abort();
+            else if (!execution.detached) {
+                execution.detached = true;
+                log("warn", "runtime.execution_transport_detached", { code: event.code, reason: event.reason }, executionContext(connectionId, execution));
+                // The server may have stopped asking by the time this finishes; a saved result is announced again.
+                void execution.promise.finally(() => {
+                    if (!execution.result || active.get(requestId) !== execution)
+                        return;
+                    options.announce.current?.({ sessionId: execution.sessionId, turnId: execution.turnId, harness: execution.harness });
+                });
             }
-            resolve();
-        }, { once: true });
-    });
+        }
+        resolveClosed();
+    };
+    socket.addEventListener("close", (event) => handleClose(event), { once: true });
     socket.addEventListener("error", (event) => {
-        const detail = event.error;
+        const detail = event;
         log("warn", "runtime.websocket.error", {
             type: event.type,
-            error: serializeDiagnosticError(detail ?? new Error("WebSocket error")),
+            message: typeof detail.message === "string" && detail.message ? detail.message : undefined,
+            readyState: socket.readyState,
+            opened: openedAt > 0,
+            ready: readyAt > 0,
+            lastInboundAgeMs: Date.now() - lastHeartbeat,
+            error: serializeDiagnosticError(detail.error ?? new Error("WebSocket error")),
         }, { connectionId });
         socket.close();
     });
     socket.addEventListener("open", () => {
+        openedAt = Date.now();
         try {
             log("info", "runtime.websocket.open", {
                 attempt: options.attempt,
@@ -289,14 +386,17 @@ async function connect(options) {
                 if (connectionId)
                     throw new Error("Runtime connection identity changed");
                 connectionId = frame.connectionId;
+                readyAt = Date.now();
                 clearTimeout(readyTimer);
                 log("info", "runtime.ready", {
                     connectionId,
-                    durationMs: Date.now() - connectedAt,
+                    durationMs: readyAt - connectedAt,
+                    detachedExecutions: [...active.values()].filter((entry) => entry.detached).length,
                 }, { connectionId });
                 nativeChannelReady = true;
                 options.onNativeChannel?.(sendNative);
                 options.onReady();
+                options.announce.current = announceHere;
                 let recoveryBatch = 0;
                 for await (const executions of options.executor.results.pendingBatches()) {
                     recoveryBatch += 1;
@@ -391,10 +491,7 @@ async function connect(options) {
                     if (previous.sessionId !== identity.sessionId || previous.turnId !== identity.turnId || previous.harness !== identity.harness)
                         throw new Error("Runtime recovery identity changed");
                     await previous.promise;
-                    const saved = await options.executor.results.recover(identity);
-                    if (saved)
-                        for (const event of saved.events)
-                            send({ type: "runtime.event", requestId: frame.requestId, event });
+                    await replaySaved(frame.requestId, identity, context);
                     return;
                 }
                 const running = [...active].find(([, entry]) => entry.turnId === identity.turnId && entry.sessionId === identity.sessionId && entry.harness === identity.harness);
@@ -404,14 +501,26 @@ async function connect(options) {
                     traceContext: frame.traceContext,
                     controller: new AbortController(),
                     promise: Promise.resolve(),
+                    recovery: true,
                 };
                 active.set(frame.requestId, recovery);
                 recovery.promise = (async () => {
                     try {
                         if (running) {
-                            running[1].controller.abort();
-                            await running[1].promise;
-                            active.delete(running[0]);
+                            // A detached execution was not superseded by this host; wait for its result instead of discarding it.
+                            if (running[1].detached) {
+                                log("info", "runtime.recovery_waiting_detached", { runningRequestId: running[0] }, context);
+                                // A recovery the server gave up on must not hold an execution slot until the Turn ends.
+                                const stopped = recovery.controller.signal;
+                                await Promise.race([running[1].promise, new Promise((resolve) => stopped.addEventListener("abort", () => resolve(), { once: true }))]);
+                                stopped.throwIfAborted();
+                            }
+                            else {
+                                running[1].controller.abort();
+                                await running[1].promise;
+                            }
+                            if (active.get(running[0]) === running[1])
+                                active.delete(running[0]);
                         }
                         const saved = await options.executor.results.recover(identity);
                         recovery.controller.signal.throwIfAborted();
@@ -433,7 +542,8 @@ async function connect(options) {
                                 // The next connection can read the same result.
                             }
                         }
-                        active.delete(frame.requestId);
+                        if (active.get(frame.requestId) === recovery)
+                            active.delete(frame.requestId);
                     }
                 })();
                 return;
@@ -449,11 +559,9 @@ async function connect(options) {
             if (previous) {
                 if (previous.sessionId !== frame.input.sessionId || previous.turnId !== frame.input.turnId || previous.harness !== frame.input.harness)
                     throw new Error("Runtime execution identity changed");
+                log("info", "runtime.execution_resumed", { detached: previous.detached === true, settled: Boolean(previous.result) }, executionContext(connectionId, frame.input));
                 await previous.promise;
-                const saved = await options.executor.results.recover(frame.input, frame.requestId);
-                if (saved)
-                    for (const event of saved.events)
-                        send({ type: "runtime.event", requestId: frame.requestId, event });
+                await replaySaved(frame.requestId, frame.input, context, frame.requestId);
                 return;
             }
             const requestContext = async (executionSignal) => {
@@ -601,7 +709,6 @@ async function connect(options) {
         shutdown();
     try {
         await closed;
-        await Promise.allSettled([...active.values()].map((entry) => entry.promise));
     }
     finally {
         clearTimeout(readyTimer);

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

@@ -118,6 +118,8 @@ export declare class NativeIngest {
     private readonly reads;
     private readonly timers;
     private readonly failures;
+    /** File versions that hit a size limit; they are not read again until the file changes. */
+    private readonly oversized;
     private readonly aliveAt;
     private readonly runningPaths;
     /** Files a live Cohub execution is writing in a format that cannot mark its Turn. */
@@ -210,14 +212,19 @@ export declare class NativeIngest {
     };
     transcriptFor(sessionId: string, harness: Harness, headTurnId: string | null): TranscriptState | null;
     scan(): Promise<void>;
-    plan(filter?: ImportFilter, signal?: AbortSignal): Promise<Array<NativeCandidate & {
+    /** `resume` is automatic resumption: it skips file versions that already hit a size limit, which only an explicit import retries. */
+    plan(filter?: ImportFilter, signal?: AbortSignal, options?: {
+        resume?: boolean;
+    }): Promise<Array<NativeCandidate & {
         nativeSessionId?: string;
     }>>;
     /**
      * Start or resume a backfill. What was imported is tracked, so resuming simply plans again; the
      * server recognizes any Turn it already has, so an interrupted batch is never duplicated.
      */
-    startImport(filter?: ImportFilter, concurrency?: number): Promise<ImportJob>;
+    startImport(filter?: ImportFilter, concurrency?: number, options?: {
+        resume?: boolean;
+    }): Promise<ImportJob>;
     pauseImport(): ImportJob;
     watch(signal: AbortSignal): Promise<void>;
     private watchHarness;
@@ -231,6 +238,7 @@ export declare class NativeIngest {
     private report;
     private sync;
     private read;
+    private readVersion;
     private crossesBoundary;
     private blank;
     private harnessFor;

package/dist/runtime/native/ingest.js

@@ -2,6 +2,7 @@ import { appendFile, mkdir, open, readFile, readdir, rename, stat } from "node:f
 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 { SizeLimitError } from "./transcript.js";
 import { nativeTurnId } from "./identity.js";
 import { harnessAdapter, transcriptFormat } from "../harnesses/index.js";
 import { containsNativePath } from "./paths.js";
@@ -27,6 +28,7 @@ const RETRY_MAX_MS = 5 * 60_000;
  */
 const INGEST_BATCH_TURNS = Math.min(50, NATIVE_INGEST_MAX_TURNS);
 const IMPORT_FAILURES_KEPT = 100;
+const fileVersion = (info) => `${info.ino}:${info.size}:${info.mtimeMs}`;
 /** Headers are read this many at a time; each costs one small read. */
 const HEADER_CONCURRENCY = 16;
 /** Whether a session in `cwd` belongs to the directory bound at `root`. */
@@ -105,6 +107,8 @@ export class NativeIngest {
     reads = new Set();
     timers = new Map();
     failures = new Map();
+    /** File versions that hit a size limit; they are not read again until the file changes. */
+    oversized = new Map();
     aliveAt = new Map();
     runningPaths = new Set();
     /** Files a live Cohub execution is writing in a format that cannot mark its Turn. */
@@ -320,21 +324,23 @@ export class NativeIngest {
         }
         this.drainLive();
         if (this.job.state === "running")
-            await this.startImport(this.job.filter, this.job.concurrency);
+            await this.startImport(this.job.filter, this.job.concurrency, { resume: true });
     }
-    async plan(filter = {}, signal) {
+    /** `resume` is automatic resumption: it skips file versions that already hit a size limit, which only an explicit import retries. */
+    async plan(filter = {}, signal, options = {}) {
         const harnesses = this.harnesses.filter((harness) => !filter.harnesses?.length || filter.harnesses.includes(harness));
         const candidates = await discoverTranscripts(this.options.cwd, harnesses, { headers: true, nested: this.nested, signal });
         // A transcript whose first read failed is still untracked (size -1), so a later import retries it.
         return candidates.filter((candidate) => (this.states.get(candidate.path)?.size ?? -1) < 0 && !this.live.has(candidate.path)
+            && !(options.resume && this.oversized.get(candidate.path) === fileVersion(candidate))
             && (!filter.nativeSessionId || candidate.nativeSessionId === filter.nativeSessionId));
     }
     /**
      * Start or resume a backfill. What was imported is tracked, so resuming simply plans again; the
      * server recognizes any Turn it already has, so an interrupted batch is never duplicated.
      */
-    async startImport(filter = {}, concurrency = DEFAULT_IMPORT_CONCURRENCY) {
-        const queue = await this.plan(filter);
+    async startImport(filter = {}, concurrency = DEFAULT_IMPORT_CONCURRENCY, options = {}) {
+        const queue = await this.plan(filter, undefined, options);
         const resuming = this.job.state === "running" || this.job.state === "paused";
         const same = resuming && JSON.stringify(this.job.filter) === JSON.stringify(filter);
         const base = same ? this.job : { ...this.job, done: 0, turns: 0, bytes: 0, failed: [], startedAt: new Date().toISOString() };
@@ -450,7 +456,7 @@ export class NativeIngest {
     }
     retryLater(path, error) {
         this.report(path, error);
-        if (this.stopped || !this.transport)
+        if (this.stopped || !this.transport || error instanceof SizeLimitError)
             return;
         const attempts = (this.failures.get(path) ?? 0) + 1;
         if (attempts > RETRY_ATTEMPTS) {
@@ -508,6 +514,20 @@ export class NativeIngest {
             return null; throw error; });
         if (!info?.isFile())
             return;
+        const version = fileVersion(info);
+        if (lane === "live" && this.oversized.get(path) === version)
+            return;
+        this.oversized.delete(path);
+        try {
+            await this.readVersion(path, lane, force, info);
+        }
+        catch (error) {
+            if (error instanceof SizeLimitError)
+                this.oversized.set(path, version);
+            throw error;
+        }
+    }
+    async readVersion(path, lane, force, info) {
         const previous = this.states.get(path);
         // Unchanged bytes can still hold a Turn whose end the control plane has only now reported.
         if (previous && this.unchanged(previous, info) && !(force && previous.runningTurnId))

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

@@ -41,6 +41,10 @@ export type TranscriptLine = {
 };
 type Line = TranscriptLine;
 export declare const iso: (value: unknown) => string;
+/** A size limit that the same bytes will hit again; retrying before the file changes is wasted work. */
+export declare class SizeLimitError extends Error {
+    name: string;
+}
 export declare const NATIVE_MAX_RECORD_BYTES: number;
 export declare const NATIVE_MAX_TRANSCRIPT_BYTES: number;
 export declare const codexSessionsDirectory: () => string;

package/dist/runtime/native/transcript.js

@@ -19,6 +19,10 @@ export const iso = (value) => {
     return date.toISOString();
 };
 const missing = (error) => error?.code === "ENOENT";
+/** A size limit that the same bytes will hit again; retrying before the file changes is wasted work. */
+export class SizeLimitError extends Error {
+    name = "SizeLimitError";
+}
 export const NATIVE_MAX_RECORD_BYTES = 256 * 1024 * 1024;
 export const NATIVE_MAX_TRANSCRIPT_BYTES = 1024 * 1024 * 1024;
 const NATIVE_HEADER_MAX_BYTES = 1024 * 1024;
@@ -203,7 +207,7 @@ export async function ensurePlainCodexRollout(path, cacheDirectory, signal, maxB
             transform(chunk, _encoding, push) {
                 written += chunk.length;
                 if (written > maxBytes) {
-                    push(new Error("Decompressed rollout exceeds the local limit"));
+                    push(new SizeLimitError("Decompressed rollout exceeds the local limit"));
                     return;
                 }
                 push(null, chunk);
@@ -231,9 +235,9 @@ export async function readTranscriptLines(stream) {
         pendingBytes += bytes.length;
         checksum.update(bytes);
         if (pendingBytes > NATIVE_MAX_RECORD_BYTES)
-            throw new Error("Native record exceeds the 256 MiB local parse limit; original retained");
+            throw new SizeLimitError("Native record exceeds the 256 MiB local parse limit; original retained");
         if (offset + pendingBytes > NATIVE_MAX_TRANSCRIPT_BYTES)
-            throw new Error("Native transcript exceeds the 1 GiB local parse limit; original retained");
+            throw new SizeLimitError("Native transcript exceeds the 1 GiB local parse limit; original retained");
     };
     for await (const chunk of stream) {
         let start = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.8.0",
+  "version": "10.8.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "12.0.0",
+    "@neta-art/cohub": "12.1.0",
     "@neta-art/generation": "^0.1.40",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",