@ilya-lesikov/pi-pi 0.10.0 → 0.12.0

package/extensions/orchestrator/pp-state-tools.ts

@@ -138,7 +138,7 @@ function validateStateContent(taskDir: string, absolute: string, content: string
     const res = validatePlan(content);
     return res.ok
       ? { ok: true }
-      : { ok: false, errors: res.errors, hint: "Keep exactly: # Plan, ## Scope, ## Checklist (items need 'Done when:'), ## Blockers (optional)." };
+      : { ok: false, errors: res.errors, hint: "Keep exactly: # Plan, ## Scope, ## Checklist (items need 'Done when:'), ## Pattern constraints (optional), ## Blockers (optional)." };
   }
   return { ok: true };
 }

package/extensions/orchestrator/rate-limit-fallback-flow.test.ts

@@ -30,14 +30,14 @@ import { handleMainRateLimit, handleSubagentRateLimit } from "./rate-limit-fallb
 
 function makeOrchestrator() {
   return {
-    active: { state: { phase: "debug" } },
+    active: { state: { phase: "implement" } },
     activeTaskToken: 1,
     subFallbackActive: false,
     subFallbackDialogPending: false,
     subFallbackPendingDecision: false,
     subFallbackModelId: null as string | null,
     subSwitchBackTimer: null as any,
-    config: { agents: { orchestrators: { debug: { thinking: "high" }, implement: { thinking: "high" } } } },
+    config: { agents: { orchestrators: { implement: { thinking: "high" } } } },
     switchModel: vi.fn().mockResolvedValue(true),
     sendUserMessageWhenIdle: vi.fn(),
     cancelPendingRetry: vi.fn(),

package/extensions/orchestrator/rate-limit-fallback.ts

@@ -160,7 +160,7 @@ async function activateFallback(
 function currentThinking(orchestrator: Orchestrator): string {
   const phase = orchestrator.active?.state.phase;
   const orchestrators = orchestrator.config?.agents?.orchestrators as Record<string, { thinking?: string }> | undefined;
-  const key = phase === "debug" || phase === "brainstorm" || phase === "review" || phase === "quick" ? phase : "implement";
+  const key = phase === "brainstorm" || phase === "review" || phase === "quick" ? phase : "implement";
   return orchestrators?.[key]?.thinking ?? "high";
 }
 

package/extensions/orchestrator/state.test.ts

@@ -52,15 +52,6 @@ describe("createTask", () => {
     expect(raw.endsWith("\n")).toBe(true);
   });
 
-  it("uses debug as initial phase for debug", () => {
-    const cwd = makeCwd();
-    const taskDir = createTask(cwd, "debug", "Fix timeout issue");
-    const state = loadTask(taskDir);
-    expect(state.phase).toBe("debug");
-    expect(state.step).toBe("llm_work");
-    expect(state.reviewCycle).toBeNull();
-    expect(state.reviewPass).toBe(0);
-  });
 
   it("uses brainstorm as initial phase for brainstorm", () => {
     const cwd = makeCwd();
@@ -103,6 +94,16 @@ describe("loadTask", () => {
 
     expect(() => loadTask(taskDir)).toThrowError(/Failed to parse .*state\.json:/);
   });
+
+  it("throws for a legacy debug-phase task", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "implement", "Legacy debug");
+    const state = loadTask(taskDir);
+    (state as any).phase = "debug";
+    saveTask(taskDir, state);
+
+    expect(() => loadTask(taskDir)).toThrowError(/Debug tasks are no longer supported/);
+  });
 });
 
 describe("saveTask", () => {
@@ -134,18 +135,18 @@ describe("listTasks", () => {
   it("lists only non-done tasks and respects type filter", () => {
     const cwd = makeCwd();
     const implementTask = createTask(cwd, "implement", "Implement feature");
-    const debugTask = createTask(cwd, "debug", "Debug crash");
+    const reviewTask = createTask(cwd, "review", "Review crash");
     const brainstormTask = createTask(cwd, "brainstorm", "Idea storm");
 
-    const doneState = loadTask(debugTask);
+    const doneState = loadTask(reviewTask);
     doneState.phase = "done";
-    saveTask(debugTask, doneState);
+    saveTask(reviewTask, doneState);
 
     const all = listTasks(cwd);
     const allDirs = all.map((t) => t.dir);
     expect(allDirs).toContain(implementTask);
     expect(allDirs).toContain(brainstormTask);
-    expect(allDirs).not.toContain(debugTask);
+    expect(allDirs).not.toContain(reviewTask);
 
     const brainstormOnly = listTasks(cwd, "brainstorm");
     expect(brainstormOnly).toHaveLength(1);
@@ -384,7 +385,7 @@ describe("getActiveTask", () => {
   it("returns null when multiple unlocked tasks exist (ambiguous)", () => {
     const cwd = makeCwd();
     createTask(cwd, "implement", "First abandoned");
-    createTask(cwd, "debug", "Second abandoned");
+    createTask(cwd, "review", "Second abandoned");
     vi.spyOn(lockfile, "checkSync").mockReturnValue(false);
 
     expect(getActiveTask(cwd)).toBeNull();
@@ -393,7 +394,7 @@ describe("getActiveTask", () => {
   it("returns the single unlocked task when others are locked", () => {
     const cwd = makeCwd();
     const lockedTask = createTask(cwd, "implement", "Locked by other");
-    const unlockedTask = createTask(cwd, "debug", "Abandoned");
+    const unlockedTask = createTask(cwd, "review", "Abandoned");
 
     vi.spyOn(lockfile, "checkSync").mockImplementation((path: string, _options?: { stale?: number }) => {
       if (path === join(lockedTask, "state.json")) return true;
@@ -434,7 +435,7 @@ describe("getActiveTaskStatus", () => {
   it("reports ambiguous with all tasks when multiple are unlocked", () => {
     const cwd = makeCwd();
     createTask(cwd, "implement", "First");
-    createTask(cwd, "debug", "Second");
+    createTask(cwd, "review", "Second");
     vi.spyOn(lockfile, "checkSync").mockReturnValue(false);
 
     const status = getActiveTaskStatus(cwd);
@@ -447,7 +448,6 @@ describe("getFirstPhase", () => {
   it("returns expected first phase for each task type", () => {
     expect(getFirstPhase("implement")).toBe("brainstorm");
     expect(getFirstPhase("brainstorm")).toBe("brainstorm");
-    expect(getFirstPhase("debug")).toBe("debug");
     expect(getFirstPhase("review")).toBe("review");
     expect(getFirstPhase("quick")).toBe("quick");
   });

package/extensions/orchestrator/state.ts

@@ -28,14 +28,13 @@ export interface AutonomousConfig {
   phases: Record<string, AutonomousPhaseConfig>;
 }
 
-export type TaskType = "implement" | "debug" | "brainstorm" | "review" | "quick";
+export type TaskType = "implement" | "brainstorm" | "review" | "quick";
 
 export type ImplementPhase = "brainstorm" | "plan" | "implement" | "done";
-export type DebugPhase = "debug" | "plan" | "implement" | "done";
 export type BrainstormPhase = "brainstorm" | "plan" | "implement" | "done";
 export type ReviewPhase = "review" | "plan" | "implement" | "done";
 export type QuickPhase = "quick";
-export type Phase = ImplementPhase | DebugPhase | BrainstormPhase | ReviewPhase | QuickPhase;
+export type Phase = ImplementPhase | BrainstormPhase | ReviewPhase | QuickPhase;
 
 export interface TaskState {
   phase: Phase;
@@ -76,10 +75,24 @@ export interface TaskState {
   // the guided/autonomous transition or the autonomous terminal handoff), so the
   // hooks never run twice for the same completion.
   afterImplementRan?: boolean;
-  // Per-repo interleaved Plannotator review cursor (#3a). repoPaths is the ordered
-  // set of repos to review; index is the next repo. Persisted so the loop resumes
-  // on the next /pp after the agent fixes one repo's feedback. Undefined = no loop.
-  plannotatorCursor?: { repoPaths: string[]; index: number };
+  // State-freshness reconcile markers (see maybePromptReconcile). Absent on legacy
+  // tasks. reconcilePending forces a re-prompt after a pause/complete that could
+  // not reconcile in-line.
+  reconcilePromptedPhase?: string;
+  reconciledPhase?: string;
+  reconcilePending?: boolean;
+  // Per-repo Plannotator review cursor. repoPaths is the ordered set of repos to
+  // review; index is read only by the single-repo path (retained for
+  // backward-compatible deserialization of older cursors). For multi-repo reviews
+  // the user drives repo selection via a status picker; `status` records each
+  // repo's outcome (absent = unreviewed) and `feedback` holds pending
+  // changes-requested feedback not yet applied. Undefined = no active loop.
+  plannotatorCursor?: {
+    repoPaths: string[];
+    index: number;
+    status?: Record<string, "approved" | "changes-requested" | "fixes-applied">;
+    feedback?: Record<string, string>;
+  };
   // The phase the task was in when it was marked done. Recorded so the Resume
   // "reopen a done task" flow (#2) can restore the actual last working phase
   // (done itself carries no phase history). Absent on legacy done tasks.
@@ -102,7 +115,6 @@ function taskStatePath(taskDir: string): string {
 
 export function getFirstPhase(type: TaskType): Exclude<Phase, "done"> {
   if (type === "implement" || type === "brainstorm") return "brainstorm";
-  if (type === "debug") return "debug";
   if (type === "review") return "review";
   return "quick";
 }
@@ -115,7 +127,7 @@ export function getEffectiveMode(state: TaskState): TaskMode | undefined {
 // drives them, so they never inherit the task's autonomous mode even when one is set.
 // plan/implement are autonomous-capable regardless of whether they are the task's initial phase.
 export function getEffectivePhaseMode(state: TaskState): TaskMode {
-  if (state.phase === "brainstorm" || state.phase === "debug" || state.phase === "review") return "guided";
+  if (state.phase === "brainstorm" || state.phase === "review") return "guided";
   return getEffectiveMode(state) ?? "guided";
 }
 
@@ -162,8 +174,19 @@ export function createTask(cwd: string, type: TaskType, description: string, mod
 export function loadTask(taskDir: string): TaskState {
   const sp = taskStatePath(taskDir);
   const raw = readFileSync(sp, "utf-8");
+  let parsed: TaskState;
+  try {
+    parsed = JSON.parse(raw) as TaskState;
+  } catch (err: any) {
+    throw new Error(`Failed to parse ${sp}: ${err.message}`);
+  }
+  if ((parsed as any).phase === "debug") {
+    throw new Error(
+      "Debug tasks are no longer supported; use /pp → Implement → From to reuse their artifacts.",
+    );
+  }
   try {
-    const state = JSON.parse(raw) as TaskState;
+    const state = parsed;
     if ((state as any).phase === "planning") {
       state.phase = "plan";
     }
@@ -203,7 +226,7 @@ export function listTasks(cwd: string, typeOrOptions?: TaskType | ListTasksOptio
   const base = stateDir(cwd);
   if (!existsSync(base)) return [];
 
-  const types: TaskType[] = options.type ? [options.type] : ["implement", "debug", "brainstorm", "review", "quick"];
+  const types: TaskType[] = options.type ? [options.type] : ["implement", "brainstorm", "review", "quick"];
   const results: TaskInfo[] = [];
 
   for (const t of types) {
@@ -343,7 +366,7 @@ function firstMarkdownContent(path: string): string | null {
 export function taskFullName(taskDir: string, state: TaskState): string {
   let desc = state.description ?? "";
 
-  if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
+  if (["implement", "brainstorm", "review", "quick"].includes(desc)) {
     const fallback =
       firstMarkdownContent(join(taskDir, "USER_REQUEST.md")) ??
       firstMarkdownContent(join(taskDir, "RESEARCH.md")) ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",
@@ -33,11 +33,12 @@
     "AGENTS.md"
   ],
   "scripts": {
-    "postinstall": "bash scripts/postinstall.sh",
+    "postinstall": "node scripts/postinstall.mjs",
     "test": "vitest run --exclude '3p/**'",
     "test:watch": "vitest --exclude '3p/**'",
     "test:3p": "bash scripts/test-3p.sh",
-    "test:all": "vitest run --exclude '3p/**' && bash scripts/test-3p.sh",
+    "test:package": "bash scripts/test-package.sh",
+    "test:all": "vitest run --exclude '3p/**' && bash scripts/test-3p.sh && bash scripts/test-package.sh",
     "coverage": "vitest run --exclude '3p/**' --coverage"
   },
   "pi": {
@@ -53,8 +54,10 @@
   "dependencies": {
     "@joplin/turndown-plugin-gfm": "^1.0.64",
     "@pierre/diffs": "^1.2.0",
+    "croner": "^10.0.1",
     "effect": "^3.0.0",
     "minimatch": "^10.0.0",
+    "nanoid": "^5.0.0",
     "pino": "^10.3.1",
     "proper-lockfile": "^4.1.2",
     "turndown": "^7.2.0",

package/scripts/lib/smoke-resolve.mjs

@@ -0,0 +1,99 @@
+// Runs from INSIDE the installed package directory (import.meta.url is under the package), so
+// dynamic import() of a bare specifier resolves through the installed artifact's own
+// node_modules chain — the same resolution pi performs at extension load. Exits non-zero if a
+// registered extension path is missing or a required runtime specifier fails to load.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG_DIR = dirname(fileURLToPath(import.meta.url));
+
+function fail(msg) {
+  console.error(`  ✗ ${msg}`);
+  process.exitCode = 1;
+}
+
+const pkg = JSON.parse(readFileSync(join(PKG_DIR, "package.json"), "utf8"));
+
+const extEntries = pkg?.pi?.extensions ?? [];
+if (extEntries.length === 0) fail("package.json has no pi.extensions entries");
+for (const entry of extEntries) {
+  if (existsSync(resolve(PKG_DIR, entry))) {
+    console.log(`  ✓ extension present: ${entry}`);
+  } else {
+    fail(`registered extension path missing from artifact: ${entry}`);
+  }
+}
+
+// Bare specifiers pi itself supplies to loaded extensions — never mirrored into dependencies.
+const peerSupplied = new Set(Object.keys(pkg.peerDependencies ?? {}));
+
+function isBuiltin(spec) {
+  return spec.startsWith("node:");
+}
+function isRelative(spec) {
+  return spec.startsWith(".") || spec.startsWith("/");
+}
+function packageName(spec) {
+  const parts = spec.split("/");
+  return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+function collectTsFiles(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const full = join(dir, name);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...collectTsFiles(full));
+    else if (name.endsWith(".ts")) out.push(full);
+  }
+  return out;
+}
+
+// Scope the scan to the pi-subagents source only. Other shipped 3p sources reference SDK
+// specifiers behind lazy `await import()` guards that are intentionally NOT root dependencies;
+// scanning them would produce a permanently failing test.
+const SCAN_DIR = join(PKG_DIR, "3p", "pi-subagents", "src");
+if (!existsSync(SCAN_DIR)) {
+  fail(`expected shipped source dir missing: 3p/pi-subagents/src`);
+  process.exit(process.exitCode ?? 1);
+}
+
+// Value (non-type) import/export ... from "spec" and dynamic import("spec"). `import type` /
+// `export type` statements are type-only and erased at build, so they carry no runtime requirement.
+const FROM_RE = /(^|\n)\s*(import|export)\s+(?!type\b)(?:[^;]*?\sfrom\s+)?["']([^"']+)["']/g;
+const DYN_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+
+const required = new Set();
+for (const file of collectTsFiles(SCAN_DIR)) {
+  const src = readFileSync(file, "utf8");
+  for (const m of src.matchAll(FROM_RE)) addSpec(m[3]);
+  for (const m of src.matchAll(DYN_RE)) addSpec(m[1]);
+}
+function addSpec(spec) {
+  if (isBuiltin(spec) || isRelative(spec)) return;
+  const name = packageName(spec);
+  if (peerSupplied.has(name)) return;
+  required.add(name);
+}
+
+// Floor: these two are the runtime imports that broke consumer installs; assert them explicitly
+// even if the extractor's shape ever changes.
+required.add("croner");
+required.add("nanoid");
+
+const specs = [...required].sort();
+console.log(`  runtime specifiers to resolve: ${specs.join(", ")}`);
+
+for (const spec of specs) {
+  try {
+    await import(spec);
+    console.log(`  ✓ resolved: ${spec}`);
+  } catch (err) {
+    fail(`cannot resolve '${spec}' from installed package: ${err?.message ?? err}`);
+  }
+}
+
+if (process.exitCode) {
+  console.error("  → the root package is missing a runtime dependency its shipped extensions need.");
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,93 @@
+// Vendor-source decision: on non-Windows we invoke the existing bash `vendor.sh` UNCHANGED so
+// Linux/CI stay byte-for-byte identical; on Windows we SKIP the bash vendor step (a documented
+// Windows limitation) and rely on the npm-pack HTML fallback below. vendor.sh is still the single
+// source used by `npm run build`/CI — this script does not fork its logic.
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(SCRIPT_DIR, "..");
+const PI_EXT_DIR = join(REPO_ROOT, "3p", "pi-plannotator", "apps", "pi-extension");
+const isWindows = process.platform === "win32";
+
+function fail(msg) {
+  console.error(`  ✗ ${msg}`);
+  process.exit(1);
+}
+
+function runVendor() {
+  if (isWindows) {
+    console.log("  ⚠ skipping plannotator vendor step on Windows (bash vendor.sh unavailable)");
+    return;
+  }
+  const res = spawnSync("bash", [join(PI_EXT_DIR, "vendor.sh")], { cwd: REPO_ROOT, stdio: "inherit" });
+  if (res.status !== 0) fail(`vendor.sh failed with exit code ${res.status ?? "unknown"}`);
+}
+
+function htmlPresent() {
+  return existsSync(join(PI_EXT_DIR, "plannotator.html")) && existsSync(join(PI_EXT_DIR, "review-editor.html"));
+}
+
+// Extract a specific file from an npm tarball (gzipped POSIX/ustar tar) using only
+// Node builtins — no external `tar` executable, which is not guaranteed on native
+// Windows. Returns the file's bytes, or null when the entry is absent.
+function extractFromTar(tarBytes, wantPath) {
+  let off = 0;
+  while (off + 512 <= tarBytes.length) {
+    const header = tarBytes.subarray(off, off + 512);
+    const name = header.subarray(0, 100).toString("utf-8").replace(/\0.*$/, "");
+    if (name === "") break;
+    const size = parseInt(header.subarray(124, 136).toString("utf-8").replace(/\0.*$/, "").trim() || "0", 8);
+    const dataStart = off + 512;
+    if (name === wantPath) return tarBytes.subarray(dataStart, dataStart + size);
+    off = dataStart + Math.ceil(size / 512) * 512;
+  }
+  return null;
+}
+
+// Run `npm pack` without depending on PATH/PATHEXT resolution of `npm`, which on
+// Windows is `npm.cmd` and cannot be spawned by execFileSync without a shell
+// (Node rejects .cmd without shell:true). In a lifecycle script npm exports
+// npm_execpath (the CLI's JS entry); run it with the current node. Fall back to a
+// shell-resolved `npm`/`npm.cmd` only if that env var is somehow absent.
+function runNpmPack(destDir) {
+  const npmCli = process.env.npm_execpath;
+  if (npmCli) {
+    execFileSync(process.execPath, [npmCli, "pack", "@plannotator/pi-extension", "--pack-destination", destDir, "--silent"], {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    return;
+  }
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  execFileSync(npmCmd, ["pack", "@plannotator/pi-extension", "--pack-destination", destDir, "--silent"], {
+    stdio: ["ignore", "ignore", "ignore"],
+    shell: true,
+  });
+}
+
+function extractHtmlFallback() {
+  const tmp = mkdtempSync(join(tmpdir(), "pi-pi-plannotator-"));
+  try {
+    runNpmPack(tmp);
+    const tgz = readdirSync(tmp).find((name) => name.endsWith(".tgz"));
+    if (!tgz) fail("npm pack produced no tarball for @plannotator/pi-extension");
+    const tarBytes = gunzipSync(readFileSync(join(tmp, tgz)));
+    for (const file of ["plannotator.html", "review-editor.html"]) {
+      const bytes = extractFromTar(tarBytes, `package/${file}`);
+      if (!bytes) fail(`@plannotator/pi-extension tarball is missing ${file}`);
+      writeFileSync(join(PI_EXT_DIR, file), bytes);
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+runVendor();
+
+if (htmlPresent()) process.exit(0);
+
+extractHtmlFallback();

package/scripts/test-package.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Release-layout smoke test: pack the root package, install the tarball into a throwaway
+# directory OUTSIDE this checkout, and verify the shipped extension artifact resolves its
+# runtime imports from the installed tree alone.
+#
+# Why this exists: the root `npm test` excludes 3p/** and the vendored suites run inside
+# 3p/*/node_modules, so a bare import that a vendored extension needs but the root package
+# forgets to declare is invisible in the dev checkout (its node_modules still has the package).
+# It only surfaces after a clean `npm install` by a consumer — exactly the croner/nanoid
+# regression this guards against. Resolving bare specifiers from the installed package tree is
+# the only shape that reproduces that failure.
+#
+# Registry access is required (npm install of the tarball fetches deps, runs the root
+# postinstall, and npm v7+ auto-installs peerDependencies). Offline CI: warm the npm cache and
+# export a --prefer-offline-friendly registry mirror.
+set -uo pipefail
+cd "$(dirname "$0")/.."
+ROOT="$(pwd)"
+
+TMPDIR_SMOKE="$(mktemp -d)"
+trap 'rm -rf "$TMPDIR_SMOKE"' EXIT
+
+echo "▶ packing root package"
+PACK_JSON="$(npm pack --json --pack-destination "$TMPDIR_SMOKE" 2>/dev/null)"
+TARBALL="$(node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{const a=JSON.parse(s);process.stdout.write(a[0].filename)})' <<<"$PACK_JSON")"
+if [ -z "$TARBALL" ] || [ ! -f "$TMPDIR_SMOKE/$TARBALL" ]; then
+  echo "ERROR: npm pack did not produce a tarball (got: '$TARBALL')." >&2
+  exit 1
+fi
+echo "  tarball: $TARBALL"
+
+INSTALL_DIR="$TMPDIR_SMOKE/install"
+mkdir -p "$INSTALL_DIR"
+( cd "$INSTALL_DIR" && npm init -y >/dev/null 2>&1 )
+
+echo "▶ installing tarball into a clean consumer directory"
+if ! ( cd "$INSTALL_DIR" && npm install "$TMPDIR_SMOKE/$TARBALL" --no-audit --no-fund 2>&1 ); then
+  echo "ERROR: installing the packed tarball failed." >&2
+  exit 1
+fi
+
+PKG_NAME="$(node -e 'process.stdout.write(require("./package.json").name)')"
+PKG_DIR="$INSTALL_DIR/node_modules/$PKG_NAME"
+if [ ! -d "$PKG_DIR" ]; then
+  echo "ERROR: installed package not found at $PKG_DIR" >&2
+  exit 1
+fi
+
+# Run the resolution check from a helper placed INSIDE the installed package, so bare-specifier
+# resolution provably walks the artifact's own node_modules hierarchy (not this checkout's).
+CHECK="$PKG_DIR/__smoke-resolve.mjs"
+cp "$ROOT/scripts/lib/smoke-resolve.mjs" "$CHECK"
+
+echo "▶ resolving shipped extension runtime imports from the install tree"
+( cd "$PKG_DIR" && node "$CHECK" )
+STATUS=$?
+
+if [ $STATUS -ne 0 ]; then
+  echo "✗ package smoke test FAILED" >&2
+  exit $STATUS
+fi
+echo "✓ package smoke test passed"

package/scripts/postinstall.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-cd "$(dirname "$0")/.."
-
-bash 3p/pi-plannotator/apps/pi-extension/vendor.sh
-
-PI_EXT_DIR="3p/pi-plannotator/apps/pi-extension"
-if [ -f "$PI_EXT_DIR/plannotator.html" ] && [ -f "$PI_EXT_DIR/review-editor.html" ]; then
-  exit 0
-fi
-
-TMPDIR=$(mktemp -d)
-trap 'rm -rf "$TMPDIR"' EXIT
-
-npm pack @plannotator/pi-extension --pack-destination "$TMPDIR" --silent 2>/dev/null
-tar -xzf "$TMPDIR"/*.tgz -C "$TMPDIR"
-cp "$TMPDIR/package/plannotator.html" "$PI_EXT_DIR/plannotator.html"
-cp "$TMPDIR/package/review-editor.html" "$PI_EXT_DIR/review-editor.html"