@nklisch/pi-enhanced 0.1.8 → 0.1.10

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

@@ -9,9 +9,10 @@ import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { LifetimeUsage } from "#src/lifecycle/usage";
 import { getLifetimeTotal } from "#src/lifecycle/usage";
-import type { SubagentType } from "#src/types";
+import type { SubagentType, ThinkingLevel } from "#src/types";
 import {
 	describeActivity,
+	formatModelThinking,
 	formatMs,
 	formatSessionTokens,
 	formatTurns,
@@ -30,6 +31,7 @@ export interface WidgetAgent {
 	readonly status: string;
 	readonly description: string;
 	readonly modelLabel: string;
+	readonly thinkingLevel: ThinkingLevel;
 	readonly toolUses: number;
 	readonly startedAt: number;
 	readonly completedAt?: number;
@@ -78,7 +80,7 @@ export function renderFinishedLine(
 		statusText = theme.fg("warning", " aborted");
 	}
 
-	const parts: string[] = [agent.modelLabel];
+	const parts: string[] = [formatModelThinking(agent.modelLabel, agent.thinkingLevel)];
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	parts.push(duration);
@@ -102,7 +104,7 @@ export function renderRunningLines(
 	const tokens = getLifetimeTotal(agent.lifetimeUsage);
 	const tokenText = tokens > 0 ? formatSessionTokens(tokens, agent.contextPercent, theme, agent.compactionCount) : "";
 
-	const parts: string[] = [agent.modelLabel];
+	const parts: string[] = [formatModelThinking(agent.modelLabel, agent.thinkingLevel)];
 	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);
@@ -176,7 +178,7 @@ function buildSections(
 		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", formatModelThinking(agent.modelLabel, agent.thinkingLevel))}`
 			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", agent.description)}`
 			+ ` ${theme.fg("dim", "· queued")}`,
 		),

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

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-plugins",
-  "version": "0.3.5",
+  "version": "0.3.8",
   "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.20.1-nklisch.0",
-    "@nklisch/pi-subagents": "18.1.0-nklisch.0",
+    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.1",
+    "@nklisch/pi-subagents": "18.1.0-nklisch.1",
     "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.8",
+  "version": "0.1.10",
   "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"
@@ -67,7 +67,7 @@
     "@nklisch/pi-clearance": "^0",
     "@nklisch/pi-conveniences": "^0",
     "@nklisch/pi-fff-compat": "^0",
-    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.0",
+    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.1",
     "@nklisch/pi-model-modes": "^0",
     "@nklisch/pi-plugins": "^0",
     "@sinclair/typebox": "^0.34.49",
@@ -101,6 +101,6 @@
     "pi-web-access"
   ],
   "scripts": {
-    "test": "node test/verify-bundle.mjs"
+    "test": "node test/verify-bundle.mjs && node test/verify-subagent-restart.mjs"
   }
 }

package/test/verify-subagent-restart.mjs

