@herbertgao/pi-extensions 2026.8.14 → 2026.8.15

package/README.md

@@ -8,33 +8,36 @@ Aggregate installer for HerbertGao-maintained Pi extensions and pinned upstream
 pi install npm:@herbertgao/pi-extensions
 ```
 
-Requires Node.js 24 or newer.
+Requires Node.js 24 or newer and Pi 0.84.4 or newer.
 
-The package bundles 3 active `@herbertgao/*` child packages—`pi-cc-extensions`, `resume-from`, and `pi-subagents`—plus the following upstream packages under their original names:
+The package bundles 4 active `@herbertgao/*` child packages—`pi-bark`, `pi-cc-extensions`, `resume-from`, and `pi-subagents`—plus the following upstream packages under their original names:
 
 - `@dietrichgebert/ponytail@4.9.0`
-- `@juicesharp/rpiv-ask-user-question@2.7.1`
+- `@juicesharp/rpiv-ask-user-question@2.8.0`
 - `@luxusai/pi-hindsight@0.12.0`
-- `@narumitw/pi-btw@0.55.4`
+- `@narumitw/pi-btw@0.56.0`
 - `@pi-plugins/fast-mode@0.1.10`
 - `@tifan/pi-copy-response@0.2.6`
-- `@tifan/pi-handoff@2.0.1`
+- `@tifan/pi-handoff@2.2.0`
 - `@tifan/pi-inline-skills@1.0.5`
 - `@tifan/pi-mermaid-open@0.2.0`
 - `@tifan/pi-preferred-thinking@1.0.1`
-- `@tifan/pi-recap@0.4.5`
-- `@tifan/pi-rename@0.5.1`
-- `@tifan/pi-titlebar-spinner@0.1.3`
-- `pi-mcp-adapter@2.30.0`
+- `@tifan/pi-recap@0.4.6`
+- `@tifan/pi-rename@0.6.0`
+- `pi-mcp-adapter@2.31.0`
 - `pi-footer@0.5.1`
-- `pi-lens@4.1.2`
-- `pi-web-access@0.26.0`
+- `pi-lens@4.1.3`
+- `pi-web-access@0.27.0`
 - `remote-pi@0.7.0`
-- `@czottmann/pi-automode@1.14.0`
+- `@czottmann/pi-automode@1.15.0`
 
 Pi loads their extensions and skills through `node_modules/` paths inside one package root. The upstream companions are pinned and bundled, not forked or renamed.
 
-`@herbertgao/resume-from@0.2.0` keeps Claude Code sessions associated with their original repository when the active transcript later moves into a nested cwd. `pi-lens@4.1.2` improves delayed LSP diagnostics, stale-result cleanup, process cleanup, and snapshot completeness. `pi-automode@1.14.0` bounds classifier streams and permits only validated temporary-directory subtrees. `pi-web-access@0.26.0` adds explicit XCrawl search plus safer query and extraction fallbacks. Preferred Thinking 1.0.1 preserves an explicit subagent `--thinking` choice.
+### Bark notifications
+
+`@herbertgao/pi-bark` sends localized Bark pushes when a user-facing Pi run fully settles or `@juicesharp/rpiv-ask-user-question` needs an answer. Notifications include emoji-labeled machine/path metadata and support the bundled official Pi badge through Bark's `icon` parameter. Configure it in `$PI_CODING_AGENT_DIR/bark.json` (normally `~/.pi/agent/bark.json`); see the [package README](../pi-bark/README.md). Without a valid endpoint it stays inactive.
+
+`@herbertgao/resume-from@0.2.0` keeps Claude Code sessions associated with their original repository when the active transcript later moves into a nested cwd. `pi-lens@4.1.3` expands language routing and bounds retained diagnostic facts across multi-root sessions. `pi-automode@1.15.0` preserves dynamic providers on legacy registries. `pi-web-access@0.27.0` adds configurable fetch deadlines and answer models plus isolated GitHub clone runtimes. Preferred Thinking 1.0.1 preserves an explicit subagent `--thinking` choice. Deprecated `@tifan/pi-titlebar-spinner` is no longer bundled; Rename remains the single owner of Herdr tab naming.
 
 `pi-stash` is no longer bundled: `/btw` already preserves the main editor draft while handling side questions outside the main conversation. Prior `@herbertgao/pi-stash` releases remain available but are no longer maintained here.
 

package/THIRD_PARTY_NOTICES.md

@@ -9,7 +9,6 @@ The aggregate package bundles the following packages from [tifandotme/pi-extensi
 - `@tifan/pi-preferred-thinking`
 - `@tifan/pi-recap`
 - `@tifan/pi-rename`
-- `@tifan/pi-titlebar-spinner`
 
 They are distributed under the following MIT license:
 

package/node_modules/@czottmann/pi-automode/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [1.15.0] - 2026-08-28
+
+## Bug fixes
+
+- **OMP 18 classifier compatibility** — Support OMP 18 model registries that lack `complete()` and `getProvider()`. Load the legacy completion API only for these registries. Keep current Pi on its runtime registry path so extension-registered providers remain available. Thanks, @NarryG! (#29)
+
 ## [1.14.0] - 2026-08-27
 
 ## Bug fixes
@@ -45,7 +51,8 @@ All notable changes to this project are documented in this file.
 - **Project config trust gate** — Ignore `.pi/automode.local.json` and `.pi/automode.json` until Pi trusts the project. Apply the trust gate during startup and config reloads. (#16)
 - **In-memory observability logs** — Write logs to an extension-owned directory (`~/.pi/agent/extensions/pi-automode/logs/`) instead of the launching project directory. Thanks, @HerbertGao! (#13)
 
-[Unreleased]: https://github.com/czottmann/pi-automode/compare/v1.14.0...HEAD
+[Unreleased]: https://github.com/czottmann/pi-automode/compare/v1.15.0...HEAD
+[1.15.0]: https://github.com/czottmann/pi-automode/compare/v1.14.0...v1.15.0
 [1.14.0]: https://github.com/czottmann/pi-automode/compare/v1.13.0...v1.14.0
 [1.13.0]: https://github.com/czottmann/pi-automode/compare/v1.12.0...v1.13.0
 [1.12.0]: https://github.com/czottmann/pi-automode/compare/v1.11.0...v1.12.0

package/node_modules/@czottmann/pi-automode/README.md

@@ -8,6 +8,10 @@ It is not a sandbox. Extensions run in the Pi process. A malicious extension can
 
 Pi-automode does not guard user `!` or `!!` shell commands. It guards only agent tool calls. Use it to reduce unsafe autonomous tool use. Do not use it as an OS security boundary.
 
+## Compatibility
+
+Pi-automode supports Pi and Oh My Pi (OMP) 18. It automatically uses OMP's legacy completion API. The integration needs no OMP-specific configuration.
+
 ## Install
 
 From npm:

package/node_modules/@czottmann/pi-automode/extensions/auto-mode/classifier.ts

@@ -84,10 +84,9 @@ async function resolveClassifier(
     };
   }
 
-  const rawComplete: ClassifierCompletionFn = (callModel, context, options) =>
-    ctx.modelRegistry.complete(callModel, context, options);
-  const simpleComplete: ClassifierCompletionFn = (callModel, context, options) =>
-    completeSimpleWithRegistry(ctx, callModel, context, options);
+  const { rawComplete, simpleComplete } = createRegistryCompletionFns(
+    ctx.modelRegistry,
+  );
   const completionPlan = createClassifierCompletionPlan(
     model,
     config.classifierReasoningLevel,
@@ -125,6 +124,70 @@ export type ClassifierCompletionFn = (
   },
 ) => Promise<AssistantMessage>;
 
+type RegistryCompletionApi = {
+  complete?: ClassifierCompletionFn;
+  getProvider?: (provider: string) => {
+    streamSimple: (
+      model: Model<any>,
+      context: { systemPrompt: string; messages: UserMessage[] },
+      options: Parameters<ClassifierCompletionFn>[2],
+    ) => { result: () => Promise<AssistantMessage> };
+  } | undefined;
+};
+type ClassifierCompletionFallbacks = {
+  rawComplete: ClassifierCompletionFn;
+  simpleComplete: ClassifierCompletionFn;
+};
+
+type ClassifierCompletionFallbackLoader =
+  () => Promise<ClassifierCompletionFallbacks>;
+
+// Static import would initialize deprecated compat registries on current Pi;
+// OMP rewrites this literal dynamic import to its native pi-ai module.
+async function loadCompatCompletionFns(): Promise<ClassifierCompletionFallbacks> {
+  const { complete, completeSimple } = await import(
+    "@earendil-works/pi-ai/compat"
+  );
+  return {
+    rawComplete: complete as ClassifierCompletionFn,
+    simpleComplete: completeSimple as ClassifierCompletionFn,
+  };
+}
+
+/**
+ * Prefer the current runtime registry so extension-registered providers remain
+ * visible. Older Pi-family runtimes (including OMP 18) expose neither
+ * `complete` nor `getProvider`; lazily load the compat API they already use.
+ */
+export function createRegistryCompletionFns(
+  registry: RegistryCompletionApi,
+  fallbackLoader: ClassifierCompletionFallbackLoader =
+    loadCompatCompletionFns,
+): ClassifierCompletionFallbacks {
+  let fallbackPromise: Promise<ClassifierCompletionFallbacks> | undefined;
+  const rawComplete: ClassifierCompletionFn =
+    typeof registry.complete === "function"
+      ? (model, context, options) =>
+        registry.complete!.call(registry, model, context, options)
+      : async (model, context, options) =>
+        (await (fallbackPromise ??= fallbackLoader())).rawComplete(
+          model,
+          context,
+          options,
+        );
+  const simpleComplete: ClassifierCompletionFn =
+    typeof registry.getProvider === "function"
+      ? (model, context, options) =>
+        completeSimpleWithRegistry(registry, model, context, options)
+      : async (model, context, options) =>
+        (await (fallbackPromise ??= fallbackLoader())).simpleComplete(
+          model,
+          context,
+          options,
+        );
+  return { rawComplete, simpleComplete };
+}
+
 export type RetryOptions = {
   maxAttempts?: number;
   maxTokens?: number;
@@ -206,17 +269,16 @@ async function completeClassifierAttempt(
 
 /**
  * Run normalized Pi AI completion through the provider in Pi's runtime registry.
- * This temporary bridge is only valid until Pi exposes
- * `ctx.modelRegistry.completeSimple(...)` natively. Replace this function with
- * that API when the project's minimum supported Pi version includes it.
+ * Callers use this only when the registry exposes `getProvider`; legacy
+ * registries take the compat completion path instead.
  */
 async function completeSimpleWithRegistry(
-  ctx: ExtensionContext,
+  registry: RegistryCompletionApi,
   model: Model<any>,
   context: { systemPrompt: string; messages: UserMessage[] },
   options: Parameters<ClassifierCompletionFn>[2],
 ): Promise<AssistantMessage> {
-  const provider = ctx.modelRegistry.getProvider(model.provider);
+  const provider = registry.getProvider?.(model.provider);
   if (!provider) throw new Error(`Unknown provider: ${model.provider}`);
   return provider.streamSimple(model, context, options).result();
 }

package/node_modules/@czottmann/pi-automode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"

package/node_modules/@herbertgao/pi-bark/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Herbert Gao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@herbertgao/pi-bark/README.md

@@ -0,0 +1,44 @@
+# @herbertgao/pi-bark
+
+Bark notifications for user-facing Pi sessions. It sends a notification when Pi fully settles and when [`@juicesharp/rpiv-ask-user-question`](https://github.com/juicesharp/rpiv-mono) opens a questionnaire. Requests follow Bark's official [POST form API](https://github.com/Finb/Bark/blob/master/docs/en-us/tutorial.md#request-methods).
+
+## Install
+
+```bash
+pi install npm:@herbertgao/pi-bark
+```
+
+The extension is also included in `@herbertgao/pi-extensions`.
+
+## Configure
+
+Create `$PI_CODING_AGENT_DIR/bark.json` (normally `~/.pi/agent/bark.json`):
+
+```json
+{
+  "endpoint": "https://api.day.app/your-device-key",
+  "machine": "MacBook Pro M1 Max",
+  "locale": "zh-CN",
+  "events": {
+    "agentSettled": true,
+    "askUserQuestion": true
+  },
+  "params": {
+    "group": "pi",
+    "icon": "https://raw.githubusercontent.com/HerbertGao/pi-extensions/master/packages/pi-bark/assets/pi-icon.png"
+  },
+  "timeoutMs": 4000
+}
+```
+
+`endpoint` is required. `locale` accepts `auto` (default), `zh-CN`, `zh-TW`, or `en`; unsupported languages fall back to English. `params` accepts additional Bark POST parameters such as `group`, `sound`, `icon`, and `level`; dynamic `title` and `body` values always take precedence. Set `"enabled": false` to disable all notifications without removing the package.
+
+The notification body uses `💻` for the configured machine name and `📁` for Pi's full working directory. Questionnaire text is intentionally not sent because it may contain sensitive context. Only sessions with a user-facing UI notify, so nested `pi-subagents` sessions do not create duplicate pushes.
+
+The bundled [`assets/pi-icon.png`](assets/pi-icon.png) is a 512×512 rasterization of Pi's official [square badge](https://pi.dev/favicon.svg) from the [Pi Press Kit](https://pi.dev/press-kit), suitable for Bark's iOS 15+ `icon` parameter.
+
+Keep `bark.json` private because the endpoint normally contains the Bark device key. Restart Pi or run `/reload` after changing it.
+
+## License
+
+[MIT](LICENSE)

package/node_modules/@herbertgao/pi-bark/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@herbertgao/pi-bark",
+  "version": "0.1.0",
+  "description": "Send Bark notifications when Pi finishes or needs user input.",
+  "keywords": [
+    "bark",
+    "notifications",
+    "pi-extension",
+    "pi-package"
+  ],
+  "homepage": "https://github.com/HerbertGao/pi-extensions/tree/master/packages/pi-bark#readme",
+  "bugs": {
+    "url": "https://github.com/HerbertGao/pi-extensions/issues"
+  },
+  "license": "MIT",
+  "author": "Herbert Gao",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HerbertGao/pi-extensions.git",
+    "directory": "packages/pi-bark"
+  },
+  "files": [
+    "assets",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "test": "node --test tests/**/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.84.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "x-origin": "original"
+}

package/node_modules/@herbertgao/pi-bark/src/index.ts

@@ -0,0 +1,178 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { readFileSync } from "node:fs"
+import { homedir, hostname } from "node:os"
+import { join } from "node:path"
+
+const ASK_USER_PROMPT_EVENT = "rpiv:ask-user:prompt"
+const DEFAULT_TIMEOUT_MS = 4_000
+
+export type BarkLocale = "en" | "zh-CN" | "zh-TW"
+type NotificationEvent = "agentSettled" | "askUserQuestion"
+
+const COPY: Record<BarkLocale, Record<NotificationEvent, string>> = {
+  en: {
+    agentSettled: "✅ Pi finished",
+    askUserQuestion: "🟡 Pi needs your input",
+  },
+  "zh-CN": {
+    agentSettled: "✅ Pi 跑完了",
+    askUserQuestion: "🟡 Pi 等你回答",
+  },
+  "zh-TW": {
+    agentSettled: "✅ Pi 已完成",
+    askUserQuestion: "🟡 Pi 等你回覆",
+  },
+}
+
+export interface BarkConfig {
+  endpoint: string
+  machine: string
+  locale: BarkLocale
+  events: {
+    agentSettled: boolean
+    askUserQuestion: boolean
+  }
+  params: Record<string, string | number | boolean>
+  timeoutMs: number
+}
+
+export function getConfigPath(): string {
+  return join(
+    process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"),
+    "bark.json",
+  )
+}
+
+export function resolveLocale(input: unknown): BarkLocale {
+  const requested =
+    typeof input === "string" && input.toLowerCase() !== "auto"
+      ? input
+      : Intl.DateTimeFormat().resolvedOptions().locale
+  const locale = requested.toLowerCase()
+  if (locale.includes("hant") || /^zh-(tw|hk|mo)/.test(locale)) return "zh-TW"
+  if (locale.startsWith("zh")) return "zh-CN"
+  return "en"
+}
+
+export function notificationTitle(
+  locale: BarkLocale,
+  event: NotificationEvent,
+): string {
+  return COPY[locale][event]
+}
+
+export function normalizeConfig(input: unknown): BarkConfig | undefined {
+  if (!input || typeof input !== "object") return undefined
+  const source = input as Record<string, unknown>
+  if (source.enabled === false || typeof source.endpoint !== "string")
+    return undefined
+
+  try {
+    const protocol = new URL(source.endpoint).protocol
+    if (protocol !== "http:" && protocol !== "https:") return undefined
+  } catch {
+    return undefined
+  }
+
+  const eventSource =
+    source.events && typeof source.events === "object"
+      ? (source.events as Record<string, unknown>)
+      : {}
+  const params =
+    source.params && typeof source.params === "object"
+      ? Object.fromEntries(
+          Object.entries(source.params).filter((entry) =>
+            ["string", "number", "boolean"].includes(typeof entry[1]),
+          ),
+        )
+      : {}
+  const timeoutMs =
+    typeof source.timeoutMs === "number" &&
+    Number.isFinite(source.timeoutMs) &&
+    source.timeoutMs > 0
+      ? source.timeoutMs
+      : DEFAULT_TIMEOUT_MS
+
+  return {
+    endpoint: source.endpoint,
+    machine:
+      typeof source.machine === "string" && source.machine.trim()
+        ? source.machine.trim()
+        : hostname(),
+    locale: resolveLocale(source.locale),
+    events: {
+      agentSettled: eventSource.agentSettled !== false,
+      askUserQuestion: eventSource.askUserQuestion !== false,
+    },
+    params,
+    timeoutMs,
+  }
+}
+
+export function loadConfig(path = getConfigPath()): BarkConfig | undefined {
+  try {
+    return normalizeConfig(JSON.parse(readFileSync(path, "utf8")))
+  } catch {
+    return undefined
+  }
+}
+
+export function formatBody(config: BarkConfig, cwd: string): string {
+  return `💻 ${config.machine}\n📁 ${cwd}`
+}
+
+export async function sendBark(
+  config: BarkConfig,
+  title: string,
+  body: string,
+  fetcher: typeof fetch = fetch,
+): Promise<void> {
+  const form = new URLSearchParams()
+  for (const [key, value] of Object.entries(config.params))
+    form.set(key, String(value))
+  form.set("title", title)
+  form.set("body", body)
+
+  const response = await fetcher(config.endpoint, {
+    method: "POST",
+    body: form,
+    signal: AbortSignal.timeout(config.timeoutMs),
+  })
+  if (!response.ok) throw new Error(`Bark returned HTTP ${response.status}`)
+}
+
+export default function piBark(pi: ExtensionAPI): void {
+  let config: BarkConfig | undefined
+  let cwd = process.cwd()
+  let userFacingSession = false
+
+  const notify = async (title: string): Promise<void> => {
+    if (!config || !userFacingSession) return
+    try {
+      await sendBark(config, title, formatBody(config, cwd))
+    } catch {
+      // Notifications are best-effort and must never interrupt Pi.
+    }
+  }
+
+  const unsubscribeAskUser = pi.events.on(ASK_USER_PROMPT_EVENT, () => {
+    if (config?.events.askUserQuestion)
+      void notify(notificationTitle(config.locale, "askUserQuestion"))
+  })
+
+  pi.on("session_start", (_event, ctx) => {
+    config = loadConfig()
+    cwd = ctx.cwd
+    userFacingSession = ctx.hasUI
+  })
+
+  pi.on("agent_settled", (_event, ctx) => {
+    cwd = ctx.cwd
+    if (config?.events.agentSettled)
+      void notify(notificationTitle(config.locale, "agentSettled"))
+  })
+
+  pi.on("session_shutdown", () => {
+    unsubscribeAskUser()
+  })
+}

package/node_modules/@juicesharp/rpiv-ask-user-question/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@juicesharp/rpiv-ask-user-question",
-	"version": "2.7.1",
+	"version": "2.8.0",
 	"description": "Pi extension. A structured questionnaire the model can put to you when it would otherwise guess, with typed options instead of free-form replies.",
 	"keywords": [
 		"pi-package",
@@ -94,7 +94,7 @@
 		}
 	},
 	"dependencies": {
-		"@juicesharp/rpiv-config": "^2.7.1",
+		"@juicesharp/rpiv-config": "^2.8.0",
 		"typebox": "^1.1.24"
 	}
 }