pi-crew 0.10.6 → 0.11.1

package/src/runtime/task-display.ts

@@ -47,6 +47,6 @@ export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
 								? "⚠"
 								: "◦";
 		const wait = waitingReason(task, tasks);
-		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
+		return `- ${icon} ${task.id} [${task.status}] ${task.role}▸${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
 	});
 }

package/src/schema/config-schema.ts

@@ -298,6 +298,10 @@ export const PiTeamsUiConfigSchema = Type.Object(
 	{
 		widgetPlacement: Type.Optional(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor"), Type.Literal("bottom")])),
 		widgetMaxLines: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+		/** Inline panel (editor-wrapper agent rows). M1-9/P1-8: parsed + read
+		 *  (src/ui/inline-panel/index.ts) + defaulted (true), but absent from this
+		 *  schema → same unknown-key warning. */
+		inlinePanel: Type.Optional(Type.Boolean()),
 		powerbar: Type.Optional(Type.Boolean()),
 		dashboardPlacement: Type.Optional(Type.Union([Type.Literal("center"), Type.Literal("right")])),
 		dashboardWidth: Type.Optional(Type.Integer({ minimum: 32, maximum: 120 })),

package/src/state/coordination/locks.ts

@@ -307,6 +307,21 @@ function releaseLock(filePath: string, token: string): void {
 	// (probably stale and overtaken). Do not touch it — the new holder owns it.
 }
 
+/**
+ * Error codes that mean "the lock file exists / is momentarily un-creatable
+ * because another process holds it" rather than "something is broken".
+ *
+ * EEXIST is the POSIX O_CREAT|O_EXCL loser signal. On Windows (libuv),
+ * CREATE_NEW against a file that another process has open mid-create can
+ * surface as EPERM (ERROR_ACCESS_DENIED) or EBUSY instead of EEXIST —
+ * observed on the windows-latest CI runner (ST-3 cross-process flock test).
+ * Retrying these is correct: the holder always closes/releases within the
+ * stale-deadline budget, and the deadline still bounds the wait.
+ */
+function isLockContention(code: string | undefined): boolean {
+	return code === "EEXIST" || code === "EPERM" || code === "EBUSY";
+}
+
 function acquireLockWithRetry(filePath: string, staleMs: number, kind: LockKind = "file"): string {
 	let attempt = 0;
 	const deadline = Date.now() + staleMs * 2;
@@ -317,7 +332,7 @@ function acquireLockWithRetry(filePath: string, staleMs: number, kind: LockKind
 			return token;
 		} catch (error) {
 			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "EEXIST") throw error;
+			if (!isLockContention(code)) throw error;
 			if (Date.now() > deadline) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
@@ -355,7 +370,7 @@ async function acquireLockWithRetryAsync(filePath: string, staleMs: number, kind
 			return token;
 		} catch (error) {
 			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "EEXIST") throw error;
+			if (!isLockContention(code)) throw error;
 			if (Date.now() > deadline) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}

package/src/ui/adaptive-card.ts

@@ -0,0 +1,65 @@
+/**
+ * AdaptiveCard — a width-deferred card component (R2, 2026-09-16).
+ *
+ * Problem it fixes: pi-crew's tool-renderer cards used to be BUILT as a
+ * pre-formatted string at a guessed width (`ctx.width || process.stdout.columns
+ * || 116`) and handed to `new Text(...)`. Pi's ToolRenderContext carries NO
+ * width field — neither the TUI nor export-html pass one — so the guess could
+ * never match the real render column. `Text.render(width)` WRAPS lines wider
+ * than the column, which tore the box frame apart (top border split mid-line,
+ * right border vanished). This hit HTML export hardest: export renders every
+ * card at width=100 while a non-TTY export process builds at the 116 fallback.
+ *
+ * Design: build the frame at RENDER time, at the width the caller actually
+ * provides. The card receives a `builder(width) => string`; `render(width)`
+ * invokes it and delegates line-wrapping/padding to a zero-padding `Text`.
+ * Results are cached per width (mirroring Text's own cache) so repeated
+ * renders of an unchanged card cost nothing.
+ *
+ * Fail-visible: a builder exception surfaces as a red `✖ card render error`
+ * line instead of propagating into the TUI render loop (which has no per-
+ * component catch). Construction-time errors in the ToolRenderer wrappers
+ * keep their own catch — this is the third and final layer.
+ */
+
+import { Text } from "@earendil-works/pi-tui";
+import type { CrewComponent } from "./component.ts";
+
+export class AdaptiveCard implements CrewComponent {
+	#builder: (width: number) => string;
+	#errorStyle: (text: string) => string;
+	#text = new Text("", 0, 0);
+	#cachedWidth: number | undefined;
+	#cachedLines: string[] | null = null;
+
+	/**
+	 * @param builder produces the full card text (frame included) for a width.
+	 *   Must keep every line within `width` visual columns — the same contract
+	 *   the old fixed-width builders already obeyed for their baked width.
+	 * @param errorStyle theme.fg("error", …) adapter for the fail-visible line.
+	 */
+	constructor(builder: (width: number) => string, errorStyle: (text: string) => string = (t) => t) {
+		this.#builder = builder;
+		this.#errorStyle = errorStyle;
+	}
+
+	invalidate(): void {
+		this.#cachedLines = null;
+		this.#cachedWidth = undefined;
+	}
+
+	render(width: number): string[] {
+		if (this.#cachedLines !== null && this.#cachedWidth === width) return this.#cachedLines;
+		let text: string;
+		try {
+			text = this.#builder(width);
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			text = this.#errorStyle(`✖ card render error: ${msg.slice(0, 60)}`);
+		}
+		this.#text.setText(text);
+		this.#cachedLines = this.#text.render(width);
+		this.#cachedWidth = width;
+		return this.#cachedLines;
+	}
+}