supipowers 2.2.1 → 2.2.3

package/README.md

@@ -36,6 +36,9 @@ The installer detects Pi (`~/.pi`) and OMP (`~/.omp`) — when both are present
 | [Bun](https://bun.sh)                                 | Runtime — required for installation and the built-in SQLite FTS index |
 | [Git](https://git-scm.com)                            | Used by the installer and git-based workflows                         |
 
+> [!TIP]
+> OMP ≥15.1.7 is recommended for best reliability with supipowers command-driven agent handoffs and accurate provider-scoped `/fast` status indicators. Older compatible OMP versions can run supipowers but lack those runtime fixes.
+
 ### Optional dependencies
 
 The installer scans for these and offers to install missing tooling where it can. Everything works without them, but each one unlocks additional capabilities.

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "supipowers",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {
-    "test": "bun test --timeout 20000 tests/",
+    "test": "bun test --timeout 60000 --parallel tests/",
+    "test:windows": "bun test --timeout 60000 --parallel tests/platform/ tests/utils/editor.test.ts tests/utils/exec-cli.test.ts tests/fix-pr/scripts/exec.test.ts tests/mempalace/uv.test.ts tests/mempalace/git-hook.test.ts",
     "typecheck": "tsc --noEmit",
-    "test:watch": "bun test --timeout 20000 --watch tests/",
-    "test:evals": "bun test --timeout 20000 tests/evals/",
+    "test:watch": "bun test --timeout 60000 --parallel --watch tests/",
+    "test:evals": "bun test --timeout 60000 --parallel tests/evals/",
     "build": "tsc -p tsconfig.build.json",
-    "ci": "bun run typecheck && bun run test",
+    "ci": "bun run src/ci.ts",
     "install:visual-server": "npm --prefix src/visual/scripts ci --ignore-scripts --no-audit --no-fund",
     "postinstall": "bun run install:visual-server",
     "prepare": "git config core.hooksPath hooks || true",
     "dev-install": "bun run bin/dev-install.ts"
   },
   "engines": {
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.13"
   },
   "keywords": [
     "omp",
@@ -65,7 +66,7 @@
     ]
   },
   "dependencies": {
-    "@clack/prompts": "^0.10.0",
+    "@clack/prompts": "^1.4.0",
     "handlebars": "^4.7.8",
     "yaml": "^2.8.3",
     "zod": "^4.3.0"
@@ -90,8 +91,8 @@
     "@oh-my-pi/pi-ai": "latest",
     "@oh-my-pi/pi-coding-agent": "latest",
     "@oh-my-pi/pi-tui": "latest",
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.8.0",
     "bun-types": "^1.3.11",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   }
 }

package/skills/context-mode/SKILL.md

@@ -63,7 +63,7 @@ When OMP's `shellMinimizer` is active, large bash output ends with a `[raw outpu
 
 ### Read
 
-Reads are never blocked — OMP's native open/read tool preserves hashline anchors (e.g., `120th|content` after 14.4.1) for the edit contract. Large reads (>110 lines) are auto-compressed to head (80) + tail (30) with a `sel` hint.
+Reads are never blocked — OMP's native open/read tool preserves hashline anchors (e.g., `120th|content` after 14.4.1) for the edit contract. Copy edit anchors exactly, without the `|content` body, and never fabricate anchors. Edit payload lines must start with `~` immediately followed by intended file content; avoid a readability space after `~` unless that space is intentional file content. Large reads (>110 lines) are auto-compressed to head (80) + tail (30) with a `sel` hint.
 
 For analysis-only reads where anchors are not needed, prefer `ctx_execute_file(path, language, code)` — only your printed summary enters context.
 

package/src/bootstrap.ts

@@ -12,6 +12,7 @@ import { registerAiReviewCommand, handleAiReview } from "./commands/ai-review.js
 import { registerQaCommand } from "./commands/qa.js";
 import { registerReleaseCommand, handleRelease } from "./commands/release.js";
 import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
+import { execCli } from "./utils/exec-cli.js";
 import { registerDoctorCommand, handleDoctor } from "./commands/doctor.js";
 import { registerModelCommand, handleModel } from "./commands/model.js";
 import { registerFixPrCommand } from "./commands/fix-pr.js";
