pi-continual-harness 0.16.1 → 0.17.0

package/README.md

@@ -473,6 +473,17 @@ registerProposer({
 Then `"my-proposer"` is selectable via `/refine --proposer my-proposer` or
 `"proposer": "my-proposer"` in the config.
 
+**Cross-instance registry (0.17+).** pi's extension loader isolates module
+instances between extensions, so before 0.17.0 a companion's `registerProposer`
+call wrote to a private module copy that `/refine` never read — the
+registration was silently invisible. The registry is now backed by a
+process-wide global (`Symbol.for("pi-continual-harness.proposers")`), so any
+copy's registrations are visible to every copy. Companions that want a
+zero-import startup entry can skip importing this package at runtime entirely
+and push a `DeltaProposer` (typically a lazy delegate that dynamic-imports its
+implementation on first `propose()`) directly into
+`globalThis[Symbol.for("pi-continual-harness.proposers")]`.
+
 ## Scope and non-goals
 
 - **In scope:** unified state store, online `/refine`, structured deltas,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-continual-harness",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Online self-improvement layer for pi. A unified, in-trajectory harness-state store (prompt notes, memory, skill descriptions, sub-agent specs) with a manual /refine that proposes evidence-backed structured CRUD deltas. Composes with pi-reflect (offline) and pi-mem (storage); owns only the online optimizer layer. Inspired by Continual Harness (arXiv 2605.09998) and ACE (arXiv 2510.04618).",
   "keywords": [
     "pi-package",

package/src/proposer.ts

@@ -434,21 +434,55 @@ export const dedupeProposer: DeltaProposer = {
 
 // ---- registry -------------------------------------------------------------
 
-const registry = new Map<string, DeltaProposer>([
+// Cross-instance registry key (0.17.0). pi's extension loader isolates module
+// instances between extensions (a fresh jiti per extension load, module cache
+// off), so a companion package's `import { registerProposer } from
+// "pi-continual-harness"` resolves to a DIFFERENT copy of this module than the
+// one whose /refine reads the registry — a module-level Map made companion
+// registrations silently invisible. Backing the registry with a process-wide
+// global makes registration work no matter which copy each side holds.
+//
+// The string is the public contract: companions that avoid importing this
+// package at all (thin startup entries) can push a DeltaProposer straight into
+// `globalThis[Symbol.for("pi-continual-harness.proposers")]`.
+const REGISTRY_KEY = Symbol.for("pi-continual-harness.proposers");
+type ProposerRegistry = Map<string, DeltaProposer>;
+
+function globalRegistry(): ProposerRegistry {
+  const g = globalThis as Record<symbol, unknown>;
+  let r = g[REGISTRY_KEY] as ProposerRegistry | undefined;
+  if (!(r instanceof Map)) {
+    r = new Map<string, DeltaProposer>();
+    g[REGISTRY_KEY] = r;
+  }
+  return r;
+}
+
+// Built-ins stay module-local: they are pure functions of their input, and
+// keeping them off the shared map means two isolated harness copies never hand
+// each other's closures to /refine. External registrations live ONLY in the
+// shared map, so every copy can see them.
+const builtins = new Map<string, DeltaProposer>([
   ["steering", steeringProposer],
   ["dedupe", dedupeProposer],
 ]);
 
-/** Register (or replace) a named proposer. For external extensions. */
+/** Register (or replace) a named proposer. For external extensions. Writes to
+ *  the process-wide registry (Symbol.for("pi-continual-harness.proposers")),
+ *  so it takes effect across pi's per-extension module isolation. */
 export function registerProposer(p: DeltaProposer): void {
-  registry.set(p.name, p);
+  globalRegistry().set(p.name, p);
 }
 
 /** Look up a proposer by name; falls back to the steering default. */
 export function getProposer(name: string | undefined): DeltaProposer {
-  return registry.get(name ?? "steering") ?? steeringProposer;
+  const key = name ?? "steering";
+  const custom = globalRegistry().get(key);
+  // Defensive: the shared map can be written by anyone in the process.
+  if (custom && typeof custom.propose === "function") return custom;
+  return builtins.get(key) ?? steeringProposer;
 }
 
 export function listProposers(): string[] {
-  return [...registry.keys()];
+  return [...new Set([...builtins.keys(), ...globalRegistry().keys()])];
 }