@herbertgao/pi-extensions 2026.8.1 → 2026.8.3

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

@@ -83,6 +83,7 @@ import { SubagentScheduler } from "./schedule.js"
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js"
 import {
   applyAndEmitLoaded,
+  loadSettings,
   type SubagentsSettings,
   saveAndEmitChanged,
   type ToolDescriptionMode,
@@ -426,14 +427,18 @@ export default function (pi: ExtensionAPI) {
     },
   )
 
+  // This setting controls the initial load, which runs before the normal settings
+  // application below. Later per-call reloads deliberately remain tolerant.
+  let strictAgentFiles = loadSettings(process.cwd()).strictAgentFiles === true
+
   /** Reload agents from project/global custom agent dirs and merge with defaults (called on init and each Agent invocation). */
-  const reloadCustomAgents = () => {
-    const userAgents = loadCustomAgents(process.cwd())
+  const reloadCustomAgents = (strict = false) => {
+    const userAgents = loadCustomAgents(process.cwd(), strict)
     registerAgents(userAgents)
   }
 
-  // Initial load
-  reloadCustomAgents()
+  // Initial load — the only strict one.
+  reloadCustomAgents(strictAgentFiles)
 
   // ---- Agent activity tracking + widget ----
   const agentActivity = new Map<string, AgentActivity>()
@@ -990,6 +995,9 @@ export default function (pi: ExtensionAPI) {
       setDefaultJoinMode,
       setSchedulingEnabled,
       setScopeModels: setScopeModelsEnabled,
+      setStrictAgentFiles: (enabled) => {
+        strictAgentFiles = enabled
+      },
       setDisableDefaultAgents: setDisableDefaultAgents,
       setToolDescriptionMode: setToolDescriptionMode,
       setFleetView: setFleetViewEnabled,
@@ -1233,12 +1241,12 @@ Terse command-style prompts produce shallow, generic work.
         )
       },
 
-      renderResult(result, { expanded, isPartial }, theme) {
+      renderResult(result, { expanded, isPartial }, theme, renderContext) {
+        const resultText =
+          result.content[0]?.type === "text" ? result.content[0].text : ""
         const details = result.details as AgentDetails | undefined
-        if (!details) {
-          const text =
-            result.content[0]?.type === "text" ? result.content[0].text : ""
-          return new Text(text, 0, 0)
+        if (renderContext?.isError || !details?.status) {
+          return new Text(resultText, 0, 0)
         }
 
         // Helper: build "haiku · thinking: high · ↻5≤30 · 3 tool uses · 33.8k tokens" stats string
@@ -1293,8 +1301,6 @@ Terse command-style prompts produce shallow, generic work.
           line += " " + theme.fg("dim", "·") + " " + theme.fg("dim", duration)
 
           if (expanded) {
-            const resultText =
-              result.content[0]?.type === "text" ? result.content[0].text : ""
             if (resultText) {
               const lines = resultText.split("\n").slice(0, 50)
               for (const l of lines) {
@@ -1324,6 +1330,10 @@ Terse command-style prompts produce shallow, generic work.
           return new Text(line, 0, 0)
         }
 
+        if (details.status !== "error" && details.status !== "aborted") {
+          return new Text(resultText, 0, 0)
+        }
+
         // ---- Error / Aborted (hard max_turns) ----
         const s = stats(details)
         let line = theme.fg("error", "✗") + (s ? " " + s : "")
@@ -1590,23 +1600,22 @@ Terse command-style prompts produce shallow, generic work.
             }
           }
 
-          try {
-            id = manager.spawn(pi, ctx, subagentType, params.prompt, {
-              description: params.description,
-              model,
-              maxTurns: effectiveMaxTurns,
-              isolated,
-              inheritContext,
-              thinkingLevel: thinking,
-              isBackground: true,
-              isolation,
-              invocation: agentInvocation,
-              rootSessionId: ctx.sessionManager.getSessionId(),
-              ...bgCallbacks,
-            })
-          } catch (err) {
-            return textResult(err instanceof Error ? err.message : String(err))
-          }
+          // A throw here means the agent never started. Let it out: Pi marks a
+          // tool call failed only when execute throws, while a returned message
+          // reads to the model as a subagent that ran and reported this.
+          id = manager.spawn(pi, ctx, subagentType, params.prompt, {
+            description: params.description,
+            model,
+            maxTurns: effectiveMaxTurns,
+            isolated,
+            inheritContext,
+            thinkingLevel: thinking,
+            isBackground: true,
+            isolation,
+            invocation: agentInvocation,
+            rootSessionId: ctx.sessionManager.getSessionId(),
+            ...bgCallbacks,
+          })
 
           // Set output file + join mode synchronously after spawn, before the
           // event loop yields — onSessionCreated is async so this is safe.
@@ -1766,18 +1775,15 @@ Terse command-style prompts produce shallow, generic work.
             },
           )
           record = fgResult.record
-        } catch (err) {
+        } finally {
+          // A startup throw propagates as a failed tool call without leaving
+          // the spinner running or a finished agent in the widget.
           clearInterval(spinnerInterval)
-          return textResult(err instanceof Error ? err.message : String(err))
-        }
-
-        clearInterval(spinnerInterval)
-
-        // Clean up foreground agent from widget
-        if (fgId) {
-          agentActivity.delete(fgId)
-          widget.markFinished(fgId)
-          fleet.onAgentFinished(fgId)
+          if (fgId) {
+            agentActivity.delete(fgId)
+            widget.markFinished(fgId)
+            fleet.onAgentFinished(fgId)
+          }
         }
 
         // Get final token count
