@juicesharp/rpiv-pi 1.19.0 → 1.19.1

package/extensions/rpiv-core/built-in-workflows.test.ts

@@ -1050,6 +1050,39 @@ describe("ship workflow", () => {
 	});
 });
 
+// ---------------------------------------------------------------------------
+// pr-triage security-gate — the script-stage guard must fail closed on
+// missing / malformed security_flag (NaN), not silently pass as SAFE.
+// ---------------------------------------------------------------------------
+
+describe("pr-triage security-gate", () => {
+	const gateRun = () => {
+		const stage = findWorkflow("pr-triage").stages["security-gate"];
+		if (!stage?.run) throw new Error("pr-triage security-gate stage has no run function");
+		return stage.run as (ctx: { input?: { data?: unknown } }) => void;
+	};
+
+	it("throws on missing input (undefined)", () => {
+		expect(() => gateRun()({ input: undefined })).toThrow(/BLOCK/);
+	});
+
+	it("throws on non-numeric security_flag (NaN)", () => {
+		expect(() => gateRun()({ input: { data: { security_flag: "not-a-number" } } })).toThrow(/BLOCK/);
+	});
+
+	it("throws on BLOCK (security_flag = 2)", () => {
+		expect(() => gateRun()({ input: { data: { security_flag: 2 } } })).toThrow(/BLOCK/);
+	});
+
+	it("does not throw on SAFE (security_flag = 0)", () => {
+		expect(() => gateRun()({ input: { data: { security_flag: 0 } } })).not.toThrow();
+	});
+
+	it("does not throw on REVIEW (security_flag = 1)", () => {
+		expect(() => gateRun()({ input: { data: { security_flag: 1 } } })).not.toThrow();
+	});
+});
+
 // ---------------------------------------------------------------------------
 // implement reads wiring — every implement stage declares reads: ["plans"]
 // and validates clean with contracts threaded in.
