bigpowers 2.88.0 → 2.88.1

package/.gemini/extensions/bigpowers/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.0",
+  "version": "2.88.1",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "gemini-extension"

package/.pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.0",
+  "version": "2.88.1",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "pi-package"

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [2.88.1](https://github.com/danielvm-git/bigpowers/compare/v2.88.0...v2.88.1) (2026-09-05)
+
+
+### Bug Fixes
+
+* **extensions:** prevent omp-hooks from crashing pi at startup ([#119](https://github.com/danielvm-git/bigpowers/issues/119)) ([a487565](https://github.com/danielvm-git/bigpowers/commit/a487565160cbb20fae7ee8d85504898186fbe167))
+
 # [2.88.0](https://github.com/danielvm-git/bigpowers/compare/v2.87.8...v2.88.0) (2026-09-01)
 
 

package/extensions/omp-hooks.ts

@@ -2,7 +2,8 @@
 // extensions/omp-hooks.ts
 // bigpowers — Single OMP extension entry exposing every source skill as a
 // slash command, a bigpowers_skill LLM tool, and safety policy guards.
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
 import { execSync } from "node:child_process";
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -236,9 +237,12 @@ async function injectSkillPrompt(
 // ---------------------------------------------------------------------------
 
 export default function bigpowers(pi: ExtensionAPI) {
-  const z = pi.zod;
-
-  pi.setLabel("bigpowers");
+  // NOTE: Do not call action methods (setLabel, sendUserMessage, setModel, …)
+  // in the factory body. pi installs throwing stubs for them during extension
+  // loading and only binds real implementations afterward — a load-time call
+  // aborts the whole pi startup (BUG-2026-09-05, #119). Only registration
+  // methods (registerCommand/registerTool/on/registerFlag) are valid here;
+  // perform actions inside event/command handlers via the runtime-bound `pi`.
 
   // Discover skills from skills/ in the installed plugin package root.
   const skills = discoverSkills(join(pluginRoot(), "skills"));
@@ -262,18 +266,24 @@ export default function bigpowers(pi: ExtensionAPI) {
     label: "Bigpowers Skill",
     description:
       "Interact with bigpowers source skills. Use 'list' to enumerate available skills, 'get' to retrieve a skill's full markdown, and 'run' to activate a skill with arguments.",
-    parameters: z.object({
-      action: z
-        .enum(["list", "get", "run"])
-        .describe("Operation: list all skills, get one skill, or run a skill with arguments"),
-      skill: z
-        .string()
-        .optional()
-        .describe("Skill name — required for 'get' and 'run' actions"),
-      args: z
-        .string()
-        .optional()
-        .describe("User arguments passed to the skill — only used with 'run'"),
+    parameters: Type.Object({
+      action: Type.Union(
+        [Type.Literal("list"), Type.Literal("get"), Type.Literal("run")],
+        {
+          description:
+            "Operation: list all skills, get one skill, or run a skill with arguments",
+        },
+      ),
+      skill: Type.Optional(
+        Type.String({
+          description: "Skill name — required for 'get' and 'run' actions",
+        }),
+      ),
+      args: Type.Optional(
+        Type.String({
+          description: "User arguments passed to the skill — only used with 'run'",
+        }),
+      ),
     }),
     async execute(_id, params, _signal, _onUpdate, _ctx) {
       const { action, skill: skillName, args } = params;

package/package.json

@@ -1,13 +1,8 @@
 {
   "name": "bigpowers",
-  "version": "2.88.0",
+  "version": "2.88.1",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
-  "omp": {
-    "extensions": [
-      "extensions/omp-hooks.ts"
-    ]
-  },
   "scripts": {
     "setup": "node bin/setup.js",
     "compliance": "bash scripts/audit-compliance.sh specs/verifications/features && bash scripts/validate-doctrine.sh && python3 scripts/check-skill-links.py",
@@ -34,6 +29,9 @@
     "pi-package"
   ],
   "pi": {
+    "extensions": [
+      "extensions/omp-hooks.ts"
+    ],
     "skills": [
       "./.pi/skills"
     ],
@@ -69,6 +67,7 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^11.0.1",
     "@semantic-release/npm": "^12.0.1",
-    "semantic-release": "^24.2.0"
+    "semantic-release": "^24.2.0",
+    "typebox": "^1.3.7"
   }
 }

package/scripts/omp-smoke.ts

@@ -2,52 +2,86 @@
 // Runtime smoke for extensions/omp-hooks.ts.
 // Imports the extension, registers a fake ExtensionAPI, calls registered hooks,
 // and asserts the slash-command handler awaits injection.
+//
+// Load-phase contract (BUG-2026-09-05, #119): pi installs throwing stubs for
+// ACTION methods during extension loading and only binds real implementations
+// after the factory returns. Registration methods are valid during load. This
+// fake models that contract so a load-time action call (e.g. pi.setLabel())
+// fails here exactly as it does in real pi, instead of silently passing.
+// See pi 0.85.1 src/core/extensions/loader.ts (createExtensionRuntime).
 
 import bigpowers from "../extensions/omp-hooks.ts";
 
 type AnyObj = Record<string, unknown>;
 type Listener = (...args: unknown[]) => unknown;
 
-function makeZod(): AnyObj {
-  const chainable: AnyObj = {};
-  chainable.optional = () => chainable;
-  chainable.describe = () => chainable;
-  return chainable;
-}
+// pi's verbatim message when an action method is called during load.
+const LOAD_PHASE_ERROR =
+  "Extension runtime not initialized. Action methods cannot be called during extension loading.";
+
+// True while the factory body runs. Action methods throw while this is set.
+let loading = true;
 
 const commands = new Map<string, { description: string; handler: Listener }>();
 const tools: AnyObj[] = [];
 const events = new Map<string, Listener>();
 const sendCalls: AnyObj[] = [];
 
+// Action method: rejects if invoked during the loading phase, like real pi.
+function action<T extends Listener>(fn: T): T {
+  return ((...args: unknown[]) => {
+    if (loading) throw new Error(LOAD_PHASE_ERROR);
+    return fn(...args);
+  }) as T;
+}
+
 const pi: AnyObj = {
-  setLabel: () => {},
-  zod: {
-    object: (_shape: AnyObj) => makeZod(),
-    string: () => makeZod(),
-    enum: () => makeZod(),
-  },
+  // ----- Registration methods: valid during load -----
   registerCommand: (name: string, spec: { description: string; handler: Listener }) => {
     commands.set(name, spec);
   },
   registerTool: (tool: AnyObj) => {
     tools.push(tool);
   },
+  registerShortcut: (_shortcut: string, _opts: AnyObj) => {},
+  registerFlag: (_name: string, _opts: AnyObj) => {},
   on: (event: string, handler: Listener) => {
     events.set(event, handler);
   },
-  sendUserMessage: async (content: string, opts?: { deliverAs?: string }) => {
+  // registerProvider() calls made in the factory are queued by real pi, not
+  // thrown — model that as a permissive no-op.
+  registerProvider: (..._args: unknown[]) => {},
+
+  // ----- Action methods: throw if called during load -----
+  setLabel: action((_entryId: string, _label?: string) => {}),
+  setSessionName: action((_name: string) => {}),
+  getSessionName: action(() => undefined),
+  appendEntry: action((_customType: string, _data?: unknown) => {}),
+  setModel: action(() => Promise.resolve(true)),
+  getActiveTools: action(() => [] as string[]),
+  getAllTools: action(() => [] as AnyObj[]),
+  setActiveTools: action((_names: string[]) => {}),
+  getCommands: action(() => [] as AnyObj[]),
+  getThinkingLevel: action(() => "off"),
+  setThinkingLevel: action((_level: string) => {}),
+  sendUserMessage: action(async (content: string, opts?: { deliverAs?: string }) => {
     sendCalls.push({ kind: "sendUserMessage", content, opts });
     return undefined;
-  },
-  sendMessage: async (msg: AnyObj, opts?: { triggerTurn?: boolean; deliverAs?: string }) => {
+  }),
+  sendMessage: action(async (msg: AnyObj, opts?: { triggerTurn?: boolean; deliverAs?: string }) => {
     sendCalls.push({ kind: "sendMessage", msg, opts });
     return undefined;
-  },
+  }),
 };
 
+// Load the extension under the load-phase contract. A load-time action call
+// throws here and fails the smoke test (RED), matching pi's startup abort.
 await bigpowers(pi as unknown as never);
 
+// Factory returned successfully: the runtime is now "bound". Action methods
+// are callable from here on (handlers, tool executions).
+loading = false;
+
 console.log(JSON.stringify({
   commands: commands.size,
   tool: tools[0]?.name,

package/scripts/validate-omp-extension.sh

@@ -19,20 +19,22 @@ pass() {
   echo "ok  : $*"
 }
 
-# ── 1. Package has exactly one omp.extensions entry ────────────────────────
+# ── 1. Package has exactly one pi.extensions entry ─────────────────────────
+# pi reads extension paths from the `pi` manifest key (readPiManifest). The
+# legacy `omp.extensions` key was never consumed by pi — see BUG-2026-09-05.
 echo "--- [OMP] manifest: single extension entry ---"
-EXT_COUNT=$(node -e "const p = require('./package.json'); const exts = p.omp?.extensions; if (!exts) { console.log(0); } else { console.log(exts.length); }")
+EXT_COUNT=$(node -e "const p = require('./package.json'); const exts = p.pi?.extensions; if (!exts) { console.log(0); } else { console.log(exts.length); }")
 if [[ "$EXT_COUNT" -eq 1 ]]; then
-  pass "omp.extensions has exactly 1 entry"
+  pass "pi.extensions has exactly 1 entry"
 else
-  fail "omp.extensions has $EXT_COUNT entries (expected 1)"
+  fail "pi.extensions has $EXT_COUNT entries (expected 1)"
 fi
 
 # ── 2. Extension file exists ───────────────────────────────────────────────
 echo "--- [OMP] extension file exists ---"
-EXT_PATH=$(node -e "const p = require('./package.json'); console.log(p.omp?.extensions?.[0] || '')")
+EXT_PATH=$(node -e "const p = require('./package.json'); console.log(p.pi?.extensions?.[0] || '')")
 if [[ -z "$EXT_PATH" ]]; then
-  fail "No omp.extensions entry found"
+  fail "No pi.extensions entry found"
 else
   if [[ -f "$EXT_PATH" ]]; then
     pass "extension file '$EXT_PATH' exists"
@@ -93,6 +95,27 @@ if [[ -n "$EXT_PATH" && -f "$EXT_PATH" ]]; then
   fi
 fi
 
+# ── 6. Runtime load smoke (load-phase contract, BUG-2026-09-05) ────────────
+# Loads the extension through a fake ExtensionAPI that models pi's load-phase
+# guard: action methods (setLabel, sendUserMessage, …) throw during the factory
+# body, exactly as real pi does. Catches load-time action calls that abort pi
+# startup (#119). Requires a Node with TypeScript type-stripping (>=22.6).
+echo "--- [OMP] runtime load smoke (scripts/omp-smoke.ts) ---"
+SMOKE="$REPO_ROOT/scripts/omp-smoke.ts"
+if [[ ! -f "$SMOKE" ]]; then
+  fail "omp-smoke.ts not found at $SMOKE"
+elif ! command -v node >/dev/null 2>&1; then
+  echo "warn: node unavailable — skipping runtime load smoke"
+else
+  SMOKE_ERR=$(mktemp)
+  if node "$SMOKE" >/dev/null 2>"$SMOKE_ERR"; then
+    pass "extension loads without calling action methods during load"
+  else
+    fail "runtime load smoke failed — $(head -3 "$SMOKE_ERR" 2>/dev/null | tr '\n' ' ')"
+  fi
+  rm -f "$SMOKE_ERR"
+fi
+
 # ── Summary ────────────────────────────────────────────────────────────────
 echo "---"
 if [[ "$ERRORS" -eq 0 ]]; then