@@ -2673,6 +2679,7 @@ ${systemPrompt}
       defaultJoinMode: getDefaultJoinMode(),
       schedulingEnabled: isSchedulingEnabled(),
       scopeModels: isScopeModelsEnabled(),
+      strictAgentFiles,
       disableDefaultAgents: isDefaultsDisabled(),
       toolDescriptionMode: getToolDescriptionMode(),
       fleetView: isFleetViewEnabled(),
@@ -2762,6 +2769,14 @@ ${systemPrompt}
           currentValue: isScopeModelsEnabled() ? "on" : "off",
           values: ["on", "off"],
         },
+        {
+          id: "strictAgentFiles",
+          label: "Strict agent files",
+          description:
+            "Fail startup on an unreadable or unparseable agent .md instead of skipping it with a warning",
+          currentValue: strictAgentFiles ? "on" : "off",
+          values: ["on", "off"],
+        },
         {
           id: "disableDefaultAgents",
           label: "Disable defaults",
@@ -2867,6 +2882,13 @@ ${systemPrompt}
         const enabled = value === "on"
         setScopeModelsEnabled(enabled)
         notifyApplied(ctx, `Scope models ${enabled ? "enabled" : "disabled"}`)
+      } else if (id === "strictAgentFiles") {
+        const enabled = value === "on"
+        strictAgentFiles = enabled
+        notifyApplied(
+          ctx,
+          `Strict agent files ${enabled ? "enabled" : "disabled"}. Takes effect on next pi session.`,
+        )
       } else if (id === "disableDefaultAgents") {
         const enabled = value === "on"
         setDisableDefaultAgents(enabled)

package/node_modules/@herbertgao/pi-subagents/src/nested-tools.ts

@@ -399,47 +399,38 @@ export function createNestedSubagentTools(
       // one earlier would silently give a grandchild the wrong worktree base, the
       // wrong conversation under inherit_context, and the wrong inherited model.
       //
-      // spawn() throws on strict worktree-isolation failure and cwd validation —
-      // report it as a tool error, like the top-level Agent tool does, instead of
-      // letting it escape into the child's turn.
-      try {
-        if (invocation.runInBackground) {
-          const id = context.manager.spawn(
-            context.pi,
-            ctx,
-            resolvedType,
-            params.prompt,
-            {
-              ...options,
-              isBackground: true,
-            },
-          )
-          // Synchronous, before the event loop yields — onSessionCreated fires
-          // asynchronously inside runAgent, so the file is attached in time.
-          attachTranscript(id)
-          return textResult(
-            `Nested agent started in background. Agent ID: ${id}`,
-          )
-        }
-
-        const { record } = await context.manager.spawnAndWait(
+      // Startup throws mean no child ran. Let them propagate so Pi marks the
+      // nested Agent tool call failed instead of presenting the message as a
+      // successful child result.
+      if (invocation.runInBackground) {
+        const id = context.manager.spawn(
           context.pi,
           ctx,
           resolvedType,
           params.prompt,
-          { ...options, signal },
-          attachTranscript,
-        )
-        return textResult(
-          formatRecord(record, "inline"),
-          record.status === "error",
-        )
-      } catch (err) {
-        return textResult(
-          err instanceof Error ? err.message : String(err),
-          true,
+          {
+            ...options,
+            isBackground: true,
+          },
         )
+        // Synchronous, before the event loop yields — onSessionCreated fires
+        // asynchronously inside runAgent, so the file is attached in time.
+        attachTranscript(id)
+        return textResult(`Nested agent started in background. Agent ID: ${id}`)
       }
+
+      const { record } = await context.manager.spawnAndWait(
+        context.pi,
+        ctx,
+        resolvedType,
+        params.prompt,
+        { ...options, signal },
+        attachTranscript,
+      )
+      return textResult(
+        formatRecord(record, "inline"),
+        record.status === "error",
+      )
     },
   })
 

package/node_modules/@herbertgao/pi-subagents/src/prompts.ts

@@ -10,6 +10,8 @@ export interface PromptExtras {
   memoryBlock?: string
   /** Preloaded skill contents to inject. */
   skillBlocks?: { name: string; content: string }[]
+  /** Original checkout path when cwd is an isolated worktree copy. */
+  worktreeBase?: string
 }
 
 /**
@@ -55,6 +57,12 @@ Platform: ${env.platform}`
   }
   const extrasSuffix =
     extraSections.length > 0 ? "\n\n" + extraSections.join("\n") : ""
+  const worktreeSection = extras?.worktreeBase
+    ? `\n\n<worktree_isolation>
+Your working directory is an isolated git worktree copy of ${extras.worktreeBase}.
+Work only inside it — never in ${extras.worktreeBase}, even if other instructions name that path as your working directory.
+</worktree_isolation>`
+    : ""
 
   if (config.promptMode === "append") {
     const identity = parentSystemPrompt || genericBase
@@ -88,6 +96,7 @@ You are operating as a sub-agent invoked to handle a specific task.
       "\n\n" +
       activeAgentTag +
       envBlock +
+      worktreeSection +
       customSection +
       extrasSuffix
     )
@@ -100,7 +109,12 @@ You have been invoked to handle a specific task autonomously.
 ${envBlock}`
 
   return (
-    activeAgentTag + replaceHeader + "\n\n" + config.systemPrompt + extrasSuffix
+    activeAgentTag +
+    replaceHeader +
+    worktreeSection +
+    "\n\n" +
+    config.systemPrompt +
+    extrasSuffix
   )
 }
 

package/node_modules/@herbertgao/pi-subagents/src/settings.ts

@@ -49,6 +49,12 @@ export interface SubagentsSettings {
    * against. Defaults to false: subagents may use any model.
    */
   scopeModels?: boolean
+  /**
+   * When true, an unreadable or unparseable agent `.md` aborts extension load
+   * instead of being skipped with a warning. This applies only during startup;
+   * later per-call reloads remain tolerant. Defaults to false.
+   */
+  strictAgentFiles?: boolean
   /**
    * When true, the three built-in default agents (general-purpose, Explore, Plan)
    * are not registered at startup. User-defined agents from project/global custom
@@ -129,6 +135,7 @@ export interface SettingsAppliers {
   setDefaultJoinMode: (mode: JoinMode) => void
   setSchedulingEnabled: (b: boolean) => void
   setScopeModels: (enabled: boolean) => void
+  setStrictAgentFiles: (b: boolean) => void
   setDisableDefaultAgents: (b: boolean) => void
   setToolDescriptionMode: (mode: ToolDescriptionMode) => void
   setFleetView: (b: boolean) => void
@@ -207,6 +214,9 @@ function sanitize(raw: unknown): SubagentsSettings {
   if (typeof r.scopeModels === "boolean") {
     out.scopeModels = r.scopeModels
   }
+  if (typeof r.strictAgentFiles === "boolean") {
+    out.strictAgentFiles = r.strictAgentFiles
+  }
   if (typeof r.disableDefaultAgents === "boolean") {
     out.disableDefaultAgents = r.disableDefaultAgents
   }
@@ -315,6 +325,8 @@ export function applySettings(
   if (typeof s.schedulingEnabled === "boolean")
     appliers.setSchedulingEnabled(s.schedulingEnabled)
   if (typeof s.scopeModels === "boolean") appliers.setScopeModels(s.scopeModels)
+  if (typeof s.strictAgentFiles === "boolean")
+    appliers.setStrictAgentFiles(s.strictAgentFiles)
   if (typeof s.disableDefaultAgents === "boolean")
     appliers.setDisableDefaultAgents(s.disableDefaultAgents)
   if (s.toolDescriptionMode)

package/node_modules/@herbertgao/pi-subagents/src/types.ts

@@ -77,6 +77,8 @@ export interface AgentConfig {
   enabled?: boolean
   /** Where this agent was loaded from */
   source?: "default" | "project" | "global"
+  /** Path of the .md it was loaded from. Unset for embedded defaults. */
+  sourcePath?: string
 }
 
 export type JoinMode = "async" | "group" | "smart"

