pi-ui-extend 1.0.46 → 1.0.47

package/README.md

@@ -512,10 +512,21 @@ Pix implements the Pi extension UI surface for notifications, keyed toasts, widg
 
 ## Development
 
+Use the exact Node.js version in `.node-version` for development and builds;
+`.nvmrc` mirrors it for nvm users. No particular version manager is required:
+all npm scripts use the `node` and `npm` already on your `PATH`.
+The supported runtime range is `>=22.19.0 <25`, shared by Pix, ACP, and Desktop.
+CI checks the pinned version on Linux, macOS, and Windows, plus the minimum
+supported version on Linux.
+
 ```bash
 git clone https://github.com/dnaroid/pix.git
 cd pix
-npm install
+
+# Select the version from .node-version using your preferred installation method.
+# With nvm (optional): nvm install && nvm use
+node --version
+npm ci
 
 # Run from source
 npm run dev -- --cwd /path/to/project

package/bin/pix.mjs

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const minimumNodeVersion = [22, 19, 0];
-const minimumNodeVersionLabel = "22.19.0";
+const supportedNodeRange = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).engines.node;
 const launcherPath = fileURLToPath(import.meta.url);
 const packageRoot = dirname(dirname(launcherPath));
 const mainPath = fileURLToPath(new URL("../dist/main.js", import.meta.url));
@@ -13,8 +12,8 @@ const installPath = fileURLToPath(new URL("../dist/app/cli/install.js", import.m
 const cliArgs = process.argv.slice(2);
 
 if (!isCurrentNodeSupported()) {
-	console.error(`[pix] Node ${minimumNodeVersionLabel}+ is required; current Node is ${process.versions.node}.`);
-	console.error("[pix] Install/use a newer Node, for example `mise install node@22.19.0` or `nvm install 22`.");
+	console.error(`[pix] Node ${supportedNodeRange} is required; current Node is ${process.versions.node}.`);
+	console.error("[pix] Install a supported Node.js release and ensure node and npm use it on PATH.");
 	process.exit(1);
 }
 
@@ -45,9 +44,15 @@ if (!existsSync(mainPath)) {
 await import(new URL("../dist/main.js", import.meta.url));
 
 function isCurrentNodeSupported() {
-	const parts = process.versions.node.split(".").map((part) => Number.parseInt(part, 10));
+	// Only the project's bounded stable range is accepted; fail closed if its format changes.
+	const range = /^>=(\d+)\.(\d+)\.(\d+) <(\d+)$/u.exec(supportedNodeRange);
+	const version = /^(\d+)\.(\d+)\.(\d+)$/u.exec(process.versions.node);
+	if (!range || !version) return false;
+	const minimumNodeVersion = range.slice(1, 4).map(Number);
+	const parts = version.slice(1).map(Number);
+	if (parts[0] >= Number(range[4])) return false;
 	for (let index = 0; index < minimumNodeVersion.length; index += 1) {
-		const current = parts[index] ?? 0;
+		const current = parts[index];
 		const minimum = minimumNodeVersion[index];
 		if (current > minimum) return true;
 		if (current < minimum) return false;

package/dist/app/app.d.ts

@@ -80,6 +80,7 @@ export declare class PiUiExtendApp {
     private selectDraftModel;
     private draftModelState;
     private draftModelStatus;
+    private draftModelUsageSelection;
     private applyPixConfig;
     private updateOutputFilters;
     start(): Promise<void>;

package/dist/app/app.js

@@ -185,6 +185,7 @@ export class PiUiExtendApp {
         });
         this.modelUsageController = new AppModelUsageController({
             runtimeSession: () => this.runtime?.session,
+            draftSelection: () => this.draftModelUsageSelection(),
             render: () => this.render(),
         });
         this.tabsController = new AppTabsController({
@@ -948,6 +949,7 @@ export class PiUiExtendApp {
         this.draftModelRef = ref;
         this.draftThinkingLevel = thinkingLevel;
         this.draftModelOverrideRef = `${ref}:${thinkingLevel}`;
+        this.modelUsageController.observeSession(undefined);
         this.setStatus("new conversation");
     }
     draftModelState() {
@@ -965,6 +967,13 @@ export class PiUiExtendApp {
             return undefined;
         return { modelLabel: state.modelRef, thinkingLabel: state.thinkingLevel };
     }
+    draftModelUsageSelection() {
+        const state = this.draftModelState();
+        if (!state?.modelRef)
+            return undefined;
+        const model = state.models.find((candidate) => `${candidate.provider}/${candidate.id}` === state.modelRef);
+        return model ? { model, thinkingLevel: state.thinkingLevel } : undefined;
+    }
     applyPixConfig(config) {
         replaceRecord(this.pixConfig.toolRenderer, config.toolRenderer);
         replaceRecord(this.pixConfig.outputFilters, config.outputFilters);

package/dist/app/commands/command-model-actions.js

@@ -384,10 +384,8 @@ export class ModelCommandActions {
         });
     }
     saveDefaultThinking(level) {
-        const runtime = getRuntime(this.host, "default-thinking");
-        if (!runtime)
-            return;
-        const fallbackModelRef = runtime.session.model ? this.host.modelRef(runtime.session.model) : undefined;
+        const runtime = this.host.runtime();
+        const fallbackModelRef = runtime?.session.model ? this.host.modelRef(runtime.session.model) : undefined;
         const saved = savePixDefaultThinking(level, fallbackModelRef);
         if (!saved)
             throw new Error("Set /default-model first or select a session model before setting default thinking");
@@ -396,7 +394,7 @@ export class ModelCommandActions {
             kind: "system",
             text: `Default thinking level set to ${saved.thinking ?? level} for ${saved.modelRef}. New sessions will use it unless --model is provided.`,
         });
-        this.host.setSessionStatus(runtime.session);
+        this.host.setSessionStatus(runtime?.session);
     }
 }
 function formatDefaultModelRef(defaultModel) {

package/dist/app/model/model-usage-controller.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { SessionModel } from "../types.js";
 import { type ModelUsageDescriptor, type ModelUsageStatus } from "./model-usage-status.js";
 export type AppModelUsageQuery = (descriptor: ModelUsageDescriptor) => Promise<ModelUsageStatus | undefined>;
 export type ModelUsageRefreshResult = "refreshed" | "unavailable" | "failed";
@@ -12,6 +13,10 @@ export type ModelUsageRefreshStart = {
 };
 export type AppModelUsageControllerHost = {
     runtimeSession(): AgentSession | undefined;
+    draftSelection?(): {
+        model: SessionModel;
+        thinkingLevel: string;
+    } | undefined;
     render(): void;
 };
 export declare class AppModelUsageController {
@@ -32,4 +37,5 @@ export declare class AppModelUsageController {
     private refresh;
     private syncActiveModel;
     private activeStatus;
+    private activeDescriptor;
 }

package/dist/app/model/model-usage-controller.js

@@ -45,7 +45,7 @@ export class AppModelUsageController {
     refreshNow() {
         const session = this.host.runtimeSession();
         this.syncActiveModel(session);
-        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = this.activeDescriptor(session);
         if (!descriptor)
             return { kind: "unsupported" };
         const promise = this.refresh(true, descriptor);
@@ -54,7 +54,7 @@ export class AppModelUsageController {
     tick(force = false) {
         const session = this.host.runtimeSession();
         this.syncActiveModel(session);
-        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = this.activeDescriptor(session);
         if (!descriptor)
             return;
         const cacheKey = descriptorCacheKey(descriptor);
@@ -68,7 +68,7 @@ export class AppModelUsageController {
     }
     refresh(force = false, activeDescriptor) {
         const session = this.host.runtimeSession();
-        const descriptor = activeDescriptor ?? modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = activeDescriptor ?? this.activeDescriptor(session);
         if (!descriptor)
             return undefined;
         const modelKey = descriptorCacheKey(descriptor);
@@ -96,7 +96,7 @@ export class AppModelUsageController {
         });
     }
     syncActiveModel(session) {
-        const nextModelKey = descriptorCacheKey(modelUsageDescriptor(session?.model, session?.thinkingLevel));
+        const nextModelKey = descriptorCacheKey(this.activeDescriptor(session));
         if (nextModelKey === this.activeModelKey)
             return false;
         this.activeModelKey = nextModelKey;
@@ -106,4 +106,10 @@ export class AppModelUsageController {
     activeStatus() {
         return this.activeModelKey ? this.statuses.get(this.activeModelKey) : undefined;
     }
+    activeDescriptor(session) {
+        if (session)
+            return modelUsageDescriptor(session.model, session.thinkingLevel);
+        const draft = this.host.draftSelection?.();
+        return draft ? modelUsageDescriptor(draft.model, draft.thinkingLevel) : undefined;
+    }
 }

package/dist/bundled-extensions/question/tui.js

@@ -325,6 +325,30 @@ export async function runQuestionnaire(questions, ctx) {
             }
             showReview();
         }
+        function confirmMultipleAnswer() {
+            const question = currentQuestion();
+            if (!question.multiple)
+                return;
+            const selection = selections.get(question.id);
+            if (!selection || !selectionIsComplete(question, selection)) {
+                const existing = multipleSelection(question);
+                if (existing.customText !== undefined && !existing.customText.trim() && (existing.images?.length ?? 0) === 0) {
+                    customError = "Custom Answer cannot be empty.";
+                }
+                else {
+                    const minimum = question.minSelections ?? 1;
+                    customError = `Choose at least ${minimum} answer${minimum === 1 ? "" : "s"}.`;
+                }
+                refresh();
+                return;
+            }
+            customError = undefined;
+            if (questionIndex < questions.length - 1) {
+                moveToQuestion(questionIndex + 1);
+                return;
+            }
+            submitOrAnswerRemaining();
+        }
         function enterCustomMode() {
             const question = currentQuestion();
             const existing = selections.get(question.id);
@@ -410,7 +434,7 @@ export async function runQuestionnaire(questions, ctx) {
                 mode = "choices";
                 customError = undefined;
                 syncChoiceSelection();
-                refresh();
+                confirmMultipleAnswer();
                 return;
             }
             selections.set(question.id, {
@@ -558,7 +582,17 @@ export async function runQuestionnaire(questions, ctx) {
                 goBack();
                 return;
             }
-            if (isKey(data, "enter") || data === " ") {
+            if (currentQuestion().multiple) {
+                if (data === " ") {
+                    selectChoice(selectedChoiceIndex);
+                    return;
+                }
+                if (isKey(data, "enter")) {
+                    confirmMultipleAnswer();
+                    return;
+                }
+            }
+            else if (isKey(data, "enter") || data === " ") {
                 selectChoice(selectedChoiceIndex);
                 return;
             }

package/external/pi-tools-suite/src/dcp/compress-tool.ts

@@ -36,6 +36,7 @@ import {
 } from "./compression-preview.js"
 import { settleCompressionProgress } from "./compression-progress.js"
 import { estimateMessageTokens } from "./pruner-metadata.js"
+import { incompleteToolGroupGuidance } from "./protocol-closed-ranges.js"
 import {
   buildSummarySourceManifest,
   hashSummarySourceManifest,
@@ -190,7 +191,7 @@ function validateProtocolClosedRanges(plans: ResolvedRangeBoundaries[], state: D
     if (closure.incompleteToolGroup) {
       throw new Error(
         `Compression range ${plan.startId}..${plan.endId} intersects an incomplete tool group. ` +
-        "Wait until the complete assistant/tool-result group is present or choose another closed range.",
+        incompleteToolGroupGuidance(state.conversationIndexSnapshot, plan.startId, plan.endId),
       )
     }
     if (closure.expanded) {

package/external/pi-tools-suite/src/dcp/protocol-closed-ranges.ts

@@ -0,0 +1,90 @@
+import { closeConversationRange, detectToolGroupSpans } from "./conversation-index.js";
+import type { ConversationIndexEntry } from "./state.js";
+
+interface RangeBoundary {
+  id: string;
+  messageIndex: number;
+}
+
+function diagnosticId(id: string): string {
+  return id.length > 160 ? `${id.slice(0, 157)}...` : id;
+}
+
+/**
+ * Maximal closed runs inside an already policy-filtered selection. Incomplete
+ * groups are barriers, not reasons to discard all later completed work. Never
+ * widen across a retention boundary or an excluded message/block to close one.
+ */
+export function protocolClosedBoundaryRuns<T extends RangeBoundary>(
+  boundaries: T[],
+  entries: ConversationIndexEntry[],
+): T[][] {
+  if (boundaries.length === 0 || entries.length === 0) return [];
+  const first = boundaries[0]!.messageIndex;
+  const last = boundaries[boundaries.length - 1]!.messageIndex;
+  const included = new Set(boundaries.map((boundary) => boundary.messageIndex));
+  const excluded = new Set(entries.filter((entry) =>
+    entry.index >= first && entry.index <= last && !included.has(entry.index) &&
+    !entry.passthrough && entry.origin !== "dcp-control",
+  ).map((entry) => entry.index));
+  const barriers = [...excluded].map((index) => ({ startIndex: index, endIndex: index }));
+  for (const group of detectToolGroupSpans(entries)) {
+    if (group.endIndex < first || group.startIndex > last) continue;
+    if (!group.complete || group.startIndex < first || group.endIndex > last ||
+      entries.slice(group.startIndex, group.endIndex + 1).some((entry) => excluded.has(entry.index))) {
+      barriers.push(group);
+    }
+  }
+  barriers.sort((a, b) => a.startIndex - b.startIndex);
+
+  const runs: T[][] = [];
+  let cursor = 0;
+  for (const barrier of barriers) {
+    const start = cursor;
+    while (cursor < boundaries.length && boundaries[cursor]!.messageIndex < barrier.startIndex) cursor++;
+    if (cursor > start) runs.push(boundaries.slice(start, cursor));
+    while (cursor < boundaries.length && boundaries[cursor]!.messageIndex <= barrier.endIndex) cursor++;
+  }
+  if (cursor < boundaries.length) runs.push(boundaries.slice(cursor));
+
+  // Use the executor's closure authority, including non-addressable entries.
+  return runs.filter((run) => {
+    const closure = closeConversationRange(entries, run[0]!.id, run[run.length - 1]!.id);
+    return closure && !closure.expanded && !closure.incompleteToolGroup;
+  });
+}
+
+/** Bounded recovery guidance for stale/manual selections; never changes them. */
+export function incompleteToolGroupGuidance(
+  entries: ConversationIndexEntry[],
+  startId: string,
+  endId: string,
+): string {
+  const closure = closeConversationRange(entries, startId, endId);
+  if (!closure) return "Choose another protocol-closed range.";
+  const blockers = detectToolGroupSpans(entries).filter((group) =>
+    !group.complete && group.startIndex <= closure.endIndex && group.endIndex >= closure.startIndex,
+  );
+  const details = blockers.slice(0, 3).map((group) => {
+    const assistant = entries[group.startIndex]!;
+    const results = new Set(entries.slice(group.startIndex + 1, group.endIndex + 1)
+      .filter((entry) => entry.role === "toolResult" || entry.role === "bashExecution")
+      .map((entry) => entry.toolCallId));
+    const missing = group.toolCallIds.filter((id) => !results.has(id));
+    return `${diagnosticId(assistant.visibleId ?? assistant.stableId)} (missing tool result: ${missing.slice(0, 3).map(diagnosticId).join(", ")}${missing.length > 3 ? ", …" : ""})`;
+  });
+  const boundaries = entries.flatMap((entry) => {
+    if (entry.index < closure.requestedStartIndex || entry.index > closure.requestedEndIndex ||
+      entry.passthrough || entry.origin === "dcp-control") return [];
+    const id = entry.blockId !== undefined ? `b${entry.blockId}` : entry.visibleId;
+    return id ? [{ id, messageIndex: entry.index }] : [];
+  });
+  const alternatives = protocolClosedBoundaryRuns(boundaries, entries);
+  const hints = alternatives.slice(0, 3).map((run) => `${run[0]!.id}..${run[run.length - 1]!.id}`);
+  return `Blocking group(s): ${details.join("; ")}${blockers.length > 3 ? "; …" : ""}. ` +
+    (hints.length > 0
+      ? `Protocol-safe alternatives inside this selection: ${hints.join(", ")}${alternatives.length > 3 ? ", …" : ""}. `
+      : "No protocol-closed subrange is available inside this selection. ") +
+    "Choose a closed range or message-mode candidates outside the blocked groups. " +
+    "Changing only an endId beyond a blocked group will not help; wait only if its tool is actually still running.";
+}

package/external/pi-tools-suite/src/dcp/pruner-candidates.ts

@@ -5,7 +5,8 @@ import {
   estimateMessageTokens,
 } from "./pruner-metadata.js";
 import { stableMessageKeys } from "./pruner-message-ids.js";
-import { detectToolGroupSpans, findConversationIndexEntry } from "./conversation-index.js";
+import { closeConversationRange, detectToolGroupSpans, findConversationIndexEntry } from "./conversation-index.js";
+import { protocolClosedBoundaryRuns } from "./protocol-closed-ranges.js";
 
 interface CandidateBoundary {
   id: string;
@@ -120,58 +121,39 @@ function selectOldestSafePrefix(
   maxSafeMessageIndex: number,
   options?: CompressionCandidateSelectionOptions,
 ): CandidateBoundary[] | null {
-  if (boundaries.length === 0) return null;
-  if (!options || options.requiredSavingsTokens === undefined) {
-    let full = boundaries.slice();
-    while (full.length > 0 && full[0]!.isSystemReminder) full = full.slice(1);
-    while (full.length > 0 && full[full.length - 1]!.isSystemReminder) full = full.slice(0, -1);
-    if (full.length < Math.max(1, settings.minMessages)) return null;
-    if (full.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) return null;
-    return full;
-  }
-  const requiredSavings = Math.max(0, Math.floor(options.requiredSavingsTokens));
+  const requiredSavings = Math.max(0, Math.floor(options?.requiredSavingsTokens ?? 0));
   const estimatorMargin = Math.max(0, Math.floor(options?.estimatorMarginTokens ?? 0));
   const targetSourceTokens = Math.max(settings.minTokens, requiredSavings + estimatorMargin);
   const minMessages = Math.max(1, settings.minMessages);
-
-  let selectedEnd = -1;
-  let selectedTokens = 0;
-  for (let index = 0; index < boundaries.length; index++) {
-    selectedTokens += boundaries[index]!.tokenEstimate;
-    if (index + 1 >= minMessages && selectedTokens >= targetSourceTokens) {
-      selectedEnd = index;
-      break;
-    }
-  }
-  if (selectedEnd < 0) selectedEnd = boundaries.length - 1;
-
-  let selected = boundaries.slice(0, selectedEnd + 1);
-  if (state.conversationIndexSnapshot.length > 0) {
-    const groups = detectToolGroupSpans(state.conversationIndexSnapshot);
-    const startMessageIndex = selected[0]!.messageIndex;
-    let endMessageIndex = selected[selected.length - 1]!.messageIndex;
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const group of groups) {
-        const overlaps = group.startIndex <= endMessageIndex && group.endIndex >= startMessageIndex;
-        if (!overlaps) continue;
-        if (!group.complete) return null;
-        if (group.endIndex > endMessageIndex) {
-          if (group.endIndex > maxSafeMessageIndex) return null;
-          endMessageIndex = group.endIndex;
-          changed = true;
+  const eligible = boundaries.filter((boundary) => boundary.messageIndex <= maxSafeMessageIndex);
+  while (eligible[0]?.isSystemReminder) eligible.shift();
+  while (eligible[eligible.length - 1]?.isSystemReminder) eligible.pop();
+
+  for (const run of protocolClosedBoundaryRuns(eligible, state.conversationIndexSnapshot)) {
+    while (run[0]?.isSystemReminder) run.shift();
+    while (run[run.length - 1]?.isSystemReminder) run.pop();
+    if (run.length === 0) continue;
+    let selectedEnd = run.length - 1;
+    if (options?.requiredSavingsTokens !== undefined) {
+      let selectedTokens = 0;
+      for (let index = 0; index < run.length; index++) {
+        selectedTokens += run[index]!.tokenEstimate;
+        if (index + 1 >= minMessages && selectedTokens >= targetSourceTokens) {
+          selectedEnd = index;
+          break;
         }
       }
     }
-    selected = boundaries.filter((boundary) => boundary.messageIndex <= endMessageIndex);
+    const closure = closeConversationRange(state.conversationIndexSnapshot, run[0]!.id, run[selectedEnd]!.id);
+    if (!closure || closure.incompleteToolGroup || closure.startIndex !== run[0]!.messageIndex ||
+      closure.endIndex > run[run.length - 1]!.messageIndex) continue;
+    const selected = run.filter((boundary) => boundary.messageIndex <= closure.endIndex);
+    if (selected[selected.length - 1]!.messageIndex !== closure.endIndex) continue;
+    if (selected.length < minMessages) continue;
+    if (selected.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) continue;
+    return selected;
   }
-
-  while (selected.length > 0 && selected[0]!.isSystemReminder) selected = selected.slice(1);
-  while (selected.length > 0 && selected[selected.length - 1]!.isSystemReminder) selected = selected.slice(0, -1);
-  if (selected.length < minMessages) return null;
-  if (selected.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) return null;
-  return selected;
+  return null;
 }
 
 export function detectCompressionCandidate(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.46",
+  "version": "1.0.47",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {
@@ -48,19 +48,19 @@
   ],
   "scripts": {
     "predev": "npm run link:pix --silent",
-    "dev": "mise exec node@24.16.0 -- tsx src/main.ts",
-    "start": "mise exec node@24.16.0 -- tsx src/main.ts",
+    "dev": "tsx src/main.ts",
+    "start": "tsx src/main.ts",
     "prebuild:pix": "npm run generate-schemas --silent",
-    "build:pix": "mise exec node@24.16.0 -- tsc -p tsconfig.json",
+    "build:pix": "tsc -p tsconfig.json",
     "prelink:pix": "npm run build:pix --silent",
-    "link:pix": "mise exec node@24.16.0 -- npm link --silent",
-    "watch:pix": "npm run link:pix --silent && mise exec node@24.16.0 -- node scripts/watch-pix.mjs",
-    "watch:all": "mise exec node@24.16.0 -- node scripts/watch-all.mjs",
+    "link:pix": "npm link --silent",
+    "watch:pix": "npm run link:pix --silent && node scripts/watch-pix.mjs",
+    "watch:all": "node scripts/watch-all.mjs",
     "rebuild:all": "npm run build:desktop",
-    "check": "mise exec node@24.16.0 -- npm run check:inner",
+    "check": "npm run check:inner",
     "precheck:inner": "npm run generate-schemas --silent",
     "check:inner": "npm run sync:sdk-pin:check --silent && tsc --noEmit && npm run test:inner",
-    "test": "mise exec node@24.16.0 -- npm run test:inner",
+    "test": "npm run test:inner",
     "test:inner": "node --import tsx --test \"tests/**/*.test.ts\"",
     "test:tools-suite": "npm --prefix external/pi-tools-suite test",
     "test:dcp-session-sim": "npm --prefix external/pi-tools-suite run test:dcp-session-sim",
@@ -75,12 +75,12 @@
     "sync:pi-tools-suite:check": "node scripts/sync-pi-tools-suite.mjs --check",
     "sync:sdk-pin": "node scripts/sync-sdk-pin.mjs",
     "sync:sdk-pin:check": "node scripts/sync-sdk-pin.mjs --check",
-    "test:coverage": "mise exec node@24.16.0 -- node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=94 --test-coverage-branches=80 --test-coverage-functions=94 \"tests/**/*.test.ts\"",
-    "update-sdk-references": "mise exec node@24.16.0 -- node .pi/skills/pi-sdk/scripts/update-references.mjs",
+    "test:coverage": "node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=94 --test-coverage-branches=80 --test-coverage-functions=94 \"tests/**/*.test.ts\"",
+    "update-sdk-references": "node .pi/skills/pi-sdk/scripts/update-references.mjs",
     "prepack": "npm run generate-schemas --silent",
     "pack:dry-run": "npm pack --dry-run",
-    "smoke-test": "mise exec node@24.16.0 -- bash scripts/smoke-test-package.sh",
-    "smoke-test:cli": "mise exec node@24.16.0 -- node scripts/smoke-test-package-cli.mjs",
+    "smoke-test": "bash scripts/smoke-test-package.sh",
+    "smoke-test:cli": "node scripts/smoke-test-package-cli.mjs",
     "release:check": "npm run check && npm run build:pix && npm run pack:dry-run",
     "publish-npm": "bash scripts/publish.sh",
     "generate-schemas": "tsx scripts/generate-schemas.ts",