pi-cockpit 0.21.0 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cockpit",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "Responsive Maestro operations sidebar, fallback status widgets, and footer for Pi.",
   "type": "module",
   "keywords": [
@@ -43,7 +43,7 @@
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
-    "pi-maestro-teammate": "^2.4.0",
+    "pi-maestro-teammate": "^2.5.0",
     "typebox": "*"
   },
   "peerDependenciesMeta": {
@@ -72,7 +72,7 @@
     "@earendil-works/pi-coding-agent": "0.84.4",
     "@earendil-works/pi-tui": "0.84.4",
     "@types/node": "^22.0.0",
-    "pi-maestro-teammate": "2.4.0",
+    "pi-maestro-teammate": "2.5.0",
     "typebox": "1.3.7",
     "typescript": "^5.5.0"
   },

package/src/agent-bar.ts

@@ -241,7 +241,9 @@ export function renderSessionBarLine(
 	theme: Theme,
 	shortcutHint?: SessionBarHintValue,
 ): string {
-	const w = Math.max(1, width);
+	// A live main-screen row must not write the terminal's final column: doing so
+	// arms auto-wrap, while pi-tui still tracks the cursor on the original row.
+	const w = Math.max(1, width - 1);
 	if (!shortcutHint) return renderContent(w);
 	const hintSpec = typeof shortcutHint === "string" ? { text: shortcutHint, color: "dim" as const } : shortcutHint;
 	const hint = theme.fg(hintSpec.color ?? "dim", hintSpec.text);
@@ -262,7 +264,7 @@ export function renderAgentBar(
 	theme: Theme,
 	options: AgentBarRenderOptions = {},
 ): string[] {
-	if (endpoints.length === 0) return [truncateToWidth(chip(MAIN_SESSION_LABEL, true, "accent", theme), Math.max(1, width), "…")];
+	if (endpoints.length === 0) return [truncateToWidth(chip(MAIN_SESSION_LABEL, true, "accent", theme), Math.max(1, width - 1), "…")];
 	const now = options.now ?? 0;
 	// A stale selection (id no longer in the endpoint list) must not leave the
 	// bar without a highlighted chip: fall back to root / first endpoint.

package/src/agents-store.ts

@@ -11,19 +11,227 @@ import type {
 } from "pi-maestro-teammate/v1/types";
 import type {
 	RuntimeAgentReadEntityV2,
+	RuntimeReadModelChangeV2,
 	RuntimeReadModelDeltaV2,
 	RuntimeReadModelOwnershipV2,
 	RuntimeReadModelSnapshotV2,
-} from "pi-maestro-teammate/v2/runtime";
-import {
-	RuntimeReadModelProjectionV2,
-	parseRuntimeReadModelDeltaV2,
-	parseRuntimeReadModelOwnershipV2,
-	parseRuntimeReadModelSnapshotV2,
+	RuntimeReadModelSourceV2,
 } from "pi-maestro-teammate/v2/runtime";
 import { sanitizeExtensionStatusText } from "./extension-status.ts";
 import { EXPERT_LEADER_NAME, type AgentRow, type AgentStatus } from "./types.ts";
 
+export const RUNTIME_READ_MODEL_DELTA_EVENT = "teammate:runtime-read-model-delta-v2";
+export const RUNTIME_READ_MODEL_QUERY_EVENT = "teammate:runtime-read-model-query-v2";
+export const RUNTIME_READ_MODEL_SNAPSHOT_EVENT = "teammate:runtime-read-model-snapshot-v2";
+export const RUNTIME_READ_MODEL_UNAVAILABLE_EVENT = "teammate:runtime-read-model-unavailable-v2";
+
+/** Keep Cockpit loadable when its optional Teammate peer is absent. */
+export function runtimeV2ReadEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+	return env.PI_RUNTIME_BROKER?.trim().toLowerCase() === "sqlite"
+		&& (env.PI_RUNTIME_V2_READ === undefined || env.PI_RUNTIME_V2_READ === "1");
+}
+
+function plainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function safeInteger(value: unknown, minimum = 0): value is number {
+	return Number.isSafeInteger(value) && (value as number) >= minimum;
+}
+
+function identifier(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0 && value.length <= 1024 && !value.includes("\0");
+}
+
+function parseRuntimeReadModelOwnershipV2(value: unknown): RuntimeReadModelOwnershipV2 | undefined {
+	if (!plainObject(value)
+		|| !identifier(value.workspaceId)
+		|| !identifier(value.sessionId)
+		|| !identifier(value.sourceId)
+		|| !safeInteger(value.generation, 1)) return undefined;
+	return {
+		workspaceId: value.workspaceId,
+		sessionId: value.sessionId,
+		sourceId: value.sourceId,
+		generation: value.generation,
+	};
+}
+
+function parseSource(value: unknown): RuntimeReadModelSourceV2 | undefined {
+	if (!plainObject(value)
+		|| !identifier(value.streamId)
+		|| !safeInteger(value.revision, 1)
+		|| !safeInteger(value.generation, 1)) return undefined;
+	const projection = value.projection === undefined
+		? undefined
+		: parseRuntimeReadModelOwnershipV2(value.projection);
+	if (value.projection !== undefined && !projection) return undefined;
+	return {
+		streamId: value.streamId,
+		revision: value.revision,
+		generation: value.generation,
+		...(projection ? { projection } : {}),
+	};
+}
+
+const AGENT_STATUSES = new Set<RuntimeAgentReadEntityV2["status"]>([
+	"pending", "running", "retrying", "sleeping", "completed", "failed", "terminated",
+]);
+
+function parseRuntimeEntity(value: unknown): RuntimeAgentReadEntityV2 | undefined {
+	if (!plainObject(value)
+		|| !identifier(value.correlationId)
+		|| !safeInteger(value.generation, 1)
+		|| !identifier(value.agent)
+		|| !AGENT_STATUSES.has(value.status as RuntimeAgentReadEntityV2["status"])
+		|| !safeInteger(value.startedAt)
+		|| !safeInteger(value.lastActivityAt)) return undefined;
+	for (const key of ["name", "task", "spawnedBy", "parentCorrelationId", "phase", "requestedModel", "resolvedModel", "lastMessage", "error"] as const) {
+		if (value[key] !== undefined && typeof value[key] !== "string") return undefined;
+	}
+	if (value.dependencies !== undefined
+		&& (!Array.isArray(value.dependencies) || value.dependencies.some((item) => !safeInteger(item)))) return undefined;
+	if (value.attemptedModels !== undefined
+		&& (!Array.isArray(value.attemptedModels) || value.attemptedModels.some((item) => typeof item !== "string"))) return undefined;
+	if (value.projection !== undefined && !parseRuntimeReadModelOwnershipV2(value.projection)) return undefined;
+	return structuredClone(value) as unknown as RuntimeAgentReadEntityV2;
+}
+
+function parseRuntimeReadModelDeltaV2(value: unknown): RuntimeReadModelDeltaV2 | undefined {
+	if (!plainObject(value)
+		|| value.version !== 2
+		|| value.revision !== 1
+		|| value.kind !== "agent-runs-delta"
+		|| !safeInteger(value.baseCursor)
+		|| !safeInteger(value.nextCursor, 1)
+		|| value.nextCursor <= value.baseCursor
+		|| !Array.isArray(value.changes)) return undefined;
+	const source = parseSource(value.source);
+	if (!source) return undefined;
+	const changes: RuntimeReadModelChangeV2[] = [];
+	for (const change of value.changes) {
+		if (!plainObject(change)) return undefined;
+		if (change.kind === "upsert") {
+			const entity = parseRuntimeEntity(change.entity);
+			if (!entity) return undefined;
+			changes.push({ kind: "upsert", entity });
+			continue;
+		}
+		if (change.kind === "tombstone"
+			&& identifier(change.correlationId)
+			&& safeInteger(change.generation, 1)) {
+			changes.push({ kind: "tombstone", correlationId: change.correlationId, generation: change.generation });
+			continue;
+		}
+		return undefined;
+	}
+	return {
+		version: 2,
+		revision: 1,
+		kind: "agent-runs-delta",
+		baseCursor: value.baseCursor,
+		nextCursor: value.nextCursor,
+		source,
+		changes,
+	};
+}
+
+function parseRuntimeReadModelSnapshotV2(value: unknown): RuntimeReadModelSnapshotV2 | undefined {
+	if (!plainObject(value)
+		|| value.version !== 2
+		|| value.revision !== 1
+		|| value.kind !== "agent-runs-snapshot"
+		|| !safeInteger(value.cursor)
+		|| !Array.isArray(value.agents)) return undefined;
+	const source = parseSource(value.source);
+	if (!source) return undefined;
+	const agents = value.agents.map(parseRuntimeEntity);
+	if (agents.some((agent) => agent === undefined)) return undefined;
+	return {
+		version: 2,
+		revision: 1,
+		kind: "agent-runs-snapshot",
+		cursor: value.cursor,
+		source,
+		agents: agents as RuntimeAgentReadEntityV2[],
+	};
+}
+
+function cloneRuntimeEntity(entity: RuntimeAgentReadEntityV2): RuntimeAgentReadEntityV2 {
+	return structuredClone(entity);
+}
+
+class RuntimeReadModelProjectionV2 {
+	readonly #agents = new Map<string, RuntimeAgentReadEntityV2>();
+	#cursor = 0;
+	#source: RuntimeReadModelSourceV2 = { streamId: "uninitialized", revision: 1, generation: 1 };
+	#initialized = false;
+
+	get cursor(): number { return this.#cursor; }
+
+	applySnapshot(input: unknown): boolean {
+		const snapshot = parseRuntimeReadModelSnapshotV2(input);
+		if (!snapshot) return false;
+		if (this.#initialized && snapshot.source.streamId === this.#source.streamId) {
+			if (snapshot.source.generation < this.#source.generation) return false;
+			if (snapshot.source.generation === this.#source.generation && snapshot.cursor < this.#cursor) return false;
+		}
+		const next = new Map<string, RuntimeAgentReadEntityV2>();
+		for (const agent of snapshot.agents) {
+			const existing = next.get(agent.correlationId);
+			if (existing && existing.generation > agent.generation) continue;
+			next.set(agent.correlationId, cloneRuntimeEntity(agent));
+		}
+		this.#agents.clear();
+		for (const [id, agent] of next) this.#agents.set(id, agent);
+		this.#cursor = snapshot.cursor;
+		this.#source = { ...snapshot.source };
+		this.#initialized = true;
+		return true;
+	}
+
+	applyDelta(input: unknown): boolean {
+		const delta = parseRuntimeReadModelDeltaV2(input);
+		if (!delta
+			|| delta.baseCursor !== this.#cursor
+			|| delta.nextCursor <= this.#cursor
+			|| delta.source.streamId !== this.#source.streamId
+			|| delta.source.generation !== this.#source.generation
+			|| JSON.stringify(delta.source.projection) !== JSON.stringify(this.#source.projection)
+			|| delta.source.revision !== delta.nextCursor) return false;
+		const next = new Map([...this.#agents].map(([id, agent]) => [id, cloneRuntimeEntity(agent)]));
+		for (const change of delta.changes) {
+			if (change.kind === "upsert") {
+				const current = next.get(change.entity.correlationId);
+				if (current && change.entity.generation < current.generation) return false;
+				next.set(change.entity.correlationId, cloneRuntimeEntity(change.entity));
+				continue;
+			}
+			const current = next.get(change.correlationId);
+			if (current && change.generation < current.generation) return false;
+			if (!current || change.generation === current.generation) next.delete(change.correlationId);
+		}
+		this.#agents.clear();
+		for (const [id, agent] of next) this.#agents.set(id, agent);
+		this.#cursor = delta.nextCursor;
+		this.#source = { ...delta.source };
+		return true;
+	}
+
+	snapshot(): RuntimeReadModelSnapshotV2 {
+		return {
+			version: 2,
+			revision: 1,
+			kind: "agent-runs-snapshot",
+			cursor: this.#cursor,
+			source: { ...this.#source },
+			agents: [...this.#agents.values()]
+				.sort((left, right) => left.correlationId.localeCompare(right.correlationId))
+				.map(cloneRuntimeEntity),
+		};
+	}
+}
+
 const STATUS_TEXT_MAX = 48;
 /** Selected-session output kept for the expandable fixed detail region. */
 export const SESSION_CONTENT_MAX = 2_048;

package/src/index.ts

@@ -4,7 +4,18 @@ import { getAgentDir, type ExtensionAPI, type ExtensionCommandContext, type Exte
 import type { TUI } from "@earendil-works/pi-tui";
 import { ambientKeysShouldYield, capturingOverlayVisible } from "./capturing-overlay.ts";
 import { Key, decodeKittyPrintable, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { AgentReadStoreRouter, effectiveAgentStatus, type CompletePayload, type MessagePayload, type StartedPayload } from "./agents-store.ts";
+import {
+	AgentReadStoreRouter,
+	RUNTIME_READ_MODEL_DELTA_EVENT,
+	RUNTIME_READ_MODEL_QUERY_EVENT,
+	RUNTIME_READ_MODEL_SNAPSHOT_EVENT,
+	RUNTIME_READ_MODEL_UNAVAILABLE_EVENT,
+	effectiveAgentStatus,
+	runtimeV2ReadEnabled,
+	type CompletePayload,
+	type MessagePayload,
+	type StartedPayload,
+} from "./agents-store.ts";
 import { AmbientSurfaceCache, nextUiPromptDepth, shouldHideWorkingDuration, statusText, titleFor, workingMessage, type AmbientState } from "./ambient.ts";
 import { generateTitleWithModel } from "./title-llm.ts";
 import { suggestTitle } from "./title-gen.ts";
@@ -120,13 +131,6 @@ import {
 	type CockpitConfig,
 } from "./types.ts";
 import type { MailboxHostRegistry } from "pi-maestro-teammate/v1/mailbox";
-import {
-	RUNTIME_READ_MODEL_DELTA_EVENT,
-	RUNTIME_READ_MODEL_QUERY_EVENT,
-	RUNTIME_READ_MODEL_SNAPSHOT_EVENT,
-	RUNTIME_READ_MODEL_UNAVAILABLE_EVENT,
-	runtimeV2ReadEnabled,
-} from "pi-maestro-teammate/v2/runtime";
 
 export {
 	EndpointStore,

package/src/settings/settings-shell.ts

@@ -1283,7 +1283,15 @@ export class MaestroSettingsShell implements Component, Focusable {
 		const change = this.params.coordinator.changes(providerId).find((entry) => entry.key === definition.key && entry.scope === scope);
 		if (change?.operation === "unset") return this.t("settings.inherited");
 		if (change?.operation === "set") return this.formatValue(definition, change.value);
-		return this.displayConfigured(definition, this.configuredValue(this.params.coordinator.baseline(providerId), definition.key, scope));
+		const baseline = this.params.coordinator.baseline(providerId);
+		const configured = this.configuredValue(baseline, definition.key, scope);
+		if (!configured || configured.state === "absent") {
+			const effective = baseline?.effective.values.find((value) => value.key === definition.key);
+			if (effective) {
+				return `${this.t("settings.state.absent")} · ${this.t("settings.effective")} ${this.formatValue(definition, effective.value)}`;
+			}
+		}
+		return this.displayConfigured(definition, configured);
 	}
 
 	private configuredValue(snapshot: SettingsSnapshot | undefined, key: string, scope: SettingsScope) {

package/src/stack-widget.ts

@@ -96,6 +96,9 @@ export function makeAgentWidget(deps: AgentWidgetDeps) {
 		return {
 			render(width: number): string[] {
 				const cfg = deps.getConfig();
+				// Agent rows update while teammate runs. Leave the final terminal column
+				// untouched so auto-wrap cannot move the real cursor below pi-tui's model.
+				const liveWidth = Math.max(1, width - 1);
 				// graph(...) is the dispatch container, not an additional worker. Keep it
 				// in AgentsStore for linkage and cleanup, and bridge its visible descendants
 				// to the nearest non-graph ancestor for rendering.
@@ -137,7 +140,7 @@ export function makeAgentWidget(deps: AgentWidgetDeps) {
 				if (runCount) headerSegs.push({ text: theme.fg("dim", tuiT("common.running", { count: runCount })), priority: 80, clippable: false });
 				if (pendingCount) headerSegs.push({ text: theme.fg("dim", tuiT("common.pending", { count: pendingCount })), priority: 60, clippable: false });
 				if (sleepingCount) headerSegs.push({ text: theme.fg("dim", tuiT("common.sleeping", { count: sleepingCount })), priority: 50, clippable: false });
-				const headerLine = fitLineByPriority(headerSegs, width, UTILS, theme.fg("dim", g.separator), g.ellipsis);
+				const headerLine = fitLineByPriority(headerSegs, liveWidth, UTILS, theme.fg("dim", g.separator), g.ellipsis);
 				// Focused-session priority: while a selected session's detail block is
 				// open, it owns the Agent height allowance and the roster collapses to
 				// this one-line summary. The per-agent rows stay reachable through the
@@ -183,12 +186,12 @@ export function makeAgentWidget(deps: AgentWidgetDeps) {
 							above > 0 ? `↑ ${tuiT("common.more", { count: above })}` : "",
 							below > 0 ? `↓ ${tuiT("common.more", { count: below })}` : "",
 						].filter(Boolean).join(` ${g.separator} `)),
-						width,
+						liveWidth,
 						g.ellipsis,
 					)
 					: undefined;
 				if (marker && above > 0) lines.push(marker);
-				lines.push(...renderAgents(visible, cfg.agentsMode, width, paint, UTILS, { ...opts, withHead: false, maxRows: windowRows + 1 }));
+				lines.push(...renderAgents(visible, cfg.agentsMode, liveWidth, paint, UTILS, { ...opts, withHead: false, maxRows: windowRows + 1 }));
 				if (marker && above === 0) lines.push(marker);
 				return lines;
 			},

package/src/window-bar.ts

@@ -59,7 +59,7 @@ export function renderWindowBar(
 		endpoint,
 	}));
 	if (tabs.length === 0) {
-		return [truncateToWidth(theme.fg("muted", tuiT("window.empty")), Math.max(1, width), "…")];
+		return [truncateToWidth(theme.fg("muted", tuiT("window.empty")), Math.max(1, width - 1), "…")];
 	}
 	return [renderSessionBarLine(
 		(availableWidth) => renderSessionTabLine(tabs, availableWidth, {