package/node_modules/@narumitw/pi-btw/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narumiruna
+
+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/@narumitw/pi-btw/README.md

@@ -0,0 +1,210 @@
+# 💬 pi-btw — Side Questions for the Pi Coding Agent
+
+[![npm](https://img.shields.io/npm/v/@narumitw/pi-btw)](https://www.npmjs.com/package/@narumitw/pi-btw) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
+
+`@narumitw/pi-btw` is a native [Pi coding agent](https://pi.dev) extension that adds `/btw`, a side-question command for quick clarifications that should not interrupt or pollute the main agent conversation.
+
+Use it when you want to ask a temporary question, inspect context, or get a short explanation while keeping the primary coding task focused.
+
+## ✨ Features
+
+- Adds a `/btw` menu for starting or resuming an in-memory side thread or changing pi-btw settings.
+- Keeps `/btw <question>` as a direct fast path that always starts a fresh side thread.
+- Answers side questions in a dedicated, scrollable full-screen UI.
+- Keeps mouse-drag copying stable while the main agent continues running in the background.
+- Supports follow-up questions in the same ephemeral side thread.
+- Resumes any non-empty side thread retained by the current Pi session, listed by its first question.
+- Queues Pi-style `Steering` questions while an answer is running and processes them one at a time.
+- Optionally brings the latest answer, a question-to-end suffix, an exact line range, or the entire side thread into the main editor.
+- Uses the current session branch as context.
+- Uses Pi's current model or an independent model selected in `pi-btw.json`.
+- Uses a pi-btw thinking level that can be changed with Pi's configured thinking shortcut and remembered for next time.
+- Does not append the side question or answer to the main conversation.
+- Works as an independently installable npm Pi extension package.
+
+## 📦 Install
+
+```bash
+pi install npm:@narumitw/pi-btw
+```
+
+Try without installing permanently:
+
+```bash
+pi -e npm:@narumitw/pi-btw
+```
+
+Try this package locally from the repository root:
+
+```bash
+pi -e ./packages/pi-btw
+```
+
+## 🚀 Usage
+
+Open the pi-btw menu or provide the first question immediately:
+
+```text
+/btw
+/btw <your side question>
+```
+
+Examples:
+
+```text
+/btw
+/btw what does this TypeScript error mean?
+/btw summarize the current implementation before we continue
+/btw is this API name idiomatic?
+```
+
+Running `/btw` alone opens a menu with **Start side thread** selected first. When the current Pi
+session has non-empty side threads in memory, **Resume side thread** opens a bounded choice list;
+**Settings** changes the starting thinking level and whether shortcut changes are remembered.
+Each Resume row keeps the first question as its fixed title, shows its question count, and the list
+is ordered by the newest recorded answer or visible error. Opening and closing a thread without a
+new result does not reorder it. `/btw <question>` bypasses this menu and always starts a fresh side
+thread. Its answer opens above the side-thread editor. The side thread uses a dedicated full-screen
+terminal view.
+The main agent continues running in the background, but its screen rendering stays suspended until
+`/btw` closes, so new main-thread output cannot move a mouse selection inside the side thread.
+Drag the primary mouse button across side-thread text to select and copy it through Pi's terminal
+clipboard support. Returning from `/btw` redraws the main view with everything produced while it
+was hidden. A compact `btw · side thread` header stays fixed above the content so the ephemeral
+workspace remains recognizable while scrolling. Messages use Pi's normal
+user and assistant presentation without numbered turns or role labels. Type each question and press
+`Enter`; no follow-up shortcut is required.
+Previous side questions and answers remain available to the model and visible for that
+invocation. The side-thread header shows its current thinking level. Press Pi's configured
+`app.thinking.cycle` shortcut (`Shift+Tab` by default) in the composer to cycle the levels
+supported by the side-thread model; every later question uses the displayed level until it is
+changed again. By default, each shortcut change is also written to `pi-btw.json` for the next
+invocation. Turn **Remember thinking level changes** off in Settings to keep changes local to the
+current side thread. Neither path changes the main session's thinking level.
+While a response is running, the transcript and composer remain visible above an `Answering…`
+status.
+Type another question and press `Enter` to queue it as `Steering`; queued questions are shown in
+submission order and answered one at a time after the active response completes.
+A queued question uses the side thread's thinking level when its turn begins.
+A failed active response is shown in the transcript and does not discard later steering questions.
+The footer shows `PgUp`/`PgDn` only when history can scroll; press `Ctrl+C` to cancel the active
+response and discard the ephemeral side-thread draft and steering queue. Completed questions,
+answers, and visible errors remain available through Resume until the current extension instance
+ends. Steering remains entirely inside pi-btw and never appends to the main conversation or editor.
+
+After at least one successful answer, press `Ctrl+R` to bring selected context to the main
+editor. The scope menu shows the size of the latest question and answer and the entire side
+thread before you choose. Bring the latest question and answer, everything from a chosen
+question onward, an exact text range, or the entire side thread. Question-suffix, exact-range,
+and entire-thread choices preview the exact editable context block before the side thread closes;
+`Escape` returns and `Ctrl+C` closes without bringing anything to main.
+
+The text-range selector supports both fast line selection and editor-style character selection.
+It reports whether anything is selected plus the selected line, message, and approximate token
+counts. Press `Space` to select the current raw source line, then use `Up`/`Down` to extend by
+whole lines; press `Space` again to clear it. Alternatively, use the arrow keys to move the cursor
+and `Shift`+arrow keys to extend a character-level selection. Starting a Shift selection replaces
+any active line selection. Selected lines include a visible `●` marker in addition to highlighting.
+Pi's configured keys control vertical navigation, bringing, and going back (`Up`/`Down`, `Enter`,
+and `Escape` by default), and the selector displays the active keys. Selection follows raw source
+text rather than terminal-wrapped visual rows.
+
+Bringing context to main closes the side thread and loads a deterministic, editable context block
+into Pi's main editor. It never sends the draft automatically. If the main editor already has a
+draft, append is the recommended default. Replace is labeled as destructive and requires a second
+confirmation; Cancel returns to the side thread without changing either draft. Concurrent editor
+updates made while these menus are open are preserved. A success message reports whether context
+was loaded, appended, or replaced and its approximate size.
+Without an explicit bring-to-main action, closing `/btw` never adds the side thread to the main
+conversation. Non-empty threads remain only in memory for Resume within the current Pi session.
+`/new`, Pi `/resume`, `/reload`, extension replacement, and process restart discard every retained
+thread. Unsent drafts, steering queues, interrupted answers, and model credentials are never retained.
+
+## ⚙️ Model and thinking level
+
+By default, `/btw` uses the current session model. To use an independent model for side
+questions, create:
+
+```text
+$PI_CODING_AGENT_DIR/pi-btw.json
+```
+
+The normal location is `~/.pi/agent/pi-btw.json`. `PI_CODING_AGENT_DIR` is an existing Pi
+setting; pi-btw does not add any environment variables.
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-5",
+  "thinkingLevel": "low",
+  "rememberThinkingLevelChanges": true
+}
+```
+
+The `model` value uses `provider/model-id` format. Only the first `/` is the separator, so
+model IDs may contain additional slashes, such as `openrouter/anthropic/claude-sonnet`.
+The configured model must exist in Pi's model registry and have usable credentials. If it
+cannot be found or authenticated, pi-btw warns and falls back to the current session model.
+If neither model is available, `/btw` reports an error and stops. This selection affects only
+`/btw`; it does not change the main session model.
+
+Pi calls its reasoning setting the **thinking level**. `thinkingLevel` sets pi-btw's starting
+level; accepted values are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. When the
+field is absent for backward compatibility, the next invocation starts from the current session
+level. The initial value and shortcut cycle are clamped to the selected side model's capabilities
+using Pi's model rules. Pi-btw does not read, write, or change the main session's
+`defaultThinkingLevel`.
+
+`rememberThinkingLevelChanges` controls only persistence and defaults to `true` when omitted. A
+side-thread shortcut always changes that side thread immediately. When remembering is on, the
+concrete level is written for the next invocation; when off, `pi-btw.json` stays unchanged. If a
+shortcut write fails, the local change remains active and pi-btw warns that it was not remembered.
+A failed Settings-screen save instead restores the previous displayed value.
+
+A missing settings file is a side-effect-free read: pi-btw creates it only after a Settings change
+or a remembered shortcut change. Saves are ordered within the Pi process and published atomically
+with a same-directory temporary file and rename. They preserve `model` and unknown fields; malformed
+or invalid files block saves and remain unchanged. Settings must be valid UTF-8 and no larger than
+64 KiB, so unexpectedly large or invalidly encoded files are rejected without being rewritten.
+Separate Pi processes and external editors are outside this in-process ordering boundary. The file
+is read for each `/btw` invocation, so edits apply without `/reload`.
+
+## 🧠 Why use pi-btw?
+
+Normal assistant messages become part of the main Pi conversation and can distract the coding agent from the task. `pi-btw` creates a lightweight side channel for context-aware questions, making it useful for pair programming, debugging, code review, and repository exploration.
+
+## 🗂️ Package layout
+
+```txt
+packages/pi-btw/
+├── src/
+│   ├── index.ts
+│   ├── btw.ts
+│   ├── bring-to-main.ts
+│   ├── menu.ts
+│   ├── settings.ts
+│   ├── side-thread.ts
+│   ├── text.ts
+│   └── transcript-pager.ts
+├── README.md
+├── LICENSE
+├── tsconfig.json
+└── package.json
+```
+
+The package exposes its Pi extension through `package.json`:
+
+```json
+{
+  "pi": {
+    "extensions": ["./src/index.ts"]
+  }
+}
+```
+
+## 🔎 Keywords
+
+Pi extension, Pi coding agent, AI coding agent, side question command, agent chat workflow, TypeScript Pi package, npm Pi extension.
+
+## 📄 License
+
+MIT. See [`LICENSE`](./LICENSE).

package/node_modules/@narumitw/pi-btw/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "@narumitw/pi-btw",
+	"version": "0.50.0",
+	"description": "Pi extension that adds a /btw side-question command.",
+	"type": "module",
+	"license": "MIT",
+	"private": false,
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"pi",
+		"btw",
+		"side-question"
+	],
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./src/index.ts"
+		]
+	},
+	"piExtension": {
+		"lifecycle": "stable"
+	},
+	"scripts": {
+		"check": "biome check . && npm run typecheck",
+		"format": "biome check --write .",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.5.7",
+		"@earendil-works/pi-ai": "0.84.1",
+		"@earendil-works/pi-coding-agent": "0.84.1",
+		"@earendil-works/pi-tui": "0.84.1",
+		"typescript": "7.0.2"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/narumiruna/pi-extensions",
+		"directory": "packages/pi-btw"
+	},
+	"dependencies": {
+		"@narumitw/pi-tui-kit": "^0.49.1"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	}
+}