@iowarp/clio-coder 0.3.8 → 0.4.0

package/src/interactive/view/view-overlay.ts

@@ -7,6 +7,7 @@ import {
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
+	wrapTextWithAnsi,
 } from "../../engine/tui.js";
 import { clockLocal } from "../format-time.js";
 import { buildHint, showClioOverlayFrame } from "../overlay-frame.js";
@@ -359,6 +360,30 @@ export function buildArtifactHeader(
 	return padAnsi(parts.join("  "), width, ELLIPSIS);
 }
 
+/** Put verification on wrapped rows so a canonical receipt verdict is never reduced to a prefix. */
+export function buildArtifactHeaderLines(
+	artifact: ViewArtifact | undefined,
+	verification: ViewVerificationState | undefined,
+	width: number,
+): string[] {
+	const metadata = buildArtifactHeader(artifact, undefined, width);
+	const verify = verificationText(verification);
+	if (artifact === undefined || verify.length === 0) return [metadata];
+	const theme = clioTheme();
+	const token =
+		verification?.status === "ok"
+			? "success"
+			: verification?.status === "fail"
+				? "error"
+				: verification?.status === "retired"
+					? "warning"
+					: "info";
+	return [
+		metadata,
+		...wrapTextWithAnsi(theme.fg(token, verify), Math.max(1, width)).map((line) => padAnsi(line, width, ELLIPSIS)),
+	];
+}
+
 export function viewFooterHint(focus: ViewPaneFocus, canVerify: boolean, innerWidth?: number): string {
 	// One pane at a time means Tab is how the other one is reached, so the
 	// narrow footer states it. The generic elider drops middle entries, and Tab
@@ -569,8 +594,8 @@ export class ViewOverlayView implements Component {
 		this.ensureContentLoaded(artifact);
 		this.lastContentWidth = width;
 		const verification = artifact ? this.verifications.get(artifactKey(artifact)) : undefined;
-		const header = buildArtifactHeader(artifact, verification, width);
-		const bodyHeight = Math.max(0, height - 1);
+		const header = buildArtifactHeaderLines(artifact, verification, width);
+		const bodyHeight = Math.max(0, height - header.length);
 		this.lastContentBodyHeight = Math.max(1, bodyHeight);
 		const body = this.renderedContentLines(width);
 		const maxOffset = Math.max(0, body.length - Math.max(1, bodyHeight));
@@ -578,7 +603,7 @@ export class ViewOverlayView implements Component {
 		const visible = body
 			.slice(this.contentScrollOffset, this.contentScrollOffset + bodyHeight)
 			.map((line) => padAnsi(line, width, ELLIPSIS));
-		const lines = [header, ...visible];
+		const lines = [...header, ...visible];
 		return this.fixedLines(lines, width, height);
 	}
 
@@ -739,6 +764,7 @@ export function openViewOverlay(
 		width: VIEW_OVERLAY_WIDTH,
 		maxHeight: VIEW_OVERLAY_MAX_HEIGHT,
 		margin: VIEW_OVERLAY_MARGIN,
+		markerId: "view",
 		title: "View",
 		footerHint: (innerWidth) => view.getHint(innerWidth),
 	});

package/src/interactive/watch-pane.ts

@@ -0,0 +1,152 @@
+/**
+ * The workers-view watch pane: one pane, beside Clio's own, rendering whatever
+ * run the operator points at.
+ *
+ * The pane hosts `clio-coder fleet view --watch <selection-file>` (see
+ * src/cli/fleet-view.ts), a durable-state viewer that re-reads the selection
+ * file on every poll. Retargeting is therefore one small atomic file write:
+ * arrow keys in the Alt+W board follow the cursor with zero socket traffic and
+ * zero pane churn, which is what makes the navigation feel like part of the
+ * board rather than like driving a terminal multiplexer.
+ *
+ * Pane creation is deliberately lazy, but reclamation is eager. A surviving
+ * pane is adopted as soon as the controller starts so the relaunched session's
+ * inventory owns it before the next watch command. A new pane still opens only
+ * on the first watch (operator Enter, `/panes show`, or the panes tool), and is
+ * never closed by navigation: leaving the workers view parks it on the last
+ * selection, and it goes away when the operator quits the viewer (`q`), closes
+ * the pane, or runs `/panes close watch`.
+ */
+
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { type ClioDirs, clioCacheDir, clioConfigDir, clioDataDir, clioStateDir } from "../core/xdg.js";
+import type { MuxContract } from "../domains/mux/index.js";
+import type { PanesWatchController, PanesWatchResult } from "../domains/mux/operations.js";
+import { watchViewerCommand } from "../domains/mux/viewer-command.js";
+
+/**
+ * One selection file per state root, deliberately not per session: every
+ * session over a state root shares one run ledger, so a surviving watch pane
+ * from a crashed session keeps working the moment a new session writes the
+ * same file.
+ */
+function watchSelectionPath(stateDir: string = clioStateDir()): string {
+	return join(stateDir, "watch-selection");
+}
+
+export interface WatchPaneDeps {
+	mux: MuxContract;
+	getCwd: () => string;
+	/** Selection-file override for tests. */
+	selectionPath?: string;
+	/** Resolved-layout override for tests. Production pins this process's four cached roots. */
+	dirs?: Readonly<ClioDirs>;
+	/** Command override for tests; production runs this install's own CLI. */
+	command?: (selectionPath: string, dirs: Readonly<ClioDirs>) => ReadonlyArray<string>;
+	writeFile?: (path: string, content: string) => void;
+}
+
+/** Replace-by-rename so the viewer's poll never reads a torn line. */
+function atomicWrite(path: string, content: string): void {
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp`;
+	writeFileSync(tmp, content, "utf8");
+	renameSync(tmp, path);
+}
+
+export function createWatchPaneController(deps: WatchPaneDeps): PanesWatchController {
+	const selectionPath = deps.selectionPath ?? watchSelectionPath();
+	const dirs =
+		deps.dirs ??
+		Object.freeze({
+			config: clioConfigDir(),
+			data: clioDataDir(),
+			state: clioStateDir(),
+			cache: clioCacheDir(),
+		});
+	const command = deps.command ?? ((path, layout) => watchViewerCommand(path, { dirs: layout }));
+	const write = deps.writeFile ?? atomicWrite;
+
+	let paneId: string | null = null;
+	let disposed = false;
+	let adoptionInFlight: Promise<boolean> | null = null;
+	const unsubscribe = deps.mux.onPaneGone((record) => {
+		if (record.ref.paneId === paneId) paneId = null;
+	});
+	const adoptExistingPane = (): Promise<boolean> => {
+		if (disposed || paneId !== null) return Promise.resolve(true);
+		if (adoptionInFlight !== null) return adoptionInFlight;
+		const attempt = Promise.resolve()
+			.then(() => deps.mux.adoptPane({ purpose: "watch", label: "watch" }))
+			.then((adopted) => {
+				if (!disposed && paneId === null && adopted !== null) paneId = adopted.paneId;
+				return true;
+			})
+			.catch(() => {
+				// Startup reclamation is best effort. An explicit watch retries the
+				// scan before it opens a replacement pane.
+				return false;
+			})
+			.finally(() => {
+				if (adoptionInFlight === attempt) adoptionInFlight = null;
+			});
+		adoptionInFlight = attempt;
+		return attempt;
+	};
+
+	const writeSelection = (runId: string): boolean => {
+		try {
+			write(selectionPath, `${runId}\n`);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	// Reclaim durable ownership for inventory and navigation immediately. The
+	// scan remains best effort and never opens a replacement pane on its own.
+	void adoptExistingPane();
+
+	return {
+		async watch(runId: string): Promise<PanesWatchResult> {
+			if (!writeSelection(runId)) {
+				return { status: "unavailable", reason: `cannot write the watch selection at ${selectionPath}` };
+			}
+			if (paneId !== null) return { status: "watching", runId, paneId, opened: false };
+			const scanned = await adoptExistingPane();
+			if (!scanned) await adoptExistingPane();
+			if (paneId !== null) return { status: "watching", runId, paneId, opened: false };
+			const opened = await deps.mux.openUtilityPane({
+				argv: command(selectionPath, dirs),
+				cwd: deps.getCwd(),
+				label: "watch",
+				title: "clio watch",
+				purpose: "watch",
+				direction: "right",
+			});
+			if (opened === null) {
+				return { status: "unavailable", reason: "the pane host refused to open the watch pane" };
+			}
+			paneId = opened.paneId;
+			return { status: "watching", runId, paneId, opened: true };
+		},
+
+		follow(runId: string): boolean {
+			// Navigation never opens anything; a closed watch pane stays closed
+			// until the operator asks again with Enter.
+			if (paneId === null) return false;
+			return writeSelection(runId);
+		},
+
+		isOpen(): boolean {
+			return paneId !== null;
+		},
+
+		dispose(): void {
+			// The pane parks; only the subscription goes.
+			disposed = true;
+			unsubscribe();
+		},
+	};
+}

package/src/interactive/worker-progress.ts

@@ -261,6 +261,8 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 	const toolNames: string[] = [];
 	let settled = false;
 	let durable = "";
+	/** True after one assistant message ended and before the next message emits prose. */
+	let betweenAssistantMessages = false;
 	/** Starts still awaiting a finish, oldest first. */
 	const pendingActions: WorkerAction[] = [];
 	/** New streams resolve exact starts through this index. */
@@ -340,7 +342,9 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 
 			const delta = workerTextDelta(event);
 			if (delta.length > 0) {
-				changed = appendTail(admitDelta(delta, nowMs)) || changed;
+				const separator = betweenAssistantMessages && tailText.length > 0 && !tailText.endsWith("\n") ? "\n\n" : "";
+				betweenAssistantMessages = false;
+				changed = appendTail(admitDelta(`${separator}${delta}`, nowMs)) || changed;
 				changed = setPhase("writing") || changed;
 			} else if (isThinkingEvent(event)) {
 				// The phase moves and nothing else: reasoning content is never kept.
@@ -355,6 +359,7 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 				if (delta.length === 0 && tailText.trim().length === 0) {
 					changed = appendTail(durableText) || changed;
 				}
+				betweenAssistantMessages = true;
 			}
 
 			const action = toolEventAction(event);
@@ -412,6 +417,7 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 			pendingActions.length = 0;
 			pendingActionsById.clear();
 			durable = "";
+			betweenAssistantMessages = false;
 			settled = false;
 			phase = "starting";
 			touch();

package/src/interactive/worker-receipts.ts

@@ -19,7 +19,7 @@ import { clioStateDir } from "../core/xdg.js";
 import type { RunEnvelope, RunReceipt } from "../domains/dispatch/types.js";
 import { inspectRunReceiptTrustStatus } from "../domains/evidence/trust-status.js";
 import { receiptFilePath } from "./view/artifacts.js";
-import type { WorkerReceiptFacts, WorkerResultContract } from "./worker-stream.js";
+import type { WorkerPresentedResultContract, WorkerReceiptFacts, WorkerResultContract } from "./worker-stream.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -55,6 +55,22 @@ function contractFrom(receipt: Record<string, unknown>): WorkerResultContract |
 	return conformance === "pass" || conformance === "fail" || conformance === "not-reached" ? conformance : undefined;
 }
 
+const PRESENTED_RESULT_CONTRACTS: ReadonlyArray<WorkerPresentedResultContract> = [
+	"debugger-report",
+	"verifier-report",
+	"research-report",
+	"scout-report",
+];
+
+/** The kind is integrity-covered inside the validator source id on current receipts. */
+function contractKindFrom(receipt: Record<string, unknown>): WorkerPresentedResultContract | undefined {
+	const quality = isRecord(receipt.quality) ? receipt.quality : null;
+	const fact = quality !== null && isRecord(quality.resultContract) ? quality.resultContract : null;
+	const sourceId = optionalString(fact?.sourceId);
+	if (sourceId === undefined) return undefined;
+	return PRESENTED_RESULT_CONTRACTS.find((kind) => sourceId.startsWith(`agent-result-contract:${kind}:`));
+}
+
 /**
  * Project a parsed receipt onto the facts a worker block renders. The input is
  * whatever JSON the file held, not a typed {@link RunReceipt}: receipts written
@@ -66,6 +82,7 @@ export function workerReceiptFacts(receipt: Record<string, unknown>): WorkerRece
 	if (outcome === undefined) return null;
 	const output = isRecord(receipt.output) ? receipt.output : null;
 	const contract = contractFrom(receipt);
+	const contractKind = contractKindFrom(receipt);
 	const text = optionalString(output?.text);
 	const failureMessage = optionalString(receipt.failureMessage);
 	const outcomeCode = optionalString(receipt.outcomeCode);
@@ -82,6 +99,7 @@ export function workerReceiptFacts(receipt: Record<string, unknown>): WorkerRece
 		...(durationMs !== undefined ? { durationMs } : {}),
 		...(toolCalls !== undefined ? { toolCalls } : {}),
 		...(contract !== undefined ? { contract } : {}),
+		...(contractKind !== undefined ? { contractKind } : {}),
 		...(text !== undefined ? { text } : {}),
 	};
 }

package/src/interactive/worker-stream.ts

@@ -61,6 +61,9 @@ export interface WorkerAttempt {
 
 export type WorkerResultContract = "pass" | "fail" | "not-reached" | "unmeasured";
 
+/** Result kinds whose parsed envelopes have a dedicated transcript presentation. */
+export type WorkerPresentedResultContract = "debugger-report" | "verifier-report" | "research-report" | "scout-report";
+
 /**
  * Terminal facts a worker block reports. Sealed by the receipt when it can be
  * read, carried by the terminal event otherwise. Every unit is optional and
@@ -76,6 +79,8 @@ export interface WorkerReceiptSummary {
 	durationMs?: number;
 	toolCalls?: number;
 	contract?: WorkerResultContract;
+	/** Parsed from the receipt's result-contract source id; absent on legacy and untyped receipts. */
+	contractKind?: WorkerPresentedResultContract;
 	/** From an abort marker rather than a sealed terminal event; a later DispatchCompleted/DispatchFailed replaces it. */
 	provisional?: boolean;
 	/** The run is over, but no receipt could be read for it, and the ledger row could not explain why either. */