@@ -0,0 +1,186 @@
+import { spawn } from "node:child_process";
+import { execFileSync } from "node:child_process";
+import {
+  cpSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = resolve(packageRoot, "../..");
+const scratch = mkdtempSync(join(tmpdir(), "pi-enhanced-subagent-restart-"));
+const packOut = join(scratch, "pack");
+const extracted = join(scratch, "extracted");
+const sessionDir = join(scratch, "sessions");
+const inspector = join(scratch, "inspect-tools.mjs");
+const sessionId = "019d9a5f-7b13-7000-8000-000000000001";
+const requiredTools = ["subagent", "get_subagent_result", "steer_subagent"];
+const liveChildren = new Set();
+
+function stageRuntimeDependency(candidateRoot, name) {
+  const target = resolve(repoRoot, "node_modules", name);
+  const destination = join(candidateRoot, "node_modules", name);
+  mkdirSync(dirname(destination), { recursive: true });
+  cpSync(target, destination, { recursive: true });
+}
+
+function startPi(extensionPath, extraArgs = []) {
+  const cli = resolve(repoRoot, "node_modules/@earendil-works/pi-coding-agent/dist/cli.js");
+  const child = spawn(process.execPath, [
+    cli,
+    "--offline",
+    "--approve",
+    "--no-extensions",
+    "--no-skills",
+    "--no-prompt-templates",
+    "--no-themes",
+    "--no-context-files",
+    "--extension", extensionPath,
+    "--extension", inspector,
+    "--mode", "rpc",
+    "--session-dir", sessionDir,
+    "--session-id", sessionId,
+    ...extraArgs,
+  ], {
+    cwd: repoRoot,
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  liveChildren.add(child);
+  let stdout = "";
+  let stderr = "";
+  let sequence = 0;
+  const pending = new Map();
+  child.stderr.on("data", chunk => { stderr += chunk; });
+  child.stdout.on("data", chunk => {
+    stdout += chunk;
+    for (;;) {
+      const newline = stdout.indexOf("\n");
+      if (newline < 0) break;
+      const line = stdout.slice(0, newline);
+      stdout = stdout.slice(newline + 1);
+      if (!line) continue;
+      let event;
+      try { event = JSON.parse(line); }
+      catch { continue; }
+      if (event.type !== "response" || typeof event.id !== "string") continue;
+      const waiter = pending.get(event.id);
+      if (!waiter) continue;
+      pending.delete(event.id);
+      waiter.resolve(event);
+    }
+  });
+  const exited = new Promise(resolvePromise => {
+    child.once("exit", (code, signal) => {
+      liveChildren.delete(child);
+      const error = new Error(`Pi exited before responding (${code ?? signal})\n${stderr}`);
+      for (const waiter of pending.values()) waiter.reject(error);
+      pending.clear();
+      resolvePromise({ code, signal });
+    });
+  });
+
+  async function request(command) {
+    const id = `restart-${++sequence}`;
+    const response = new Promise((resolvePromise, reject) => {
+      pending.set(id, { resolve: resolvePromise, reject });
+    });
+    child.stdin.write(`${JSON.stringify({ id, ...command })}\n`);
+    const timer = setTimeout(() => {
+      const waiter = pending.get(id);
+      if (!waiter) return;
+      pending.delete(id);
+      waiter.reject(new Error(`Pi RPC timed out for ${command.type}\n${stderr}`));
+    }, 20_000);
+    timer.unref?.();
+    try {
+      const result = await response;
+      if (!result.success) throw new Error(`Pi RPC ${command.type} failed: ${result.error ?? "unknown error"}\n${stderr}`);
+      return result;
+    } finally {
+      clearTimeout(timer);
+      pending.delete(id);
+    }
+  }
+
+  return { child, exited, request, stderr: () => stderr };
+}
+
+async function inspect(runtime) {
+  await runtime.request({ type: "get_commands" });
+  await runtime.request({ type: "prompt", message: "/inspect-tools" });
+  const entries = await runtime.request({ type: "get_entries" });
+  const report = entries.data.entries.findLast(
+    entry => entry.type === "custom" && entry.customType === "subagent-tool-regression",
+  )?.data;
+  if (!report) throw new Error(`Inspector produced no report\n${runtime.stderr()}`);
+  for (const name of requiredTools) {
+    if (!report.registered.includes(name) || !report.active.includes(name)) {
+      throw new Error(`Missing active subagent tool ${name}: ${JSON.stringify(report)}\n${runtime.stderr()}`);
+    }
+  }
+}
+
+try {
+  mkdirSync(packOut, { recursive: true });
+  mkdirSync(extracted, { recursive: true });
+  mkdirSync(sessionDir, { recursive: true });
+  const raw = execFileSync(
+    process.execPath,
+    [resolve(repoRoot, "scripts/pack-package.mjs"), packageRoot, "--out", packOut],
+    { encoding: "utf8" },
+  );
+  const report = JSON.parse(raw);
+  const tarball = join(packOut, report[0].filename);
+  execFileSync("tar", ["-xzf", tarball, "-C", extracted]);
+  const candidate = join(extracted, "package");
+
+  // A normal npm installation provides these ordinary dependencies beside the
+  // bundled packages. Keep Pi's peer packages absent from this tree: the test
+  // specifically exercises the bridge from an externally installed Pi host.
+  stageRuntimeDependency(candidate, "jiti");
+  stageRuntimeDependency(candidate, "@sinclair/typebox");
+
+  writeFileSync(inspector, `
+export default function (pi) {
+  pi.registerCommand("inspect-tools", {
+    description: "Inspect subagent tool registration",
+    handler: async () => {
+      pi.appendEntry("subagent-tool-regression", {
+        registered: pi.getAllTools().map(tool => tool.name),
+        active: pi.getActiveTools(),
+      });
+    },
+  });
+}
+`);
+
+  const manifest = JSON.parse(readFileSync(join(candidate, "package.json"), "utf8"));
+  const extensionPath = resolve(candidate, manifest.pi.extensions.find(path => path.includes("production-subagents-extension")));
+
+  const first = startPi(extensionPath);
+  await inspect(first);
+  first.child.kill("SIGKILL");
+  await first.exited;
+
+  const resumed = startPi(extensionPath);
+  await inspect(resumed);
+  resumed.child.stdin.end();
+  const exit = await resumed.exited;
+  if (exit.code !== 0) throw new Error(`Resumed Pi exited unsuccessfully: ${JSON.stringify(exit)}\n${resumed.stderr()}`);
+
+  console.log("Subagent tools remain registered and active after abrupt Pi process replacement.");
+} finally {
+  const children = [...liveChildren];
+  const exits = children.map(child => new Promise(resolvePromise => child.once("exit", resolvePromise)));
+  for (const child of children) child.kill("SIGKILL");
+  await Promise.allSettled(exits);
+  rmSync(scratch, { recursive: true, force: true });
+}