@neta-art/cohub-cli 9.1.1 → 9.1.2

package/dist/board-export.d.ts

@@ -1,16 +1,16 @@
 import type { BoardDocument, BoardExportRegion, BoardSceneItem } from "@neta-art/cohub/board";
-import type { BoardHeadlessExportFormat, BoardHeadlessFont, BoardHeadlessRenderer, BoardHeadlessTexture } from "@neta-art/cohub/board/headless";
-export declare function resolveBundledFonts(): BoardHeadlessFont[];
+import type { BoardNodeExportFormat, BoardNodeFont, BoardNodeRenderer, BoardNodeTexture } from "@neta-art/cohub/board/export/node";
+export declare function resolveBundledFonts(): BoardNodeFont[];
 export type BoardExportSource = {
     document: BoardDocument;
     boardId: string;
     title: string | null;
 };
 export declare function loadBoardDocument(spaceId: string, target: string): Promise<BoardExportSource>;
-export declare function loadBoardTextures(headless: BoardHeadlessRenderer, spaceId: string, items: readonly BoardSceneItem[], options?: {
+export declare function loadBoardTextures(renderer: BoardNodeRenderer, spaceId: string, items: readonly BoardSceneItem[], options?: {
     concurrency?: number;
 }): Promise<{
-    textures: Map<string, BoardHeadlessTexture>;
+    textures: Map<string, BoardNodeTexture>;
     failed: string[];
     omitted: string[];
 }>;
@@ -24,7 +24,7 @@ export type BoardExportRunOptions = {
     padding?: number;
     colorScheme: "dark" | "light";
     background: "paper" | "transparent";
-    format: BoardHeadlessExportFormat;
+    format: BoardNodeExportFormat;
     quality?: number;
     withImages: boolean;
 };
@@ -35,7 +35,7 @@ export type BoardExportFrame = {
     height: number;
     scale: number;
     itemCount: number;
-    format: BoardHeadlessExportFormat;
+    format: BoardNodeExportFormat;
 };
 export type BoardExportRunResult = {
     frames: BoardExportFrame[];

package/dist/board-export.js

@@ -7,7 +7,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
 const execFile = promisify(execFileCallback);
-import { boardDocumentAt, boardImageKeySource, buildBoardScene, createBoardHeadlessRenderer, createBoardHeadlessSketchHost, exportBoardImageBytes, imageAssetKey, parseBoardDocument, planBoardExport, selectBoardExportAssets, } from "./board-kernel.js";
+import { boardDocumentAt, boardImageKeySource, buildBoardScene, createNodeBoardRenderer, createNodeBoardSketchHost, exportBoardImageBytes, imageAssetKey, parseBoardDocument, planBoardExport, selectBoardExportAssets, } from "./board-kernel.js";
 import { resolveBoardId } from "./board-command-support.js";
 import { BOARD_EXPORT_FONTS } from "./board-fonts.js";
 import { createClient } from "./client.js";
@@ -45,7 +45,7 @@ export async function loadBoardDocument(spaceId, target) {
         throw new Error(`Board ${result.id} could not be read: ${parsed.diagnostics[0]?.path}: ${parsed.diagnostics[0]?.message}`);
     return { document: parsed.document, boardId: result.id, title: result.title };
 }
-export async function loadBoardTextures(headless, spaceId, items, options = {}) {
+export async function loadBoardTextures(renderer, spaceId, items, options = {}) {
     const selection = selectBoardExportAssets([...items], imageAssetKey);
     const textures = new Map();
     const failed = [];
@@ -66,7 +66,7 @@ export async function loadBoardTextures(headless, spaceId, items, options = {})
                 const { bytes, mimeType } = source.kind === "file"
                     ? await readSpaceFileBytes(client, spaceId, source.value)
                     : await downloadPublicImage(source.value);
-                const texture = await headless.decodeImage(bytes, mimeType);
+                const texture = await renderer.decodeImage(bytes, mimeType);
                 textures.set(key, texture);
             }
             catch {
@@ -161,7 +161,7 @@ export async function runBoardExport(options) {
     });
     if (!plan)
         return null;
-    const headless = await createBoardHeadlessRenderer({ fonts: resolveBundledFonts() });
+    const renderer = await createNodeBoardRenderer({ fonts: resolveBundledFonts() });
     let sketchHost = null;
     try {
         const warnings = [];
@@ -169,7 +169,7 @@ export async function runBoardExport(options) {
         let backgroundTexture;
         let omittedKeys = new Set();
         if (options.withImages) {
-            const loaded = await loadBoardTextures(headless, options.spaceId, plan.items);
+            const loaded = await loadBoardTextures(renderer, options.spaceId, plan.items);
             textures = loaded.textures;
             omittedKeys = new Set(loaded.omitted);
             if (loaded.failed.length > 0) {
@@ -186,14 +186,14 @@ export async function runBoardExport(options) {
             declaredBackground.imageUrl) {
             try {
                 const { bytes, mimeType } = await downloadPublicImage(declaredBackground.imageUrl);
-                backgroundTexture = await headless.decodeImage(bytes, mimeType);
+                backgroundTexture = await renderer.decodeImage(bytes, mimeType);
             }
             catch {
                 warnings.push("The board background image could not be loaded; the fallback color was exported.");
             }
         }
         const videoCount = plan.items.filter((item) => item.type === "video").length;
-        sketchHost = createBoardHeadlessSketchHost(headless, {
+        sketchHost = createNodeBoardSketchHost(renderer, {
             readModule: async (src) => {
                 const { bytes } = await readSpaceFileBytes(createClient(), options.spaceId, src);
                 return new TextDecoder().decode(bytes);
@@ -202,7 +202,7 @@ export async function runBoardExport(options) {
         const region = times.length > 1 ? { kind: "rect", rect: plan.world } : options.region;
         const host = sketchHost;
         if (!host)
-            throw new Error("Headless sketch host could not be created.");
+            throw new Error("Node sketch host could not be created.");
         const sketchVariants = new Map();
         for (const time of times) {
             const sketchPlan = planBoardExport({
@@ -220,7 +220,7 @@ export async function runBoardExport(options) {
         }
         await Promise.all([...sketchVariants.values()].map((variant) => host.prepare([variant.item], variant.times, plan.scale)));
         if (videoCount > 0) {
-            warnings.push(`${videoCount} video preview${videoCount === 1 ? " was" : "s were"} drawn as placeholders; headless video decoding is unavailable.`);
+            warnings.push(`${videoCount} video preview${videoCount === 1 ? " was" : "s were"} drawn as placeholders; video decoding is unavailable in Node.`);
         }
         const backgroundImage = backgroundTexture
             ? { texture: backgroundTexture, fit: declaredBackground.fit ?? "cover", position: "center", opacity: declaredBackground.opacity ?? 1 }
@@ -234,7 +234,7 @@ export async function runBoardExport(options) {
         const frames = [];
         const reported = new Set();
         for (const time of times) {
-            const result = exportBoardImageBytes(headless, document, {
+            const result = exportBoardImageBytes(renderer, document, {
                 ...(time === null ? {} : { at: { ...(options.animation ? { animation: options.animation } : {}), time } }),
                 region,
                 scale: options.scale,
@@ -272,7 +272,7 @@ export async function runBoardExport(options) {
     }
     finally {
         sketchHost?.destroy();
-        headless.destroy();
+        renderer.destroy();
     }
 }
 function describeWarning(warning) {

package/dist/board-kernel.d.ts

@@ -1,2 +1,2 @@
 export { boardDocumentAt, boardImageKeySource, buildBoardScene, imageAssetKey, parseBoardDocument, planBoardExport, selectBoardExportAssets, } from "@neta-art/cohub/board";
-export { createBoardHeadlessRenderer, createBoardHeadlessSketchHost, exportBoardImageBytes } from "@neta-art/cohub/board/headless";
+export { createNodeBoardRenderer, createNodeBoardSketchHost, exportBoardImageBytes } from "@neta-art/cohub/board/export/node";

package/dist/board-kernel.js

@@ -7119,7 +7119,7 @@ function parseBoardDocument(input) {
 	} : result;
 }
 //#endregion
-//#region ../sdk/src/board/animation.ts
+//#region ../sdk/src/board/model/animation.ts
 const linear = (x) => x;
 function cubicBezier(x1, y1, x2, y2) {
 	const cx = 3 * x1;
@@ -7519,7 +7519,7 @@ function boardDocumentAt(document, animationId, time, options = {}) {
 	};
 }
 //#endregion
-//#region ../sdk/src/board/geometry.ts
+//#region ../sdk/src/board/model/geometry.ts
 function worldPoint(x, y) {
 	return {
 		x,
@@ -7862,7 +7862,7 @@ const { PI: e } = Math;
 e + 1e-4;
 const { min: a } = Math;
 //#endregion
-//#region ../sdk/src/board/core/draw-geometry.ts
+//#region ../sdk/src/board/model/draw-geometry.ts
 const sampleRadius = drawSampleRadius;
 const computeDrawBounds = drawPointsBounds;
 function trimDrawPoints(points, trim) {
@@ -8038,7 +8038,7 @@ function selectBoardExportAssets(items, assetKey, maxTextures = 64) {
 	};
 }
 //#endregion
-//#region ../sdk/src/board/core/export-plan.ts
+//#region ../sdk/src/board/model/export-plan.ts
 function normalizeBoardDocument(document) {
 	const parsed = parseBoardDocument(document);
 	if (!parsed.ok) throw new Error(`Invalid Board document: ${parsed.diagnostics.map((entry) => `${entry.path}: ${entry.message}`).join("; ")}`);
@@ -8152,7 +8152,7 @@ function planBoardExport(input) {
 	};
 }
 //#endregion
-//#region ../sdk/src/board/core/file-snapshot.ts
+//#region ../sdk/src/board/model/file-snapshot.ts
 const DOC_EXTENSIONS = /* @__PURE__ */ new Set([
 	"md",
 	"mdx",
@@ -8280,7 +8280,7 @@ function fileStem(path) {
 	return name.slice(0, dot);
 }
 //#endregion
-//#region ../sdk/src/board/core/file-preview.ts
+//#region ../sdk/src/board/model/file-preview.ts
 /**
 * Which tier a card renders at. Derived rather than stored: presentation follows
 * from the facts present, so there is no second piece of state to fall out of
@@ -8310,7 +8310,7 @@ function fileCategoryAccent(category, palette) {
 	}
 }
 //#endregion
-//#region ../sdk/src/board/core/palette.ts
+//#region ../sdk/src/board/model/palette.ts
 const LABEL_DARK = 16053492;
 const LABEL_LIGHT = 1579035;
 const BOARD_COLORS = [
@@ -8467,7 +8467,7 @@ function resolveItemColor(color, fallback, colors, mode, parseCss, part = "strok
 	return parseCss(value) ?? pickBoardColor(colors, fallback, mode)[part];
 }
 //#endregion
-//#region ../sdk/src/board/core/scene.ts
+//#region ../sdk/src/board/model/scene.ts
 function orderBoardItems(items) {
 	const children = /* @__PURE__ */ new Map();
 	for (const [id, item] of Object.entries(items)) {
@@ -8575,13 +8575,13 @@ function toSceneItem(id, item, layout) {
 	return scene;
 }
 //#endregion
-//#region ../sdk/src/board/core/text-metrics.ts
+//#region ../sdk/src/board/model/text-metrics.ts
 function boardFontFamily(font, stacks) {
 	if (font === "sans" || font === "serif" || font === "mono") return stacks[font];
 	return `"${font.replaceAll("\"", "")}", ${stacks.sans}`;
 }
 //#endregion
-//#region ../sdk/src/board/task.ts
+//#region ../sdk/src/board/model/task.ts
 function artifactScore(artifact) {
 	const kind = {
 		text: 1,
@@ -8617,7 +8617,7 @@ function taskArtifactPreviewUrl(artifact) {
 	if (artifact?.type === "video" || artifact?.type === "audio") return artifact.previewUrl;
 }
 //#endregion
-//#region ../sdk/src/board/image-key.ts
+//#region ../sdk/src/board/model/image-key.ts
 function imageAssetKey(item) {
 	if (item.type === "image") return `file:${item.props.src}`;
 	if (item.type === "file") {
@@ -28481,7 +28481,7 @@ function sync(container, item, context) {
 }
 //#endregion
 //#region ../sdk/src/board/render/renderers/board-renderer-registry.ts
-const boardCardRenderers = [
+const builtinCardRenderers = [
 	textCardRenderer,
 	imageCardRenderer,
 	{
@@ -28546,13 +28546,21 @@ const boardCardRenderers = [
 	arrowCardRenderer,
 	frameCardRenderer,
 	effectCardRenderer,
-	sketchCardRenderer,
-	unknownCardRenderer
+	sketchCardRenderer
 ];
-function getBoardCardRenderer(item, context) {
-	ensureBoardTextMeasurement();
-	return boardCardRenderers.find((renderer) => renderer.canRender(item, context)) ?? unknownCardRenderer;
+/**
+* Pick a renderer per item: `renderers` first, then the built-ins. Items no
+* renderer claims draw as a labelled placeholder box.
+*/
+function createBoardCardRendererResolver(renderers = []) {
+	const candidates = [...renderers, ...builtinCardRenderers];
+	return (item, context) => {
+		ensureBoardTextMeasurement();
+		return candidates.find((renderer) => renderer.canRender(item, context)) ?? unknownCardRenderer;
+	};
 }
+/** The built-in renderers alone. */
+const getBoardCardRenderer = createBoardCardRendererResolver();
 //#endregion
 //#region ../sdk/src/board/export/scene.ts
 function buildContext(input) {
@@ -28625,11 +28633,12 @@ function createBoardExportScene(input) {
 	});
 	world.scale.set(input.scale);
 	world.position.set(-input.world.x * input.scale, -input.world.y * input.scale);
+	const resolve = input.renderers ?? getBoardCardRenderer;
 	const groups = /* @__PURE__ */ new Map();
 	for (const item of input.items) {
 		const clip = clippingAncestor(input.scene, item);
 		const host = clip && groups.get(clip) || world;
-		const container = getBoardCardRenderer(item, context).create(item, context);
+		const container = resolve(item, context).create(item, context);
 		container.alpha = input.scene.opacity(item.id);
 		host.addChild(container);
 		if (isClippingFrame(item)) {
@@ -28686,6 +28695,7 @@ function renderBoardExport(renderer, input, options = {}) {
 		textures: options.textures,
 		sketches: options.sketches,
 		assetKey: options.assetKey,
+		renderers: options.renderers,
 		background: resolveBackground(options.background, palette, document, colorScheme),
 		backgroundImage: options.backgroundImage
 	});
@@ -28721,7 +28731,7 @@ function renderBoardExport(renderer, input, options = {}) {
 	}
 }
 //#endregion
-//#region ../sdk/src/board/headless/sketch.ts
+//#region ../sdk/src/board/export/node/sketch.ts
 const MAX_EDGE = 2048;
 const DEFAULT_TIMEOUT_MS = 2e3;
 const DEFAULT_READ_TIMEOUT_MS = 15e3;
@@ -28755,7 +28765,7 @@ function runModule(code, src, timeoutMs) {
 		...module.exports
 	} : module.exports;
 	if (typeof value.draw !== "function") throw new Error(`${src} does not export draw(ctx, frame)`);
-	if (value.draw.constructor?.name === "AsyncFunction") throw new Error(`${src} must export a synchronous draw(ctx, frame) for headless export.`);
+	if (value.draw.constructor?.name === "AsyncFunction") throw new Error(`${src} must export a synchronous draw(ctx, frame) for Node export.`);
 	return {
 		module: value,
 		context
@@ -28780,7 +28790,7 @@ function textureFromCanvas(canvas) {
 		height: canvas.height
 	}) });
 }
-function createBoardHeadlessSketchHost(headless, options) {
+function createNodeBoardSketchHost(renderer, options) {
 	const textures = /* @__PURE__ */ new Map();
 	const errors = /* @__PURE__ */ new Map();
 	const lastErrors = /* @__PURE__ */ new Map();
@@ -28803,7 +28813,7 @@ function createBoardHeadlessSketchHost(headless, options) {
 			const runtime = await loadModule(item.props.src);
 			const width = Math.max(1, Math.round(item.frame.width * scale));
 			const height = Math.max(1, Math.round(item.frame.height * scale));
-			const canvas = headless.canvasModule.createCanvas(width, height);
+			const canvas = renderer.canvasModule.createCanvas(width, height);
 			const context = canvas.getContext("2d");
 			context.scale(scale, scale);
 			const frame = {
@@ -28818,7 +28828,7 @@ function createBoardHeadlessSketchHost(headless, options) {
 			runtime.context.__boardFrame = frame;
 			try {
 				const drawResult = new Script("__boardDraw(__boardDrawContext, __boardFrame)", { filename: item.props.src }).runInContext(runtime.context, { timeout: timeoutMs });
-				if (drawResult && typeof drawResult.then === "function") throw new Error(`${item.props.src} must export a synchronous draw(ctx, frame) for headless export.`);
+				if (drawResult && typeof drawResult.then === "function") throw new Error(`${item.props.src} must export a synchronous draw(ctx, frame) for Node export.`);
 			} finally {
 				delete runtime.context.__boardDraw;
 				delete runtime.context.__boardDrawContext;
@@ -28864,7 +28874,7 @@ function createBoardHeadlessSketchHost(headless, options) {
 	};
 }
 //#endregion
-//#region ../sdk/src/board/headless/index.ts
+//#region ../sdk/src/board/export/node/index.ts
 const SYSTEM_UI_FAMILIES = [
 	"Noto Sans",
 	"DejaVu Sans",
@@ -28922,7 +28932,7 @@ function installAnimationFrameShim() {
 		globals.cancelAnimationFrame = void 0;
 	};
 }
-async function createBoardHeadlessRenderer(options = {}) {
+async function createNodeBoardRenderer(options = {}) {
 	const canvasModule = options.canvasModule ?? await loadCanvasModule();
 	extensions.add(CanvasGraphicsPipe, GraphicsPipe, CanvasGraphicsContextSystem, GraphicsContextSystem, CanvasRendererTextSystem, CanvasTextSystem, CanvasTextPipe);
 	for (const font of options.fonts ?? []) canvasModule.GlobalFonts.registerFromPath(font.path, font.family ?? "Geist");
@@ -28939,14 +28949,14 @@ async function createBoardHeadlessRenderer(options = {}) {
 		getCanvasRenderingContext2D: () => createCanvas(1, 1).getContext("2d").constructor,
 		getWebGLRenderingContext: () => WEBGL_PROBE_STUB,
 		getNavigator: () => ({
-			userAgent: "cohub-board-headless",
+			userAgent: "cohub-board-node",
 			gpu: null
 		}),
 		getBaseUrl: () => "file://",
 		getFontFaceSet: () => null,
 		fetch: (url, init) => fetch(url, init),
 		parseXML: () => {
-			throw new Error("XML parsing is not available in headless board export.");
+			throw new Error("XML parsing is not available in Node board export.");
 		}
 	});
 	installBoardTextMeasurement();
@@ -28988,9 +28998,9 @@ const MIME = {
 	jpeg: "image/jpeg",
 	webp: "image/webp"
 };
-function exportBoardImageBytes(headless, document, options = {}) {
+function exportBoardImageBytes(renderer, document, options = {}) {
 	const { format = "png", quality = .92, textures, sketches, backgroundImage, ...rest } = options;
-	const result = renderBoardExport(headless.renderer, document, {
+	const result = renderBoardExport(renderer.renderer, document, {
 		...rest,
 		...sketches ? { sketches } : {},
 		...textures ? { textures } : {},
@@ -29010,4 +29020,4 @@ function exportBoardImageBytes(headless, document, options = {}) {
 	};
 }
 //#endregion
-export { boardDocumentAt, boardImageKeySource, buildBoardScene, createBoardHeadlessRenderer, createBoardHeadlessSketchHost, exportBoardImageBytes, imageAssetKey, parseBoardDocument, planBoardExport, selectBoardExportAssets };
+export { boardDocumentAt, boardImageKeySource, buildBoardScene, createNodeBoardRenderer, createNodeBoardSketchHost, exportBoardImageBytes, imageAssetKey, parseBoardDocument, planBoardExport, selectBoardExportAssets };

package/dist/commands/me.js

@@ -1,5 +1,6 @@
 import { createClient } from "../client.js";
 import { formatLocalDateTime, handleHttp, json as outJson, jsonRequested, table } from "../output.js";
+import { SESSION_STATUS_COLUMN } from "../session-status.js";
 function parseInteger(value, name, min) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isSafeInteger(parsed) || parsed < min) {
@@ -34,6 +35,7 @@ export function registerMe(program) {
                 { key: "id", label: "ID" },
                 { key: "spaceId", label: "Space" },
                 { key: "title", label: "Title" },
+                SESSION_STATUS_COLUMN,
                 { key: "totalMessages", label: "Messages" },
                 { key: "createdAt", label: "Created" },
             ]);

package/dist/commands/spaces.js

@@ -4,6 +4,7 @@ import { readSentTurns, readSessionTurnOrigin, resolveCohubEnvironment } from "@
 import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, ok, error, handleHttp, formatEpochMs, truncateText } from "../output.js";
+import { SESSION_STATUS_COLUMN } from "../session-status.js";
 import { resolveSpace } from "../space.js";
 import { uploadLocalFiles } from "../space-files/upload.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
@@ -1329,6 +1330,7 @@ function registerSessions(spacesCmd) {
             table(result.sessions, [
                 { key: "id", label: "ID" },
                 { key: "title", label: "Title" },
+                SESSION_STATUS_COLUMN,
                 { key: "totalMessages", label: "Messages" },
                 { key: "createdAt", label: "Created" },
             ]);
@@ -1376,6 +1378,7 @@ function registerSessions(spacesCmd) {
             table([result.session], [
                 { key: "id", label: "ID" },
                 { key: "title", label: "Title" },
+                SESSION_STATUS_COLUMN,
                 { key: "totalMessages", label: "Messages" },
                 { key: "totalToolCalls", label: "Tool Calls" },
                 { key: "createdAt", label: "Created" },

package/dist/runtime/harness.js

@@ -2,7 +2,7 @@ import { access, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { delimiter, join, resolve, win32 } from "node:path";
 import { JsonRpcProcess, record } from "./json-rpc.js";
-import { codexModelCatalog } from "./model-catalog.js";
+import { codexModelCatalog, piModelCatalog } from "./model-catalog.js";
 import { downloadPublicImage } from "../safe-remote-image.js";
 export function harnessExecutableCandidates(binary, cwd, path, platform = process.platform, pathExt = process.env.PATHEXT) {
     const windows = platform === "win32";
@@ -68,11 +68,8 @@ export async function discoverHarnesses(harnesses, options, cwd) {
         try {
             if (harness === "pi") {
                 const result = await rpc.request("get_available_models");
-                for (const value of array(result.models)) {
-                    const model = record(value);
-                    if (model.id && model.provider)
-                        models.push({ harness, id: text(model.id), provider: text(model.provider), name: text(model.name) || text(model.id) });
-                }
+                const state = await rpc.request("get_state");
+                models.push(...piModelCatalog(array(result.models), state));
             }
             else {
                 await initializeCodex(rpc);

package/dist/runtime/model-catalog.d.ts

@@ -1,6 +1,14 @@
 import type { RuntimeCapabilities } from "@neta-art/cohub";
 import { type JsonRecord } from "./json-rpc.js";
 type Model = RuntimeCapabilities["models"][number];
+/**
+ * Publish only picker metadata, never provider credentials or request configuration.
+ * `state` is a fresh Pi's `get_state`: its model is what Pi runs when Cohub requests
+ * nothing, and its level is resolved and clamped for that model only. Pi's levels for
+ * other models live in its settings, which RPC does not expose; those models fall back
+ * to the picker's rule, and Cohub always sends the chosen level explicitly.
+ */
+export declare function piModelCatalog(entries: unknown[], state: JsonRecord): Model[];
 /** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
 export declare function codexModelCatalog(configResponse: JsonRecord, entries: unknown[]): Model[];
 export {};

package/dist/runtime/model-catalog.js

@@ -1,4 +1,50 @@
 import { record } from "./json-rpc.js";
+const thinkingLevels = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const thinkingLevel = (value) => thinkingLevels.includes(value) ? value : undefined;
+/**
+ * Publish only picker metadata, never provider credentials or request configuration.
+ * `state` is a fresh Pi's `get_state`: its model is what Pi runs when Cohub requests
+ * nothing, and its level is resolved and clamped for that model only. Pi's levels for
+ * other models live in its settings, which RPC does not expose; those models fall back
+ * to the picker's rule, and Cohub always sends the chosen level explicitly.
+ */
+export function piModelCatalog(entries, state) {
+    const current = record(state.model);
+    const currentLevel = thinkingLevel(state.thinkingLevel);
+    return entries.flatMap((value) => {
+        const model = record(value);
+        if (typeof model.id !== "string" || !model.id || typeof model.provider !== "string" || !model.provider)
+            return [];
+        const map = record(model.thinkingLevelMap);
+        const thinkingLevelMap = Object.fromEntries(thinkingLevels.flatMap((level) => map[level] === null || typeof map[level] === "string" ? [[level, map[level]]] : []));
+        const isDefault = current.provider === model.provider && current.id === model.id;
+        return [{
+                harness: "pi", id: model.id, provider: model.provider, name: typeof model.name === "string" ? model.name : model.id,
+                ...(isDefault ? { isDefault } : {}),
+                ...(typeof model.reasoning === "boolean" ? { reasoning: model.reasoning } : {}),
+                ...(isDefault && currentLevel ? { defaultThinkingLevel: currentLevel } : {}),
+                ...(Object.keys(thinkingLevelMap).length ? { thinkingLevelMap } : {}),
+            }];
+    });
+}
+function codexThinking(model, configuredEffort) {
+    if (!Array.isArray(model.supportedReasoningEfforts))
+        return {};
+    const efforts = new Set(model.supportedReasoningEfforts.map((entry) => record(entry).reasoningEffort));
+    const thinkingLevelMap = Object.fromEntries(thinkingLevels.map((level) => {
+        const effort = level === "off" ? "none" : level;
+        return [level, efforts.has(effort) ? effort : null];
+    }));
+    const normalize = (value) => thinkingLevel(value === "none" ? "off" : value);
+    const configured = normalize(configuredEffort);
+    const fallback = normalize(model.defaultReasoningEffort);
+    const defaultThinkingLevel = [configured, fallback].find((level) => level && thinkingLevelMap[level] != null);
+    return {
+        reasoning: thinkingLevels.some((level) => level !== "off" && thinkingLevelMap[level] != null),
+        thinkingLevelMap,
+        ...(defaultThinkingLevel ? { defaultThinkingLevel } : {}),
+    };
+}
 /** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
 export function codexModelCatalog(configResponse, entries) {
     const config = record(configResponse.config);
@@ -11,9 +57,11 @@ export function codexModelCatalog(configResponse, entries) {
         const id = typeof model.model === "string" ? model.model : typeof model.id === "string" ? model.id : null;
         if (!id || model.hidden)
             return [];
-        return [{ harness: "codex", provider, id, name: typeof model.displayName === "string" ? model.displayName : id }];
+        // A configured model replaces the catalog's own default.
+        const isDefault = configuredModel ? id === configuredModel : model.isDefault === true;
+        return [{ harness: "codex", provider, id, name: typeof model.displayName === "string" ? model.displayName : id, ...(isDefault ? { isDefault } : {}), ...codexThinking(model, config.model_reasoning_effort) }];
     });
     if (configuredModel && !models.some((model) => model.id === configuredModel))
-        models.unshift({ harness: "codex", provider, id: configuredModel, name: configuredModel });
+        models.unshift({ harness: "codex", provider, id: configuredModel, name: configuredModel, isDefault: true });
     return models;
 }

package/dist/runtime/native/execution.js

@@ -294,7 +294,7 @@ async function runCodex(executor, turn, context) {
                     escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
             };
             signal.addEventListener("abort", abort, { once: true });
-            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel } : {}) })
+            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel === "off" ? "none" : input.thinkingLevel } : {}) })
                 .then((result) => { nativeTurnId ??= text(record(result.turn).id) || null; if (signal.aborted)
                 interrupt(); })
                 .catch(finish);

package/dist/session-status.d.ts

@@ -0,0 +1,6 @@
+import type { SessionRecord } from "@neta-art/cohub";
+import type { Column } from "./output.js";
+type SessionStatusFields = Pick<SessionRecord, "activeTurn" | "lastTurnIssue">;
+export declare function sessionStatusText(session: Partial<SessionStatusFields>): string;
+export declare const SESSION_STATUS_COLUMN: Column;
+export {};

package/dist/session-status.js

@@ -0,0 +1,14 @@
+export function sessionStatusText(session) {
+    const turn = session.activeTurn;
+    if (turn)
+        return turn.status === "abort_requested" ? "stopping" : turn.status;
+    const issue = session.lastTurnIssue;
+    if (issue?.status === "failed")
+        return "failed";
+    return issue?.reason === "stale_active_recovered" ? "interrupted" : "";
+}
+export const SESSION_STATUS_COLUMN = {
+    key: "activeTurn",
+    label: "Status",
+    format: (_value, row) => sessionStatusText(row),
+};

package/package.json

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