@nklisch/pi-enhanced 0.1.2 → 0.1.4

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/session-navigation.ts

@@ -14,7 +14,6 @@
 
 import { buildSessionContext, parseSessionEntries, type SessionEntry, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { AgentConfigLookup } from "#src/config/agent-types";
-import type { EvictedSubagent } from "#src/lifecycle/subagent-manager";
 import type { SubagentStatus } from "#src/lifecycle/subagent-state";
 import type { AgentSessionEvent, SessionMessage, SubagentType } from "#src/types";
 import { formatDuration, getDisplayName } from "#src/ui/display";
@@ -26,12 +25,14 @@ export interface NavigableSubagent {
   readonly id: string;
   readonly type: SubagentType;
   readonly description: string;
+  readonly modelLabel: string;
   readonly status: SubagentStatus;
   readonly startedAt: number;
   readonly completedAt: number | undefined;
   readonly toolUses: number;
   readonly activeTools: ReadonlyMap<string, string>;
   readonly responseText: string;
+  readonly outputFile: string | undefined;
   readonly agentMessages: readonly SessionMessage[];
   isSessionReady(): boolean;
   subscribeToUpdates(fn: (event: AgentSessionEvent) => void): (() => void) | undefined;
@@ -41,17 +42,24 @@ export interface NavigableSubagent {
 /**
  * A navigable entry plus the label shown in the picker.
  *
- * A `live` entry sources its transcript from the in-memory record; an `evicted`
- * entry sources it from the persisted session file (the record is gone).
+ * A `live` entry sources its transcript from the in-memory session; an
+ * `evicted`-kind entry is a persisted snapshot for a released live session.
  */
+export interface RunDisplayMetadata {
+  readonly modelLabel: string;
+  readonly startedAt: number;
+  readonly completedAt: () => number | undefined;
+}
+
 export type NavigationEntry =
-  | { readonly kind: "live"; readonly label: string; readonly record: NavigableSubagent }
-  | { readonly kind: "evicted"; readonly label: string; readonly outputFile: string };
+  | { readonly kind: "live"; readonly label: string; readonly record: NavigableSubagent; readonly run: RunDisplayMetadata }
+  | { readonly kind: "evicted"; readonly label: string; readonly outputFile: string; readonly run: RunDisplayMetadata };
 
 /** The fields `buildLabel` reads — shared by a live record and an evicted descriptor. */
 interface LabelFields {
   readonly type: SubagentType;
   readonly description: string;
+  readonly modelLabel: string;
   readonly status: SubagentStatus;
   readonly startedAt: number;
   readonly completedAt: number | undefined;
@@ -77,34 +85,35 @@ export interface TranscriptSource {
 }
 
 /**
- * Label every navigable subagent for the picker: live records with a viewable
- * session, then agents evicted by the cleanup sweep (deduped against live ids).
+ * Label every navigable subagent: live sessions first, then persisted snapshots
+ * for released records and any legacy evicted descriptors.
  */
 export function listNavigableAgents(
   agents: readonly NavigableSubagent[],
-  evicted: readonly EvictedSubagent[],
   registry: AgentConfigLookup,
 ): NavigationEntry[] {
-  const live = agents
-    .filter((record) => record.isSessionReady())
-    .map((record): NavigationEntry => ({ kind: "live", record, label: buildLabel(record, registry) }));
-  const liveIds = new Set(agents.map((record) => record.id));
-  const evictedEntries = evicted
-    .filter((descriptor) => !liveIds.has(descriptor.id))
-    .map((descriptor): NavigationEntry => ({
-      kind: "evicted",
-      outputFile: descriptor.outputFile,
-      label: buildLabel(descriptor, registry, true),
-    }));
-  return [...live, ...evictedEntries];
+  const live = agents.flatMap((record): NavigationEntry[] => {
+    const run = {
+      modelLabel: record.modelLabel,
+      startedAt: record.startedAt,
+      completedAt: () => record.completedAt,
+    };
+    if (record.isSessionReady()) {
+      return [{ kind: "live", record, label: buildLabel(record, registry), run }];
+    }
+    return record.outputFile
+      ? [{ kind: "evicted", outputFile: record.outputFile, label: buildLabel(record, registry, true), run }]
+      : [];
+  });
+  return live;
 }
 
 /**
  * Source a transcript from a persisted child-session JSONL snapshot.
  *
- * For an agent evicted from the manager's map by the 10-minute cleanup sweep:
- * the in-memory record (and its message history) is gone, but the session file
- * survives on disk. Reads the file, drops the `SessionHeader`, and resolves the
+ * For an agent whose live session was released, the in-memory message history is
+ * gone but the terminal record and session file survive. Reads the file, drops
+ * the `SessionHeader`, and resolves the
  * message list via Pi's own parser. A static snapshot — no subscription, no
  * streaming, no live tool registry. `readFile` is injected so this module makes
  * no `fs` calls.
@@ -140,6 +149,6 @@ export function liveSource(record: NavigableSubagent): TranscriptSource {
 function buildLabel(fields: LabelFields, registry: AgentConfigLookup, evicted = false): string {
   const name = getDisplayName(fields.type, registry);
   const duration = formatDuration(fields.startedAt, fields.completedAt);
-  const marker = evicted ? " · evicted (snapshot)" : "";
-  return `${name} (${fields.description}) · ${fields.toolUses} tools · ${fields.status} · ${duration}${marker}`;
+  const marker = evicted ? " · released (snapshot)" : "";
+  return `${name} (${fields.description}) · ${fields.modelLabel} · ${fields.toolUses} tools · ${fields.status} · ${duration}${marker}`;
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/session-navigator.ts

@@ -38,10 +38,9 @@ import {
   visibleWidth,
 } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
-import type { EvictedSubagent } from "#src/lifecycle/subagent-manager";
 import type { SessionMessage } from "#src/types";
-import { describeActivity, type Theme } from "#src/ui/display";
-import { fileSnapshotSource, listNavigableAgents, liveSource, type NavigableSubagent, type TranscriptSource } from "#src/ui/session-navigation";
+import { describeActivity, formatDuration, type Theme } from "#src/ui/display";
+import { fileSnapshotSource, listNavigableAgents, liveSource, type NavigableSubagent, type RunDisplayMetadata, type TranscriptSource } from "#src/ui/session-navigation";
 
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -69,8 +68,6 @@ export interface SessionNavigatorUI {
 export interface SessionNavigatorParams {
   ui: SessionNavigatorUI;
   agents: readonly NavigableSubagent[];
-  /** Descriptors of agents evicted by the cleanup sweep, sourced from disk when picked. */
-  evicted: readonly EvictedSubagent[];
   registry: AgentConfigLookup;
   /** Working directory for tool-call rendering (relative path display). */
   cwd: string;
@@ -83,6 +80,7 @@ export interface TranscriptOverlayOptions {
   tui: TUI;
   theme: Theme;
   source: TranscriptSource;
+  run: RunDisplayMetadata;
   done: (result: undefined) => void;
   cwd: string;
   markdownTheme: MarkdownTheme;
@@ -96,8 +94,8 @@ export interface TranscriptOverlayOptions {
  * manager, so it stays a reactive consumer with no inbound call into the core.
  */
 export class SessionNavigatorHandler {
-  async handle({ ui, agents, evicted, registry, cwd, readFile }: SessionNavigatorParams): Promise<void> {
-    const entries = listNavigableAgents(agents, evicted, registry);
+  async handle({ ui, agents, registry, cwd, readFile }: SessionNavigatorParams): Promise<void> {
+    const entries = listNavigableAgents(agents, registry);
     if (entries.length === 0) {
       ui.notify("No subagent sessions to view.", "info");
       return;
@@ -120,7 +118,7 @@ export class SessionNavigatorHandler {
     const markdownTheme = getMarkdownTheme();
     await ui.custom<undefined>(
       (tui, theme, _keybindings, done) =>
-        new TranscriptOverlay({ tui, theme, source, done, cwd, markdownTheme }),
+        new TranscriptOverlay({ tui, theme, source, run: entry.run, done, cwd, markdownTheme }),
       {
         overlay: true,
         overlayOptions: { anchor: "center", width: "90%", maxHeight: `${VIEWPORT_HEIGHT_PCT}%` },
@@ -142,20 +140,23 @@ export class TranscriptOverlay implements Component {
   private scrollOffset = 0;
   private autoScroll = true;
   private unsubscribe: (() => void) | undefined;
+  private runtimeInterval: ReturnType<typeof setInterval> | undefined;
   private closed = false;
 
   private readonly tui: TUI;
   private readonly theme: Theme;
   private readonly source: TranscriptSource;
+  private readonly run: RunDisplayMetadata;
   private readonly done: (result: undefined) => void;
   private readonly cwd: string;
   private readonly markdownTheme: MarkdownTheme;
   private content: Container;
 
-  constructor({ tui, theme, source, done, cwd, markdownTheme }: TranscriptOverlayOptions) {
+  constructor({ tui, theme, source, run, done, cwd, markdownTheme }: TranscriptOverlayOptions) {
     this.tui = tui;
     this.theme = theme;
     this.source = source;
+    this.run = run;
     this.done = done;
     this.cwd = cwd;
     this.markdownTheme = markdownTheme;
@@ -165,11 +166,21 @@ export class TranscriptOverlay implements Component {
       this.content = this.rebuild();
       this.tui.requestRender();
     });
+    if (run.completedAt() === undefined) {
+      this.runtimeInterval = setInterval(() => {
+        if (this.closed || this.run.completedAt() !== undefined) {
+          this.clearRuntimeInterval();
+          return;
+        }
+        this.tui.requestRender();
+      }, 100);
+    }
   }
 
   handleInput(data: string): void {
     if (matchesKey(data, "escape") || matchesKey(data, "q")) {
       this.closed = true;
+      this.clearRuntimeInterval();
       this.done(undefined);
       return;
     }
@@ -213,7 +224,8 @@ export class TranscriptOverlay implements Component {
     const hrMid = row(th.fg("dim", "─".repeat(innerW)));
 
     lines.push(hrTop);
-    lines.push(row(th.bold("Subagent session")));
+    const runtime = formatDuration(this.run.startedAt, this.run.completedAt());
+    lines.push(row(th.bold(`Subagent session · ${this.run.modelLabel} · ${runtime}`)));
     lines.push(hrMid);
 
     const contentLines = this.buildContentLines(innerW);
@@ -249,10 +261,18 @@ export class TranscriptOverlay implements Component {
       this.unsubscribe();
       this.unsubscribe = undefined;
     }
+    this.clearRuntimeInterval();
   }
 
   // ---- Private ----
 
+  private clearRuntimeInterval(): void {
+    if (this.runtimeInterval) {
+      clearInterval(this.runtimeInterval);
+      this.runtimeInterval = undefined;
+    }
+  }
+
   private innerWidth(): number {
     return Math.max(0, this.tui.terminal.columns - 4);
   }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/subagents-settings.ts

@@ -5,9 +5,17 @@ export interface SubagentsSettingsManager {
   readonly maxConcurrent: number;
   readonly defaultMaxTurns: number | undefined;
   readonly graceTurns: number;
+  readonly consumedSessionRetentionMinutes: number;
+  readonly unconsumedSessionRetentionMinutes: number;
+  readonly abortAllOnInterrupt: boolean;
+  readonly fallbackSubagent: string | false | undefined;
   applyMaxConcurrent(n: number): { message: string; level: "info" | "warning" };
   applyDefaultMaxTurns(n: number): { message: string; level: "info" | "warning" };
   applyGraceTurns(n: number): { message: string; level: "info" | "warning" };
+  applyConsumedSessionRetention(n: number): { message: string; level: "info" | "warning" };
+  applyUnconsumedSessionRetention(n: number): { message: string; level: "info" | "warning" };
+  applyAbortAllOnInterrupt(value: boolean): { message: string; level: "info" | "warning" };
+  applyFallbackSubagent(value: string | false | undefined): { message: string; level: "info" | "warning" };
 }
 
 /** Narrow UI interface — only the ctx.ui methods the settings handler calls. */
@@ -17,6 +25,12 @@ export interface SubagentsSettingsUI {
   notify(message: string, level: "info" | "warning" | "error"): void;
 }
 
+/** Registry operations needed to offer only valid fallback agents. */
+export interface SubagentsSettingsAgentRegistry {
+  reload(): void;
+  getAvailableTypes(): string[];
+}
+
 // ---- Class ----
 
 /**
@@ -26,13 +40,20 @@ export interface SubagentsSettingsUI {
  * settings list. Lifted from `AgentsMenuHandler.showSettings`.
  */
 export class SubagentsSettingsHandler {
-  constructor(private readonly settings: SubagentsSettingsManager) {}
+  constructor(
+    private readonly settings: SubagentsSettingsManager,
+    private readonly agentRegistry: SubagentsSettingsAgentRegistry,
+  ) {}
 
   async handle({ ui }: { ui: SubagentsSettingsUI }): Promise<void> {
     const choice = await ui.select("Settings", [
       `Max concurrency (current: ${this.settings.maxConcurrent})`,
       `Default max turns (current: ${this.settings.defaultMaxTurns ?? "unlimited"})`,
       `Grace turns (current: ${this.settings.graceTurns})`,
+      `Consumed session retention (current: ${this.settings.consumedSessionRetentionMinutes}m)`,
+      `Unconsumed session retention (current: ${this.settings.unconsumedSessionRetentionMinutes}m)`,
+      `Abort all on ESC (current: ${this.settings.abortAllOnInterrupt ? "yes" : "no"})`,
+      `Unknown agent fallback (current: ${this.settings.fallbackSubagent === false ? "none" : this.settings.fallbackSubagent ?? "general-purpose"})`,
     ]);
     if (!choice) return;
 
@@ -65,19 +86,43 @@ export class SubagentsSettingsHandler {
         }
       }
     } else if (choice.startsWith("Grace turns")) {
-      const val = await ui.input(
-        "Grace turns after wrap-up steer",
-        String(this.settings.graceTurns),
-      );
-      if (val) {
-        const n = parseInt(val, 10);
-        if (n >= 1) {
-          const toast = this.settings.applyGraceTurns(n);
-          ui.notify(toast.message, toast.level);
-        } else {
-          ui.notify("Must be a positive integer.", "warning");
-        }
+      await this.applyNonNegativeInput(ui, "Grace turns after wrap-up steer", this.settings.graceTurns, 1, (n) => this.settings.applyGraceTurns(n));
+    } else if (choice.startsWith("Consumed session retention")) {
+      await this.applyNonNegativeInput(ui, "Minutes to retain a consumed live session", this.settings.consumedSessionRetentionMinutes, 0, (n) => this.settings.applyConsumedSessionRetention(n));
+    } else if (choice.startsWith("Unconsumed session retention")) {
+      await this.applyNonNegativeInput(ui, "Minutes to retain an unconsumed live session", this.settings.unconsumedSessionRetentionMinutes, 0, (n) => this.settings.applyUnconsumedSessionRetention(n));
+    } else if (choice.startsWith("Abort all on ESC")) {
+      const toast = this.settings.applyAbortAllOnInterrupt(!this.settings.abortAllOnInterrupt);
+      ui.notify(toast.message, toast.level);
+    } else if (choice.startsWith("Unknown agent fallback")) {
+      this.agentRegistry.reload();
+      const failClosed = "Fail closed (no fallback)";
+      const selected = await ui.select("Fallback for unknown agent types", [
+        failClosed,
+        ...this.agentRegistry.getAvailableTypes(),
+      ]);
+      if (selected) {
+        const toast = this.settings.applyFallbackSubagent(selected === failClosed ? false : selected);
+        ui.notify(toast.message, toast.level);
       }
     }
   }
+
+  private async applyNonNegativeInput(
+    ui: SubagentsSettingsUI,
+    title: string,
+    current: number,
+    minimum: number,
+    apply: (value: number) => { message: string; level: "info" | "warning" },
+  ): Promise<void> {
+    const val = await ui.input(title, String(current));
+    if (!val) return;
+    const n = Number(val);
+    if (!Number.isInteger(n) || n < minimum) {
+      ui.notify(minimum === 0 ? "Must be a non-negative integer." : "Must be a positive integer.", "warning");
+      return;
+    }
+    const toast = apply(n);
+    ui.notify(toast.message, toast.level);
+  }
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/widget-renderer.ts

@@ -29,6 +29,7 @@ export interface WidgetAgent {
 	readonly type: SubagentType;
 	readonly status: string;
 	readonly description: string;
+	readonly modelLabel: string;
 	readonly toolUses: number;
 	readonly startedAt: number;
 	readonly completedAt?: number;
@@ -77,7 +78,7 @@ export function renderFinishedLine(
 		statusText = theme.fg("warning", " aborted");
 	}
 
-	const parts: string[] = [];
+	const parts: string[] = [agent.modelLabel];
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	parts.push(duration);
@@ -101,7 +102,7 @@ export function renderRunningLines(
 	const tokens = getLifetimeTotal(agent.lifetimeUsage);
 	const tokenText = tokens > 0 ? formatSessionTokens(tokens, agent.contextPercent, theme, agent.compactionCount) : "";
 
-	const parts: string[] = [];
+	const parts: string[] = [agent.modelLabel];
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	if (tokenText) parts.push(tokenText);
@@ -146,7 +147,7 @@ function categorizeAgents(
 interface WidgetSections {
 	finishedLines: string[];
 	runningLines: [string, string][];
-	queuedLine: string | undefined;
+	queuedLines: string[];
 }
 
 /** Render each agent bucket into pre-formatted lines with ├─ tree connectors. */
@@ -171,11 +172,17 @@ function buildSections(
 		]);
 	}
 
-	const queuedLine = categories.queued.length > 0
-		? truncate(theme.fg("dim", "\u251C\u2500") + ` ${theme.fg("muted", "\u25E6")} ${theme.fg("dim", `${categories.queued.length} queued`)}`)
-		: undefined;
+	const queuedLines = categories.queued.map((agent) =>
+		truncate(
+			theme.fg("dim", "\u251C\u2500")
+			+ ` ${theme.fg("muted", "\u25E6")} ${theme.fg("dim", getDisplayName(agent.type, registry))}`
+			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", agent.modelLabel)}`
+			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", agent.description)}`
+			+ ` ${theme.fg("dim", "· queued")}`,
+		),
+	);
 
-	return { finishedLines, runningLines, queuedLine };
+	return { finishedLines, runningLines, queuedLines };
 }
 
 /**
@@ -183,16 +190,16 @@ function buildSections(
  * Fixes the last tree connector: ├─ → └─, and │ → space for the running-agent activity line.
  */
 function assembleWithinBudget(heading: string, sections: WidgetSections): string[] {
-	const { finishedLines, runningLines, queuedLine } = sections;
+	const { finishedLines, runningLines, queuedLines } = sections;
 	const lines: string[] = [heading, ...finishedLines];
 	for (const pair of runningLines) lines.push(...pair);
-	if (queuedLine) lines.push(queuedLine);
+	lines.push(...queuedLines);
 
 	// Fix last connector: swap \u251C\u2500 \u2192 \u2514\u2500.
 	if (lines.length > 1) {
 		const last = lines.length - 1;
 		lines[last] = lines[last].replace("\u251C\u2500", "\u2514\u2500");
-		if (runningLines.length > 0 && !queuedLine) {
+		if (runningLines.length > 0 && queuedLines.length === 0) {
 			if (last >= 2) {
 				lines[last - 1] = lines[last - 1].replace("\u251C\u2500", "\u2514\u2500");
 				lines[last] = lines[last].replace("\u2502  ", "   ");
@@ -213,10 +220,11 @@ function assembleOverflow(
 	truncate: (line: string) => string,
 	theme: Theme,
 ): string[] {
-	const { finishedLines, runningLines, queuedLine } = sections;
+	const { finishedLines, runningLines, queuedLines } = sections;
 	const lines: string[] = [heading];
 	let budget = maxBody - 1;
 	let hiddenRunning = 0;
+	let hiddenQueued = 0;
 	let hiddenFinished = 0;
 
 	for (const pair of runningLines) {
@@ -228,9 +236,13 @@ function assembleOverflow(
 		}
 	}
 
-	if (queuedLine && budget >= 1) {
-		lines.push(queuedLine);
-		budget--;
+	for (const queuedLine of queuedLines) {
+		if (budget >= 1) {
+			lines.push(queuedLine);
+			budget--;
+		} else {
+			hiddenQueued++;
+		}
 	}
 
 	for (const fl of finishedLines) {
@@ -244,9 +256,10 @@ function assembleOverflow(
 
 	const overflowParts: string[] = [];
 	if (hiddenRunning > 0) overflowParts.push(`${hiddenRunning} running`);
+	if (hiddenQueued > 0) overflowParts.push(`${hiddenQueued} queued`);
 	if (hiddenFinished > 0) overflowParts.push(`${hiddenFinished} finished`);
 	const overflowText = overflowParts.join(", ");
-	lines.push(truncate(theme.fg("dim", "\u2514\u2500") + ` ${theme.fg("dim", `+${hiddenRunning + hiddenFinished} more (${overflowText})`)}`));
+	lines.push(truncate(theme.fg("dim", "\u2514\u2500") + ` ${theme.fg("dim", `+${hiddenRunning + hiddenQueued + hiddenFinished} more (${overflowText})`)}`));
 	return lines;
 }
 
@@ -272,7 +285,7 @@ export function renderWidgetLines(params: {
 	const headingColor = hasActive ? "accent" : "dim";
 	const headingIcon = hasActive ? "\u25CF" : "\u25CB";
 
-	const { finishedLines, runningLines, queuedLine } = buildSections(
+	const { finishedLines, runningLines, queuedLines } = buildSections(
 		{ running, queued, finished },
 		registry,
 		spinnerFrame,
@@ -282,11 +295,11 @@ export function renderWidgetLines(params: {
 
 	// Assemble with overflow cap (heading takes 1 line).
 	const maxBody = MAX_WIDGET_LINES - 1;
-	const totalBody = finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
+	const totalBody = finishedLines.length + runningLines.length * 2 + queuedLines.length;
 	const heading = truncate(theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents"));
 
 	if (totalBody <= maxBody) {
-		return assembleWithinBudget(heading, { finishedLines, runningLines, queuedLine });
+		return assembleWithinBudget(heading, { finishedLines, runningLines, queuedLines });
 	}
-	return assembleOverflow(heading, { finishedLines, runningLines, queuedLine }, maxBody, truncate, theme);
+	return assembleOverflow(heading, { finishedLines, runningLines, queuedLines }, maxBody, truncate, theme);
 }

package/node_modules/@nklisch/pi-plugins/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-plugins",
-  "version": "0.2.5",
+  "version": "0.3.4",
   "private": false,
   "description": "Native marketplace and plugin lifecycle management for Pi, with Claude Code and Codex compatibility.",
   "license": "MIT",
@@ -67,8 +67,8 @@
     "@nklisch/pi-subagents"
   ],
   "dependencies": {
-    "@nklisch/pi-mcp-adapter": "2.11.0-nklisch.7",
-    "@nklisch/pi-subagents": "18.0.4-nklisch.1",
+    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.0",
+    "@nklisch/pi-subagents": "18.1.0-nklisch.0",
     "jiti": "2.7.0",
     "semver": "7.8.1",
     "smol-toml": "^1.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-enhanced",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Pi, enhanced — one install for nklisch's full harness: policy-gated command review, plugin marketplace, subagents, background tasks, research tools, search, model modes, and a curated UX set.",
   "author": {
     "name": "nklisch"

package/test/verify-bundle.mjs

@@ -7,12 +7,15 @@
  * resource path actually land in the pack?"
  */
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const clearanceManifest = JSON.parse(
+  readFileSync(join(root, "../pi-clearance/package.json"), "utf8"),
+);
 
 // Pack through the repo's bundle-aware packer; npm pack alone drops
 // bundleDependencies inside workspaces.
@@ -45,6 +48,30 @@ for (const dep of manifest.bundledDependencies ?? []) {
   if (!hit) failures.push(`node_modules/${dep}/package.json (bundled dependency missing)`);
 }
 
+const clearancePrefix = "node_modules/@nklisch/pi-clearance/";
+const targetSuffix = new Map([
+  ["x86_64-unknown-linux-gnu", "linux-x64-gnu"],
+  ["aarch64-unknown-linux-gnu", "linux-arm64-gnu"],
+  ["x86_64-apple-darwin", "darwin-x64"],
+  ["aarch64-apple-darwin", "darwin-arm64"],
+  ["x86_64-pc-windows-msvc", "win32-x64-msvc"],
+  ["aarch64-pc-windows-msvc", "win32-arm64-msvc"],
+]);
+const nativeArtifacts = clearanceManifest.napi.targets.map((target) => {
+  const suffix = targetSuffix.get(target);
+  if (suffix === undefined) throw new Error(`Unknown Pi Clearance native target: ${target}`);
+  return `${clearanceManifest.napi.binaryName}.${suffix}.node`;
+});
+for (const artifact of nativeArtifacts) {
+  const staged = existsSync(join(root, "../pi-clearance/native", artifact));
+  if (process.env.PI_NATIVE_RELEASE_ARTIFACTS === "1" && !staged) {
+    failures.push(`release artifact was not staged: ${artifact}`);
+  }
+  if (staged && !files.has(`${clearancePrefix}native/${artifact}`)) {
+    failures.push(`bundled pi-clearance is missing native/${artifact}`);
+  }
+}
+
 if (failures.length > 0) {
   console.error(`Bundle verification failed:\n- ${failures.join("\n- ")}`);
   process.exit(1);