@xynogen/pix-core 0.4.2 → 0.4.4

package/README.md

@@ -18,10 +18,10 @@ Pi activates extensions per installed package via each package's `pi.extensions`
 | `pix-footer` | Status bar: mode / git branch / model / cost / live TPS |
 | `pix-models` | `/models` — enhanced model picker with BenchLM rank, context, cost |
 | `pix-update` | `/update` — self-update Pi + refresh extensions |
-| `pix-commands` | `/diff` and `/clear` slash commands |
+| `pix-commands` | `/clear` slash command |
 | `pix-diagnostics` | Compact LSP diagnostic widget |
 | `pix-prompts` | System-prompt injection (AGENTS.md + repo directive files) |
-| `pix-skills` | Agent skill loader (`read_skills` tool + 23 bundled skills) |
+| `pix-skills` | Agent skill loader (`read_skills` tool + 28 bundled skills) |
 | `pix-nudge` | Tool + capability nudge hooks |
 
 **Tool suite** (drop-in replacements for Pi's built-in tools)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-core",
-	"version": "0.4.2",
+	"version": "0.4.4",
 	"description": "Pi extension bundle — installs and activates all core pix-* extensions",
 	"type": "module",
 	"main": "src/extension.ts",

package/src/once.test.ts

@@ -1,71 +1,112 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import registerTodo from "@xynogen/pix-todo/src/todo.ts";
 
-// Mirror of the per-member guard. pix-core does not own once.ts (each member
+// Mirror of the per-instance guard. pix-core does not own once.ts (each member
 // duplicates it to stay cross-dep-free), so we re-declare the contract here and
 // assert the dedupe semantics that the aggregator relies on.
-function once(key: string, fn: () => void): void {
-	const g = globalThis as { __pixLoaded?: Set<string> };
-	const loaded = (g.__pixLoaded ??= new Set<string>());
+function once(pi: object, key: string, fn: () => void): void {
+	const g = globalThis as { __pixOnce?: WeakMap<object, Set<string>> };
+	const registry = (g.__pixOnce ??= new WeakMap<object, Set<string>>());
+	let loaded = registry.get(pi);
+	if (!loaded) {
+		loaded = new Set<string>();
+		registry.set(pi, loaded);
+	}
 	if (loaded.has(key)) return;
 	loaded.add(key);
 	fn();
 }
 
 afterEach(() => {
-	delete (globalThis as { __pixLoaded?: Set<string> }).__pixLoaded;
+	delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
 });
 
 describe("once", () => {
 	it("runs the factory on first invocation", () => {
+		const pi = {};
 		let calls = 0;
-		once("pix-footer", () => {
+		once(pi, "pix-footer", () => {
 			calls++;
 		});
 		expect(calls).toBe(1);
 	});
 
-	it("skips repeated invocations of the same key", () => {
+	it("skips repeated invocations of the same key on the same pi", () => {
+		const pi = {};
 		let calls = 0;
 		const reg = () => {
 			calls++;
 		};
-		once("pix-footer", reg);
-		once("pix-footer", reg);
-		once("pix-footer", reg);
+		once(pi, "pix-footer", reg);
+		once(pi, "pix-footer", reg);
+		once(pi, "pix-footer", reg);
 		expect(calls).toBe(1);
 	});
 
-	it("isolates distinct keys", () => {
+	it("isolates distinct keys on the same pi", () => {
+		const pi = {};
 		const seen: string[] = [];
-		once("pix-footer", () => seen.push("footer"));
-		once("pix-welcome", () => seen.push("welcome"));
+		once(pi, "pix-footer", () => seen.push("footer"));
+		once(pi, "pix-welcome", () => seen.push("welcome"));
 		expect(seen).toEqual(["footer", "welcome"]);
 	});
 
-	it("shares the registry across calls via globalThis", () => {
+	it("shares the registry across calls via globalThis (same pi)", () => {
+		const pi = {};
 		let calls = 0;
-		once("pix-skills", () => {
+		once(pi, "pix-skills", () => {
 			calls++;
 		});
 		// A second loader pass (e.g. standalone install after pix-core) reuses
-		// the same globalThis registry and must not re-run.
-		once("pix-skills", () => {
+		// the same globalThis registry for the same pi and must not re-run.
+		once(pi, "pix-skills", () => {
 			calls++;
 		});
 		expect(calls).toBe(1);
-		expect(
-			(globalThis as { __pixLoaded?: Set<string> }).__pixLoaded?.has(
-				"pix-skills",
-			),
-		).toBe(true);
+	});
+
+	it("re-runs for a new pi instance with the same key (/new rehydration)", () => {
+		const pi1 = {};
+		const pi2 = {};
+		let calls = 0;
+		once(pi1, "pix-footer", () => {
+			calls++;
+		});
+		// pi2 is a fresh instance (as built by Pi on /new, /resume, /fork, /reload).
+		// The factory must run again — this is the rehydration guarantee.
+		once(pi2, "pix-footer", () => {
+			calls++;
+		});
+		expect(calls).toBe(2);
+	});
+
+	it("same key on two different pi instances dedupes within each instance", () => {
+		const pi1 = {};
+		const pi2 = {};
+		let calls1 = 0;
+		let calls2 = 0;
+		once(pi1, "pix-welcome", () => {
+			calls1++;
+		});
+		once(pi1, "pix-welcome", () => {
+			calls1++;
+		}); // second on pi1 → skip
+		once(pi2, "pix-welcome", () => {
+			calls2++;
+		});
+		once(pi2, "pix-welcome", () => {
+			calls2++;
+		}); // second on pi2 → skip
+		expect(calls1).toBe(1); // deduped within pi1
+		expect(calls2).toBe(1); // deduped within pi2
 	});
 });
 
 // Behavior pin: prove a REAL guarded member dedupes when its factory runs
-// twice — the exact scenario the aggregator creates when a tool is installed
-// both via pix-core (this boots it) and standalone (Pi boots it again). The
-// member must register its tool only once or Pi reports a tool conflict.
+// twice against the SAME pi — the exact scenario the aggregator creates when a
+// tool is installed both via pix-core (this boots it) and standalone (Pi boots
+// it again). The member must register its tool only once or Pi reports a
+// tool conflict.
 describe("member factory dedupe (pix-todo)", () => {
 	function makeHost() {
 		const toolNames: string[] = [];
@@ -79,7 +120,7 @@ describe("member factory dedupe (pix-todo)", () => {
 		return { pi, toolNames };
 	}
 
-	it("registers the tool once across core + standalone activation", () => {
+	it("registers the tool once across core + standalone activation (same pi)", () => {
 		const { pi, toolNames } = makeHost();
 		// First pass: pix-core's aggregator invokes the member factory.
 		registerTodo(pi);
@@ -88,4 +129,15 @@ describe("member factory dedupe (pix-todo)", () => {
 		registerTodo(pi);
 		expect(toolNames).toEqual(["todo"]);
 	});
+
+	it("registers the tool again for a fresh pi instance (/new rehydration)", () => {
+		const { pi: pi1, toolNames: tools1 } = makeHost();
+		const { pi: pi2, toolNames: tools2 } = makeHost();
+		// First session.
+		registerTodo(pi1);
+		// /new: a fresh pi is built; factory must run again.
+		registerTodo(pi2);
+		expect(tools1).toEqual(["todo"]);
+		expect(tools2).toEqual(["todo"]);
+	});
 });