@@ -1058,11 +1091,13 @@ describe("ship workflow", () => {
 describe("implement reads wiring", () => {
 	it('every implement stage declares reads: ["plans"]', () => {
 		for (const wf of builtInWorkflows) {
-			expect(wf.stages.implement?.reads, `${wf.name}.implement`).toEqual(["plans"]);
+			// Not every workflow has an implement stage (pr-triage is read-only triage).
+			if (!wf.stages.implement) continue;
+			expect(wf.stages.implement.reads, `${wf.name}.implement`).toEqual(["plans"]);
 		}
 	});
 
-	it('all five built-in workflows validate clean with reads:["plans"] (contracts threaded in)', () => {
+	it("every built-in workflow with an implement stage validates clean (contracts threaded in)", () => {
 		for (const name of ["ship", "build", "arch", "vet", "polish"]) {
 			const issues = deriveAndValidate(findWorkflow(name), { skillContracts: DECLARED_CONTRACTS });
 			expect(

package/extensions/rpiv-core/built-in-workflows.ts

@@ -79,6 +79,14 @@ interface PhaseRecord {
 	total: number;
 }
 
+/** Read an artifact file, resolving a workflow-relative path against `cwd`. */
+const readArtifactFile = (path: string, cwd: string): string =>
+	readFileSync(isAbsolute(path) ? path : join(cwd, path), "utf-8");
+
+/** Build the halting `StagePreflightError` shape every phase fanout/iterate guard `throw`s. */
+const haltPreflight = (who: string, summary: string, detail: string): StagePreflightError =>
+	new StagePreflightError("halt", who, summary, detail, true);
+
 /**
  * Parse a plan's `phases:` frontmatter into records, derive-checked against the
  * body's `## Phase N:` headings — the source of truth both the single-plan
@@ -94,12 +102,10 @@ const planPhaseRecords = (content: string, who: string, path: string): readonly
 	const phases = Array.isArray(raw) ? raw : [];
 	const headingCount = [...content.matchAll(PLAN_PHASE_RE)].length;
 	if (phases.length !== headingCount) {
-		throw new StagePreflightError(
-			"halt",
+		throw haltPreflight(
 			who,
 			`${who}: plan ${path} has mismatched phases`,
 			`${who}: plan ${path} frontmatter phases (${phases.length}) ≠ '## Phase N:' headings (${headingCount}) — the derived array is stale against the body`,
-			true,
 		);
 	}
 	// The REQUIRED scalar `phase_count` must equal the derived phase count — it
@@ -108,12 +114,10 @@ const planPhaseRecords = (content: string, who: string, path: string): readonly
 	// still degrades to [] (the existing "neither phases nor headings" path); a plan
 	// that declares phases but omits phase_count THROWS (the field is contract-required).
 	if ((phases.length > 0 || fm.phase_count !== undefined) && fm.phase_count !== phases.length) {
-		throw new StagePreflightError(
-			"halt",
+		throw haltPreflight(
 			who,
 			`${who}: plan ${path} has invalid phase_count`,
 			`${who}: plan ${path} frontmatter phase_count (${String(fm.phase_count)}) ≠ phases length (${phases.length}) — rebuild phase_count from the '## Phase N:' headings`,
-			true,
 		);
 	}
 	return phases.map((entry, index) => {
@@ -132,9 +136,6 @@ const planPhaseRecords = (content: string, who: string, path: string): readonly
 const latestFsArtifact = (state: Readonly<RunState>, name: string): Artifact | undefined =>
 	state.named[name]?.at(-1)?.artifacts.find((a) => a.handle.kind === "fs");
 
-/** Resolve a workflow-relative path against `cwd`. */
-const resolveCwd = (path: string, cwd: string): string => (isAbsolute(path) ? path : join(cwd, path));
-
 /**
  * Fan `implement` out over the structured `phases:` frontmatter array of the
  * latest plan published to the named `"plans"` channel. Sourcing from the named
@@ -153,24 +154,20 @@ const FRONTMATTER_PHASE_FANOUT = fanoutOver({
 		const path = plan.handle.path;
 		let content: string;
 		try {
-			content = readFileSync(resolveCwd(path, cwd), "utf-8");
+			content = readArtifactFile(path, cwd);
 		} catch (err) {
-			throw new StagePreflightError(
-				"halt",
+			throw haltPreflight(
 				"FRONTMATTER_PHASE_FANOUT",
 				`FRONTMATTER_PHASE_FANOUT: plan file not found`,
 				`FRONTMATTER_PHASE_FANOUT: could not read ${path} — ${err instanceof Error ? err.message : String(err)}`,
-				true,
 			);
 		}
 		const records = planPhaseRecords(content, "FRONTMATTER_PHASE_FANOUT", path);
 		if (records.length > MAX_PHASES) {
-			throw new StagePreflightError(
-				"halt",
+			throw haltPreflight(
 				"FRONTMATTER_PHASE_FANOUT",
 				`FRONTMATTER_PHASE_FANOUT: plan ${path} exceeds phase limit`,
 				`FRONTMATTER_PHASE_FANOUT: plan ${path} declares ${records.length} phases — exceeds MAX_PHASES (${MAX_PHASES}); split into smaller plans`,
-				true,
 			);
 		}
 		const promptPath = handleToString(plan.handle);
@@ -330,7 +327,7 @@ const REVIEW_PHASE_RE = /^### Phase (\d+) — (.+)$/gm;
 const reviewPhaseCount = (state: Readonly<RunState>, cwd: string): number => {
 	const review = latestFsArtifact(state, "architecture-reviews");
 	if (review?.handle.kind !== "fs") return 0;
-	const { frontmatter } = parseFrontmatter(readFileSync(resolveCwd(review.handle.path, cwd), "utf-8"));
+	const { frontmatter } = parseFrontmatter(readArtifactFile(review.handle.path, cwd));
 	const raw = (frontmatter as Record<string, unknown>).phases;
 	return Array.isArray(raw) ? raw.length : 0;
 };
@@ -386,7 +383,7 @@ const REVIEW_PHASE_ITERATE = iterateOver({
 		const review = latestFsArtifact(state, "architecture-reviews") ?? artifact;
 		if (review?.handle.kind !== "fs") return null;
 		const reviewPath = review.handle.path; // captured: narrowing is lost inside nested closures below
-		const content = readFileSync(resolveCwd(reviewPath, cwd), "utf-8");
+		const content = readArtifactFile(reviewPath, cwd);
 		const { frontmatter } = parseFrontmatter(content);
 		const raw = (frontmatter as Record<string, unknown>).phases;
 		const phases = Array.isArray(raw) ? raw : [];
@@ -394,12 +391,10 @@ const REVIEW_PHASE_ITERATE = iterateOver({
 		if (i === 0) {
 			const headingCount = [...content.matchAll(REVIEW_PHASE_RE)].length;
 			if (phases.length !== headingCount) {
-				throw new StagePreflightError(
-					"halt",
+				throw haltPreflight(
 					"REVIEW_PHASE_ITERATE",
 					`REVIEW_PHASE_ITERATE: review ${reviewPath} has mismatched phases`,
 					`REVIEW_PHASE_ITERATE: review ${reviewPath} frontmatter phases (${phases.length}) ≠ '### Phase N —' headings (${headingCount}) — the derived array is stale against the body`,
-					true,
 				);
 			}
 			const indexByN = new Map(phases.map((e, idx) => [phaseNum(e, idx), idx]));
@@ -407,20 +402,16 @@ const REVIEW_PHASE_ITERATE = iterateOver({
 				for (const d of phaseDeps(e)) {
 					const di = indexByN.get(d);
 					if (di === undefined)
-						throw new StagePreflightError(
-							"halt",
+						throw haltPreflight(
 							"REVIEW_PHASE_ITERATE",
 							`REVIEW_PHASE_ITERATE: review ${reviewPath} has invalid depends_on`,
 							`REVIEW_PHASE_ITERATE: review ${reviewPath} phase ${phaseNum(e, idx)} depends_on ${d}, which is not a declared phase`,
-							true,
 						);
 					if (di >= idx)
-						throw new StagePreflightError(
-							"halt",
+						throw haltPreflight(
 							"REVIEW_PHASE_ITERATE",
 							`REVIEW_PHASE_ITERATE: review ${reviewPath} has cyclic dependency`,
 							`REVIEW_PHASE_ITERATE: review ${reviewPath} phase ${phaseNum(e, idx)} depends_on ${d}, which is not an earlier phase (self/forward/cyclic dependency)`,
-							true,
 						);
 				}
 			});
@@ -471,7 +462,7 @@ const PLANS_PHASE_FANOUT = fanoutOver({
 			for (const a of out.artifacts) {
 				if (a.handle.kind !== "fs") continue;
 				const path = a.handle.path;
-				const content = readFileSync(resolveCwd(path, cwd), "utf-8");
+				const content = readArtifactFile(path, cwd);
 				const promptPath = handleToString(a.handle);
 				for (const r of planPhaseRecords(content, "PLANS_PHASE_FANOUT", path)) {
 					units.push({
@@ -482,12 +473,10 @@ const PLANS_PHASE_FANOUT = fanoutOver({
 			}
 		}
 		if (units.length > MAX_PHASES) {
-			throw new StagePreflightError(
-				"halt",
+			throw haltPreflight(
 				"PLANS_PHASE_FANOUT",
 				`PLANS_PHASE_FANOUT: phase limit exceeded`,
 				`PLANS_PHASE_FANOUT: ${units.length} phases exceeds MAX_PHASES (${MAX_PHASES})`,
-				true,
 			);
 		}
 		return units;
@@ -535,6 +524,58 @@ const polishWorkflow = defineWorkflow({
 	},
 });
 
+// ===========================================================================
+// pr-triage — pr-triage → security-gate → stop
+//   Read-only front door for an incoming GitHub PR. The `pr-triage` skill
+//   fetches the PR thread, assesses the diff against whatever standard the repo
+//   actually carries, writes a triage artifact, and recommends a triage
+//   disposition (Review / Request changes / Hold / Decline) as a plain next
+//   action. The `security-gate` script stage reads the skill's
+//   `security_flag` and HALTS the run on a BLOCK (≥ 2) via `haltPreflight` — the
+//   "security gate first, before any checkout" posture — while SAFE/REVIEW (< 2)
+//   fall through to `stop` carrying the verdict.
+//
+//   It terminates rather than dispatching a follow-up workflow: triage gates entry
+//   to review, it does not merge. The disposition is a plain action; `vet` (the
+//   review stage) is offered as optional sugar under Review. Only the security gate
+//   is enforced by the graph. A linear guard stage (not a `gate(...)`
+//   edge) keeps the halt off the data-routing path — the throw lives inside the
+//   script, read from the prior stage's output.
+// ===========================================================================
+
+/** BLOCK tier the pr-triage `security_flag` contract field emits (0 SAFE · 1 REVIEW · 2 BLOCK). */
+const PR_TRIAGE_BLOCK = 2;
+
+const prTriageWorkflow = defineWorkflow({
+	name: "pr-triage",
+	description:
+		"Read-only triage of a GitHub PR before any review effort. Fetches the PR thread, assesses the diff against the repo's own standards, writes a triage artifact, and recommends a triage disposition (Review / Request changes / Hold / Decline). A security BLOCK halts the run before any checkout. Best as the entry point for an incoming PR. Chain: pr-triage → security-gate → stop.",
+	start: "pr-triage",
+	stages: {
+		"pr-triage": produces(),
+		// Skillless guard: read the triage skill's `security_flag` from the prior
+		// stage's output and halt on BLOCK. A script stage (not a skill) — no LLM,
+		// no session — so the gate is free. On SAFE/REVIEW it is a no-op side effect
+		// and the chain advances to `stop`.
+		"security-gate": acts.script({
+			run: ({ input }) => {
+				const flag = Number((input?.data as { security_flag?: unknown } | undefined)?.security_flag);
+				if (Number.isNaN(flag) || flag >= PR_TRIAGE_BLOCK) {
+					throw haltPreflight(
+						"pr-triage",
+						"pr-triage: security BLOCK — do not proceed",
+						`pr-triage: security_flag=${flag} (BLOCK) — the PR diff carries a high-confidence security risk. Resolve it before any checkout or review; see the triage artifact for the traced finding.`,
+					);
+				}
+			},
+		}),
+	},
+	edges: {
+		"pr-triage": "security-gate",
+		"security-gate": "stop",
+	},
+});
+
 // ===========================================================================
 // Exports
 // ===========================================================================
@@ -545,4 +586,5 @@ export const builtInWorkflows: readonly Workflow[] = [
 	archWorkflow,
 	vetWorkflow,
 	polishWorkflow,
+	prTriageWorkflow,
 ];

package/extensions/rpiv-core/index.ts

@@ -7,7 +7,7 @@
  * Tool-owning plugins are siblings (see siblings.ts); install via /rpiv-setup.
  *
  * Workflow runtime + `/wf` command live in `@juicesharp/rpiv-workflow`. We
- * contribute five built-in workflows (ship / build / arch / vet / polish) via the
+ * contribute six built-in workflows (ship / build / arch / vet / polish / pr-triage) via the
  * sibling's `registerBuiltIns` programmatic API so they're available to
  * users running `/wf` without authoring their own.
  */

package/extensions/rpiv-core/outcome-derivation.test.ts

@@ -46,8 +46,8 @@ function stripOutcomes(w: Workflow): Workflow {
 // ---------------------------------------------------------------------------
 
 describe("BUCKET_BY_KIND", () => {
-	it("contains exactly 9 entries", () => {
-		expect(Object.keys(BUCKET_BY_KIND)).toHaveLength(9);
+	it("contains exactly 10 entries", () => {
+		expect(Object.keys(BUCKET_BY_KIND)).toHaveLength(10);
 	});
 
 	it("covers all artifactKinds used by produces skills", () => {
@@ -61,6 +61,7 @@ describe("BUCKET_BY_KIND", () => {
 			"architecture-review",
 			"frd",
 			"handoff",
+			"triage",
 		];
 		for (const kind of expectedKinds) {
 			expect(BUCKET_BY_KIND[kind]).toBeDefined();
@@ -242,10 +243,11 @@ describe("equivalence — built-in workflows", () => {
 		["validate", "validation"],
 		["code-review", "review"],
 		["revise", "plan"],
+		["pr-triage", "triage"],
 	];
 
 	/**
-	 * Expected bucket name for each produces stage across all 5 workflows.
+	 * Expected bucket name for each produces stage across all 6 workflows.
 	 * Key: "workflowName::stageName". Value: expected outcome.name.
 	 */
 	const EXPECTED: Record<string, string> = {
@@ -273,6 +275,8 @@ describe("equivalence — built-in workflows", () => {
 		"polish::blueprint": "plans",
 		"polish::validate": "validation",
 		"polish::code-review": "reviews",
+		// pr-triage
+		"pr-triage::pr-triage": "triage",
 	};
 
 	/**
@@ -343,14 +347,14 @@ describe("equivalence — built-in workflows", () => {
 		});
 	}
 
-	it("total produces stages across all workflows = 19", () => {
+	it("total produces stages across all workflows = 20", () => {
 		let count = 0;
 		for (const w of builtInWorkflows) {
 			for (const stage of Object.values(w.stages)) {
 				if (stage.kind === "produces") count++;
 			}
 		}
-		expect(count).toBe(19);
+		expect(count).toBe(20);
 	});
 });
 

package/extensions/rpiv-core/outcome-derivation.ts

@@ -35,6 +35,7 @@ export const BUCKET_BY_KIND: Readonly<Record<string, string>> = {
 	"architecture-review": "architecture-reviews",
 	frd: "discover",
 	handoff: "handoffs",
+	triage: "triage",
 };
 
 /**

package/extensions/rpiv-core/register-built-in-workflows.test.ts

@@ -11,18 +11,18 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { registerBuiltInWorkflows } from "./register-built-in-workflows.js";
 
-// Alphabetical: the five shipped presets.
-const BUILT_IN_NAMES = ["arch", "build", "polish", "ship", "vet"];
+// Alphabetical: the six shipped presets.
+const BUILT_IN_NAMES = ["arch", "build", "polish", "pr-triage", "ship", "vet"];
 
 describe("registerBuiltInWorkflows", () => {
-	it("registers all built-in workflows (five presets) when rpiv-workflow is present", async () => {
+	it("registers all built-in workflows (six presets) when rpiv-workflow is present", async () => {
 		const { getBuiltIns, flushBuiltInProviders } = await import("@juicesharp/rpiv-workflow/internal");
 		expect(getBuiltIns()).toEqual([]); // setup.ts beforeEach resets the registry
 
 		await registerBuiltInWorkflows();
 		// registerBuiltInWorkflows now registers a LAZY provider — the registry
 		// stays empty until the first loadWorkflows() flushes it. Flush directly
-		// to assert the provider contributes the five definitions.
+		// to assert the provider contributes the six definitions.
 		expect(getBuiltIns()).toEqual([]);
 		await flushBuiltInProviders();
 

package/extensions/rpiv-core/register-built-in-workflows.ts

@@ -21,7 +21,7 @@
 import { isModuleNotFound } from "./utils.js";
 
 /**
- * Register the five built-in workflows (ship / build / arch / vet / polish)
+ * Register the six built-in workflows (ship / build / arch / vet / polish / pr-triage)
  * with the rpiv-workflow runtime, if that sibling is installed. A missing
  * sibling resolves to a no-op; any other failure is re-thrown so genuine bugs
  * surface rather than hiding behind the absent-sibling path.
@@ -29,7 +29,7 @@ import { isModuleNotFound } from "./utils.js";
 export async function registerBuiltInWorkflows(): Promise<void> {
 	try {
 		// Thin `/startup` entry (~9ms, no DSL/runner). Register a LAZY provider so
-		// `built-in-workflows.js` (the ~180ms authoring-DSL graph) builds the five
+		// `built-in-workflows.js` (the ~180ms authoring-DSL graph) builds the six
 		// definitions on first `/wf`, not at startup. Missing sibling →
 		// ERR_MODULE_NOT_FOUND → no-op (no `/wf` without it).
 		const { registerBuiltInsProvider, registerBuiltIns } = await import("@juicesharp/rpiv-workflow/startup");

package/extensions/rpiv-core/skill-contracts-source.test.ts

@@ -206,8 +206,8 @@ describe("bundled skill contracts", () => {
 	// dropped, or fails to parse (a malformed block is silently skipped).
 	const declared = new Map(buildSkillContractsFromFrontmatter(BUNDLED_SKILLS_DIR));
 
-	it("declares a contract for the 19 pipeline + orthogonal skills", () => {
-		expect(declared.size).toBe(19);
+	it("declares a contract for the 20 pipeline + orthogonal skills", () => {
+		expect(declared.size).toBe(20);
 		for (const name of [
 			"discover",
 			"research",
@@ -228,6 +228,7 @@ describe("bundled skill contracts", () => {
 			"resume-handoff",
 			"frontend-design",
 			"migrate-to-guidance",
+			"pr-triage",
 		]) {
 			expect(declared.has(name)).toBe(true);
 		}
@@ -252,6 +253,7 @@ describe("bundled skill contracts", () => {
 	it("documents the declared-but-not-harvested orthogonal set", () => {
 		// These skills declare a contract but don't appear in any built-in workflow.
 		// The orthogonal set: 7 new + discover + explore + commit = 10 skills.
+		// (pr-triage IS harvested — it's dispatched by the pr-triage workflow.)
 		const harvested = harvestStageContracts(builtInWorkflows);
 		const notHarvested: string[] = [];
 		for (const [name] of declared) {
@@ -273,7 +275,7 @@ describe("bundled skill contracts", () => {
 		);
 	});
 
-	it("every declared kind matches the harvested kind for the five built-in workflows", () => {
+	it("every declared kind matches the harvested kind for the six built-in workflows", () => {
 		// Harvest derives each dispatched skill's kind from how the built-ins use
 		// it (produces() → "produces", acts() → "side-effect"). A declared kind
 		// that disagrees would make the rendered graph lie — catch it here.

package/extensions/rpiv-core/skill-contracts-source.ts

@@ -19,7 +19,6 @@ import type {
 	SchemaCompatResult,
 	SkillContract,
 } from "@juicesharp/rpiv-workflow/registration";
-import { registerOutcomeDerivation } from "./outcome-derivation.js";
 import { BUNDLED_SKILLS_DIR } from "./paths.js";
 import { isModuleNotFound } from "./utils.js";
 
@@ -169,6 +168,15 @@ export async function registerSkillContractsSource(): Promise<void> {
 		});
 		// Register the contract-derived outcome resolver so `produces` stages
 		// auto-wire `rpivBucketOutcome(bucket)` from `artifactKind` at load time.
+		// Dynamic import (not static): `outcome-derivation.js` pulls in
+		// `artifact-collector.js`, which value-imports `@juicesharp/rpiv-workflow/registration`
+		// at module-eval. A static edge would make THAT a load-time requirement of the
+		// whole extension — so when the sibling is absent or not co-located, rpiv-core
+		// fails to load entirely (the bug in #66). Deferring it here keeps the sibling
+		// edge off the entry path: it only resolves after the `/startup` import above
+		// already succeeded, and a missing/non-resolvable sibling degrades to the
+		// isModuleNotFound no-op below instead of crashing the extension.
+		const { registerOutcomeDerivation } = await import("./outcome-derivation.js");
 		await registerOutcomeDerivation();
 	} catch (err) {
 		if (isModuleNotFound(err)) return; // sibling absent — /rpiv-setup prompts the user

package/extensions/rpiv-core/utils.test.ts

@@ -74,11 +74,27 @@ describe("toErrorMessage", () => {
 });
 
 describe("isModuleNotFound", () => {
-	it("is true for an ERR_MODULE_NOT_FOUND error", () => {
+	it("is true for an ERR_MODULE_NOT_FOUND error (Node native ESM resolver)", () => {
 		const err = Object.assign(new Error("Cannot find package"), { code: "ERR_MODULE_NOT_FOUND" });
 		expect(isModuleNotFound(err)).toBe(true);
 	});
 
+	it("is true for a MODULE_NOT_FOUND error (jiti resolver — what Pi actually uses)", () => {
+		// jiti 2.7.0 rejects a missing `import("@juicesharp/rpiv-…")` with this
+		// CJS-style code; the absent-sibling guards must treat it as a no-op.
+		const err = Object.assign(new Error("Cannot find module '@juicesharp/rpiv-workflow/startup'"), {
+			code: "MODULE_NOT_FOUND",
+		});
+		expect(isModuleNotFound(err)).toBe(true);
+	});
+
+	it("is true when the resolution code is nested under cause", () => {
+		const wrapped = Object.assign(new Error("wrapped"), {
+			cause: Object.assign(new Error("Cannot find module"), { code: "MODULE_NOT_FOUND" }),
+		});
+		expect(isModuleNotFound(wrapped)).toBe(true);
+	});
+
 	it("is false for other error codes and codeless errors", () => {
 		expect(isModuleNotFound(Object.assign(new Error("boom"), { code: "ERR_OTHER" }))).toBe(false);
 		expect(isModuleNotFound(new Error("no code"))).toBe(false);

package/extensions/rpiv-core/utils.ts

@@ -52,13 +52,28 @@ export function toErrorMessage(e: unknown, fallback?: string): string {
 // ---------------------------------------------------------------------------
 
 /**
- * True for a Node module-resolution failure (the sibling isn't installed).
+ * Error codes that mean "module-resolution failed" (the sibling isn't installed
+ * / isn't resolvable). Two distinct codes because two distinct loaders are in
+ * play:
+ *   - `ERR_MODULE_NOT_FOUND` — Node's native ESM resolver (a plain
+ *     `await import(...)` under stock Node).
+ *   - `MODULE_NOT_FOUND` — jiti's resolver, which is what Pi ACTUALLY uses to
+ *     load `.ts` extensions. A missing nested `import("@juicesharp/rpiv-…")`
+ *     inside a jiti-loaded module rejects with this CJS-style code (verified on
+ *     jiti 2.7.0, both `tryNative:false` and the native-fallback path). Matching
+ *     only the ESM code let these fall through to a logged `[rpiv-core] failed
+ *     to register …` instead of the intended silent absent-sibling no-op.
+ */
+const MODULE_NOT_FOUND_CODES = new Set(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"]);
+
+/**
+ * True for a module-resolution failure (the sibling isn't installed / not
+ * resolvable from rpiv-pi's location).
  *
  * Walks the `cause` chain: a clean `await import(...)` of a missing package
- * rejects with `code === "ERR_MODULE_NOT_FOUND"` directly, but ESM loaders and
- * tooling (vitest's mock layer, some bundlers) wrap that error, nesting the
- * real code under `.cause`. Bounded against pathological self-referential
- * chains.
+ * rejects with the resolution code directly, but ESM loaders and tooling
+ * (vitest's mock layer, some bundlers) wrap that error, nesting the real code
+ * under `.cause`. Bounded against pathological self-referential chains.
  */
 export function isModuleNotFound(err: unknown): boolean {
 	for (
@@ -66,7 +81,7 @@ export function isModuleNotFound(err: unknown): boolean {
 		cur != null && depth < 16;
 		cur = (cur as { cause?: unknown }).cause, depth++
 	) {
-		if (typeof cur === "object" && (cur as { code?: unknown }).code === "ERR_MODULE_NOT_FOUND") {
+		if (typeof cur === "object" && MODULE_NOT_FOUND_CODES.has((cur as { code?: unknown }).code as string)) {
 			return true;
 		}
 	}

package/package.json

@@ -1,62 +1,64 @@
 {
-  "name": "@juicesharp/rpiv-pi",
-  "version": "1.19.0",
-  "description": "A skill-based development workflow for Pi Agent. Five skills (research, design, plan, implement, validate) and the shared subagents that compose its ship-loop.",
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "rpiv",
-    "skills",
-    "workflow"
-  ],
-  "license": "MIT",
-  "author": "juicesharp",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/juicesharp/rpiv-mono.git",
-    "directory": "packages/rpiv-pi"
-  },
-  "homepage": "https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-pi#readme",
-  "bugs": {
-    "url": "https://github.com/juicesharp/rpiv-mono/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "vitest run"
-  },
-  "files": [
-    "extensions/",
-    "skills/",
-    "agents/",
-    "scripts/",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./extensions"
-    ],
-    "skills": [
-      "./skills"
-    ]
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@tintinweb/pi-subagents": "*",
-    "@juicesharp/rpiv-ask-user-question": "*",
-    "@juicesharp/rpiv-todo": "*",
-    "@juicesharp/rpiv-advisor": "*",
-    "@juicesharp/rpiv-i18n": "*",
-    "@juicesharp/rpiv-web-tools": "*",
-    "@juicesharp/rpiv-args": "*",
-    "@juicesharp/rpiv-workflow": "*",
-    "@juicesharp/rpiv-config": "*",
-    "yaml": "*",
-    "typebox": "*",
-    "jiti": "*",
-    "@standard-schema/spec": "*"
-  }
+	"name": "@juicesharp/rpiv-pi",
+	"version": "1.19.1",
+	"description": "A skill-based development workflow for Pi Agent. Five skills (research, design, plan, implement, validate) and the shared subagents that compose its ship-loop.",
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"rpiv",
+		"skills",
+		"workflow"
+	],
+	"license": "MIT",
+	"author": "juicesharp",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/juicesharp/rpiv-mono.git",
+		"directory": "packages/rpiv-pi"
+	},
+	"homepage": "https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-pi#readme",
+	"bugs": {
+		"url": "https://github.com/juicesharp/rpiv-mono/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"test": "vitest run"
+	},
+	"files": [
+		"extensions/",
+		"skills/",
+		"agents/",
+		"scripts/",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./extensions"
+		],
+		"skills": [
+			"./skills"
+		]
+	},
+	"dependencies": {
+		"@juicesharp/rpiv-config": "^1.19.1"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@tintinweb/pi-subagents": "*",
+		"@juicesharp/rpiv-ask-user-question": "*",
+		"@juicesharp/rpiv-todo": "*",
+		"@juicesharp/rpiv-advisor": "*",
+		"@juicesharp/rpiv-i18n": "*",
+		"@juicesharp/rpiv-web-tools": "*",
+		"@juicesharp/rpiv-args": "*",
+		"@juicesharp/rpiv-workflow": "*",
+		"yaml": "*",
+		"typebox": "*",
+		"jiti": "*",
+		"@standard-schema/spec": "*"
+	}
 }