@@ -175,7 +176,7 @@ export function bootstrap(platform: Platform): void {
     const currentVersion = getInstalledVersion(platform);
     if (!currentVersion) return;
 
-    platform.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() })
+    execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["view", "supipowers", "version"], { cwd: tmpdir() })
       .then((result) => {
         if (result.code !== 0) return;
         const latest = result.stdout.trim();

package/src/ci.ts

@@ -0,0 +1,47 @@
+export type CiProfile = "default" | "windows-fast";
+
+export interface CiCommand {
+  label: string;
+  args: string[];
+}
+
+export function resolveCiProfile(value: string | undefined): CiProfile {
+  if (value === undefined || value === "" || value === "default") return "default";
+  if (value === "windows-fast") return "windows-fast";
+  throw new Error(`Unsupported SUPIPOWERS_CI_PROFILE: ${value}`);
+}
+
+export function getCiPlan(profile: CiProfile): CiCommand[] {
+  const typecheck = { label: "Typecheck", args: ["bun", "run", "typecheck"] };
+  if (profile === "windows-fast") {
+    return [
+      typecheck,
+      { label: "Windows portability tests", args: ["bun", "run", "test:windows"] },
+    ];
+  }
+
+  return [
+    typecheck,
+    { label: "Test", args: ["bun", "run", "test"] },
+  ];
+}
+
+export function runCi(profileValue: string | undefined = process.env.SUPIPOWERS_CI_PROFILE): number {
+  const profile = resolveCiProfile(profileValue);
+  for (const command of getCiPlan(profile)) {
+    console.log(`\n> ${command.label}`);
+    const result = Bun.spawnSync({
+      cmd: command.args,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: process.env,
+    });
+    if (!result.success) return result.exitCode;
+  }
+  return 0;
+}
+
+if (import.meta.main) {
+  process.exitCode = runCi();
+}

package/src/commands/doctor.ts

@@ -11,6 +11,7 @@ import { formatReliabilitySection, loadReliabilitySummaries } from "../storage/r
 import { getMetricsStore, getSessionId } from "../context-mode/hooks.js";
 import { getProjectStatePath, getProjectStateDir } from "../workspace/state-paths.js";
 import { basename } from "node:path";
+import { execCli } from "../utils/exec-cli.js";
 
 export interface CheckResult {
   name: string;
@@ -435,14 +436,14 @@ export function checkMetrics(
 
 export async function checkNpm(platform: Platform): Promise<CheckResult> {
   try {
-    const vResult = await platform.exec("npm", ["--version"]);
+    const vResult = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["--version"]);
     if (vResult.code !== 0) {
       return { name: "npm", presence: { ok: false, detail: "npm not found" } };
     }
     const version = vResult.stdout.trim();
     const presence = { ok: true, detail: `v${version}` };
 
-    const pingResult = await platform.exec("npm", ["ping"]);
+    const pingResult = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["ping"]);
     if (pingResult.code === 0) {
       return { name: "npm", presence, functional: { ok: true, detail: "Registry reachable" } };
     }
@@ -501,6 +502,7 @@ export function getDoctorRecommendations(): string[] {
   return [
     "Set `tools.elideFileMutationInputs: true` (OMP ≥14.7.0) — elides `write`/`edit`/`apply_patch` payloads from history after success. Saves significant context on long sessions like `/supi:ultraplan execute` and `/supi:harness implement`.",
     "Update to OMP ≥14.7.2 — fixes the `Working…` spinner staying active after read-only commands such as `/supi:status`, `/supi:doctor`, `/supi:context`, and `/supi:clear`. (oh-my-pi#927)",
+    "Use OMP ≥15.1.7 for best reliability — includes ACP fixes for command-driven agent handoffs and permission prompts, plus accurate provider-scoped `/fast` status-line indicators.",
   ];
 }
 

package/src/commands/memory.ts

@@ -6,17 +6,33 @@ import {
   snapshotMempalaceInstall,
   steerMempalaceInitialization,
 } from "../mempalace/installer-helper.js";
+import {
+  getMempalacePostCommitHookStatus,
+  installMempalacePostCommitHook,
+  uninstallMempalacePostCommitHook,
+  type MempalacePostCommitHookStatusResult,
+} from "../mempalace/git-hook.js";
 
 const SUBCOMMANDS = [
   { name: "status", description: "Show palace path, managed venv, and install status" },
   { name: "setup", description: "Install or repair the managed Python environment and MemPalace package" },
+  { name: "git-hook", description: "Manage the opt-in post-commit MemPalace reindex hook" },
+] as const;
+
+const GIT_HOOK_ACTIONS = [
+  { name: "status", description: "Show post-commit reindex hook status" },
+  { name: "install", description: "Install or update the post-commit reindex hook" },
+  { name: "uninstall", description: "Remove the managed hook and restore a chained user hook" },
 ] as const;
 
 const HELP = [
   "/supi:memory — native MemPalace integration",
   "",
   "Subcommands:",
-  ...SUBCOMMANDS.map((subcommand) => `  ${subcommand.name.padEnd(8)} ${subcommand.description}`),
+  ...SUBCOMMANDS.map((subcommand) => `  ${subcommand.name.padEnd(10)} ${subcommand.description}`),
+  "",
+  "Git hook:",
+  "  git-hook status|install|uninstall",
   "",
   "Memory APIs are exposed to the agent via the `mempalace` tool.",
 ].join("\n");
@@ -43,6 +59,80 @@ function statusReport(platform: Platform, cwd: string): string {
   return lines.join("\n");
 }
 
+function gitHookStatusReport(result: MempalacePostCommitHookStatusResult): string {
+  if (!result.ok) {
+    return [
+      "/supi:memory git-hook status",
+      "",
+      `status: unavailable (${result.code})`,
+      result.message,
+    ].join("\n");
+  }
+
+  return [
+    "/supi:memory git-hook status",
+    "",
+    `repo root: ${result.repoRoot}`,
+    `hooks dir: ${result.hooksDir}`,
+    `core.hooksPath: ${result.coreHooksPath ?? "(default .git/hooks)"}`,
+    `post-commit hook: ${result.installed ? "present" : "missing"}`,
+    `managed by supipowers: ${result.managed}`,
+    `chained user hook: ${result.userHookPresent ? result.userHookPath : "none"}`,
+    `reindex runner: ${result.runnerPresent ? result.runnerPath : `${result.runnerPath} (missing)`}`,
+  ].join("\n");
+}
+
+async function handleGitHook(platform: Platform, ctx: PlatformContext, action: string): Promise<void> {
+  const config = loadConfig(platform.paths, ctx.cwd);
+  const command = action || "status";
+
+  if (command === "status") {
+    const status = await getMempalacePostCommitHookStatus({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    ctx.ui.notify(gitHookStatusReport(status), status.ok ? "info" : "warning");
+    return;
+  }
+
+  if (command === "install") {
+    const result = await installMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (result.ok) {
+      ctx.ui.notify(
+        `MemPalace post-commit reindex hook ${result.action}: ${result.hookPath}`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`MemPalace post-commit hook install failed (${result.code}): ${result.message}`, "warning");
+    }
+    return;
+  }
+
+  if (command === "uninstall") {
+    const result = await uninstallMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (result.ok) {
+      ctx.ui.notify(`MemPalace post-commit reindex hook ${result.action}.`, "info");
+    } else {
+      ctx.ui.notify(`MemPalace post-commit hook uninstall failed (${result.code}): ${result.message}`, "warning");
+    }
+    return;
+  }
+
+  ctx.ui.notify(`Unknown /supi:memory git-hook action: ${command}\n\n${HELP}`, "warning");
+}
+
 async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void> {
   const config = loadConfig(platform.paths, ctx.cwd);
   if (!config.mempalace.enabled) {
@@ -105,6 +195,26 @@ async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void>
     "info",
   );
 
+
+  if (config.mempalace.hooks.postCommitReindex) {
+    const hookResult = await installMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (hookResult.ok) {
+      ctx.ui.notify(
+        `MemPalace post-commit reindex hook ${hookResult.action}: ${hookResult.hookPath}`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(
+        `MemPalace setup completed, but post-commit hook install failed (${hookResult.code}): ${hookResult.message}`,
+        "warning",
+      );
+    }
+  }
   // Check if the current project's wing is already initialized; if not, steer
   // the model to run init + mine through the mempalace tool.
   const initState = await checkMempalaceProjectInitialized({
@@ -141,8 +251,8 @@ async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void>
 export function handleMemory(platform: Platform, ctx: PlatformContext, args?: string): void {
   if (!ctx.hasUI) return;
 
-  const sub = (args ?? "").trim().split(/\s+/)[0] ?? "";
-
+  const parts = (args ?? "").trim().split(/\s+/).filter(Boolean);
+  const sub = parts[0] ?? "";
   if (sub === "" || sub === "help" || sub === "--help" || sub === "-h") {
     ctx.ui.notify(HELP, "info");
     return;
@@ -168,14 +278,37 @@ export function handleMemory(platform: Platform, ctx: PlatformContext, args?: st
     return;
   }
 
+  if (sub === "git-hook") {
+    void (async () => {
+      try {
+        await handleGitHook(platform, ctx, parts[1] ?? "status");
+      } catch (err) {
+        ctx.ui.notify(`MemPalace git-hook command crashed: ${(err as Error).message}`, "error");
+      }
+    })();
+    return;
+  }
+
   ctx.ui.notify(`Unknown /supi:memory subcommand: ${sub}\n\n${HELP}`, "warning");
 }
 
 export function registerMemoryCommand(platform: Platform): void {
   platform.registerCommand("supi:memory", {
-    description: "Manage native MemPalace integration (status, setup)",
+    description: "Manage native MemPalace integration (status, setup, git-hook)",
     getArgumentCompletions(prefix: string) {
-      const lower = prefix.trim().toLowerCase();
+      const rawLower = prefix.toLowerCase();
+      const lower = rawLower.trim();
+      if (rawLower.startsWith("git-hook ")) {
+        const actionPrefix = rawLower.slice("git-hook ".length).trimStart();
+        const matches = GIT_HOOK_ACTIONS
+          .filter((action) => action.name.startsWith(actionPrefix))
+          .map((action) => ({
+            value: `git-hook ${action.name} `,
+            label: action.name,
+            description: action.description,
+          }));
+        return matches.length > 0 ? matches : null;
+      }
       const matches = SUBCOMMANDS
         .filter((subcommand) => subcommand.name.startsWith(lower))
         .map((subcommand) => ({

package/src/commands/plan.ts

@@ -19,6 +19,7 @@ import { loadModelConfig } from "../config/model-config.js";
 import { getProjectStatePath } from "../workspace/state-paths.js";
 import { cancelPlanTracking, startPlanTracking } from "../planning/approval-flow.js";
 import { stopVisualServer } from "../visual/stop-server.js";
+import { execCli } from "../utils/exec-cli.js";
 
 modelRegistry.register({
   id: "plan",
@@ -111,7 +112,7 @@ export function registerPlanCommand(platform: Platform): void {
             const nodeModules = path.join(scriptsDir, "node_modules");
             if (!fs.existsSync(nodeModules)) {
               notifyInfo(ctx, "Installing visual companion dependencies...");
-              const installResult = await platform.exec("npm", ["install", "--production"], { cwd: scriptsDir });
+              const installResult = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["install", "--production"], { cwd: scriptsDir });
               if (installResult.code !== 0) {
                 notifyError(ctx, "Failed to install visual companion dependencies", installResult.stderr);
                 debugLogger.log("visual_companion_dependency_install_failed", {

package/src/commands/update.ts

@@ -11,6 +11,7 @@ import {
   steerMempalaceInitialization,
 } from "../mempalace/installer-helper.js";
 import { loadConfig } from "../config/loader.js";
+import { execCli, wrapExecForCli } from "../utils/exec-cli.js";
 
 // ── Options builder ──────────────────────────────────────
 
@@ -59,7 +60,7 @@ async function updateSupipowers(
   ctx.ui.notify(`Current version: v${currentVersion}`, "info");
 
   // Check latest version on npm
-  const checkResult = await platform.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() });
+  const checkResult = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["view", "supipowers", "version"], { cwd: tmpdir() });
   if (checkResult.code !== 0) {
     ctx.ui.notify("Failed to check for updates — npm view failed", "error");
     return null;
@@ -78,7 +79,8 @@ async function updateSupipowers(
   mkdirSync(tempDir, { recursive: true });
 
   try {
-    const installResult = await platform.exec(
+    const installResult = await execCli(
+      (cmd, args, opts) => platform.exec(cmd, args, opts),
       "npm", ["install", "--prefix", tempDir, `supipowers@${latestVersion}`],
       { cwd: tempDir },
     );
@@ -130,10 +132,10 @@ async function updateSupipowers(
     // Install runtime dependencies (handlebars, etc.)
     // Without this, the extension fails to load because node_modules/ was deleted above.
     ctx.ui.notify("Installing dependencies...", "info");
-    const bunInstall = await platform.exec("bun", ["install", "--production"], { cwd: extDir });
+    const bunInstall = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "bun", ["install", "--production"], { cwd: extDir });
     if (bunInstall.code !== 0) {
       // Fallback to npm if bun is not available (e.g. Windows without global bun)
-      const npmInstall = await platform.exec("npm", ["install", "--omit=dev"], { cwd: extDir });
+      const npmInstall = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npm", ["install", "--omit=dev"], { cwd: extDir });
       if (npmInstall.code !== 0) {
         ctx.ui.notify(
           "Could not install extension dependencies.\n" +
@@ -177,7 +179,7 @@ async function updateSupipowers(
 
 export function handleUpdate(platform: Platform, ctx: PlatformContext): void {
   void (async () => {
-    const exec = (cmd: string, args: string[]) => platform.exec(cmd, args);
+    const exec = wrapExecForCli((cmd: string, args: string[]) => platform.exec(cmd, args));
 
     // 1. Scan all dependencies
     const allStatuses = await scanAll(exec);

package/src/config/defaults.ts

@@ -74,9 +74,11 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
     hooks: {
       wakeUp: true,
       searchGuidance: true,
+      writeGuidance: true,
       autoSearchOnPrompt: true,
       compactionCheckpoint: true,
       shutdownDiary: true,
+      postCommitReindex: false,
     },
     budgets: {
       wakeUpTokens: 1200,

package/src/config/schema.ts

@@ -109,9 +109,11 @@ export const ConfigSchema = z.object(
           {
             wakeUp: z.boolean(),
             searchGuidance: z.boolean(),
+            writeGuidance: z.boolean(),
             autoSearchOnPrompt: z.boolean(),
             compactionCheckpoint: z.boolean(),
             shutdownDiary: z.boolean(),
+            postCommitReindex: z.boolean(),
           },
         ).strict(),
         budgets: z.object(

package/src/context-mode/sandbox/executor.ts

@@ -20,6 +20,31 @@ export interface ExecuteResult {
 
 const DEFAULT_TIMEOUT = 30_000;
 
+const MISSING_BASH_EXIT_CODE = 127;
+function buildMissingBashMessage(platform: NodeJS.Platform): string {
+  const base = "bash is required to execute shell snippets.";
+  switch (platform) {
+    case "win32":
+      return `${base} Install Git for Windows or WSL, then retry.`;
+    case "darwin":
+      return `${base} Install bash via Homebrew (\`brew install bash\`) or Xcode Command Line Tools, then retry.`;
+    case "linux":
+      return `${base} Install bash via your distro's package manager (apt/yum/pacman), then retry.`;
+    default:
+      return `${base} Install bash for your platform and retry.`;
+  }
+}
+const MISSING_BASH_MESSAGE = buildMissingBashMessage(process.platform);
+
+function missingBashResult(startedAt: number): ExecuteResult {
+  return {
+    stdout: "",
+    stderr: MISSING_BASH_MESSAGE,
+    exitCode: MISSING_BASH_EXIT_CODE,
+    duration: performance.now() - startedAt,
+  };
+}
+
 export async function executeCode(
   language: string,
   code: string,
@@ -29,6 +54,11 @@ export async function executeCode(
   const opts = options ?? {};
   const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
   const cwd = opts.cwd ?? process.cwd();
+  const start = performance.now();
+
+  if (language === "shell" && Bun.which("bash") === null) {
+    return missingBashResult(start);
+  }
 
   const id = randomUUID();
   const srcPath = path.join(os.tmpdir(), `ctx-exec-${id}${runner.fileExt}`);
@@ -37,7 +67,6 @@ export async function executeCode(
     : undefined;
 
   fs.writeFileSync(srcPath, code);
-  const start = performance.now();
 
   try {
     // Compile step for compiled languages

package/src/fix-pr/scripts/exec.ts

@@ -2,6 +2,35 @@ import { spawnSync } from "node:child_process";
 import type { ExecOptions, ExecResult, Platform } from "../../platform/types.js";
 import { findExecutable } from "../../utils/executable.js";
 
+export interface CliInvocation {
+  cmd: string;
+  args: string[];
+}
+
+function quoteCmdArgument(arg: string): string {
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+export function buildCliInvocation(
+  resolvedCommand: string,
+  args: string[],
+  platform: NodeJS.Platform = process.platform,
+): CliInvocation {
+  if (platform === "win32" && /\.(cmd|bat)$/i.test(resolvedCommand)) {
+    return {
+      cmd: "cmd.exe",
+      args: [
+        "/d",
+        "/s",
+        "/c",
+        `"${[resolvedCommand, ...args].map(quoteCmdArgument).join(" ")}"`,
+      ],
+    };
+  }
+
+  return { cmd: resolvedCommand, args };
+}
+
 export function runCliCommand(
   command: string,
   args: string[],
@@ -13,7 +42,9 @@ export function runCliCommand(
     pathext: env.PATHEXT,
   }) ?? command;
 
-  const result = spawnSync(resolvedCommand, args, {
+  const invocation = buildCliInvocation(resolvedCommand, args);
+
+  const result = spawnSync(invocation.cmd, invocation.args, {
     cwd: options?.cwd,
     env,
     encoding: "utf8",

package/src/harness/anti_slop/fallow-adapter.ts

@@ -25,6 +25,7 @@ import {
   type SlopBackendResult,
   type SlopFinding,
 } from "./backend.js";
+import { execCli } from "../../utils/exec-cli.js";
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
@@ -149,7 +150,7 @@ async function resolveInvocation(
   }
 
   try {
-    const probe = await platform.exec("npx", ["--no-install", "fallow", "--version"], { timeout: 5000 });
+    const probe = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npx", ["--no-install", "fallow", "--version"], { timeout: 5000 });
     if (probe.code === 0) {
       availabilityCache = { ok: true, via: "npx" };
       return { ok: true, cmd: "npx", baseArgs: ["--no-install", "fallow"], via: "npx" };
@@ -187,7 +188,7 @@ async function runFallow(
   const startedAt = Date.now();
   let result;
   try {
-    result = await platform.exec(invocation.cmd, args, {
+    result = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), invocation.cmd, args, {
       cwd: opts.cwd,
       timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     });
@@ -269,7 +270,7 @@ export class FallowAdapter implements SlopBackend {
     if (opts.subtree) args.push("--path", opts.subtree);
 
     try {
-      const result = await platform.exec(invocation.cmd, args, {
+      const result = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), invocation.cmd, args, {
         cwd: opts.cwd,
         timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       });

package/src/harness/command.ts

@@ -45,7 +45,6 @@ import {
 import { computeScore } from "./anti_slop/score.js";
 import {
   type BuildRunnerInput,
-  type HarnessPipelineProgressEvent,
   type PipelineRunOutcome,
   HARNESS_STAGE_ORDER,
   runHarnessPipelineUntilGate,
@@ -58,7 +57,7 @@ import { DEFAULT_HARNESS_CONFIG } from "./hooks/register.js";
 import { handlePrComment } from "./pr-comment/handler.js";
 import { runGitVerificationQa } from "./git-verify-qa.js";
 import { getHarnessSessionDir } from "./project-paths.js";
-import type { HarnessDesignSpec, HarnessGateMode, HarnessSession, HarnessStage } from "../types.js";
+import type { HarnessDesignSpec, HarnessGateMode, HarnessPipelineProgressEvent, HarnessSession, HarnessStage } from "../types.js";
 
 modelRegistry.register({
   id: "harness",
@@ -133,9 +132,11 @@ function createHarnessProgress(ctx: HarnessCommandContext) {
   let done = 0;
   let cur: HarnessStage | null = null;
   const completed: string[] = [];
+  let liveDetail: string | null = null;
 
   function refresh() {
-    const label = cur ? HARNESS_STAGE_LABELS[cur] : "Complete";
+    const baseLabel = cur ? HARNESS_STAGE_LABELS[cur] : "Complete";
+    const label = cur && liveDetail ? `${baseLabel} — ${liveDetail}` : baseLabel;
     const spinner = cur ? "\u25cc" : "\u2713";
     (ctx.ui as any).setStatus?.("supi-harness", `  ${spinner} harness: ${label} (${done}/${SO.length})`);
   }
@@ -147,22 +148,26 @@ function createHarnessProgress(ctx: HarnessCommandContext) {
         case "stage-started":
           cur = event.stage;
           break;
+        case "stage-progress":
+          cur = event.stage;
+          liveDetail = event.detail;
+          break;
         case "stage-completed": {
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           const mark = "\u2713";
           completed.push(`${mark} ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "done"}`);
           break;
         }
         case "stage-skipped":
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           completed.push(`\u2013 ${HARNESS_STAGE_LABELS[event.stage]}: skipped`);
           break;
         case "awaiting-user":
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           completed.push(`\u25cb ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "awaiting review"}`);
           break;
         case "stage-failed": case "stage-blocked":
-          cur = null;
+          cur = null; liveDetail = null;
           completed.push(`\u2717 ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "failed"}`);
           break;
       }