pi-orchestrator-config 4.17.0 → 4.18.0

package/README.md

@@ -16,7 +16,6 @@ Single extension that provides:
 | **`list_models`**             | List available models and providers for subagent model override                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | **Async background agents**   | Spawn agents in background with `async: true` — results surface automatically when complete. Fullscreen overlay dashboard with live output, keyboard nav, and kill support (`/async-status`: `x` kills, `Space` multi-selects, `a` kills all). On **acpx** parents, optional async is coerced to sync; dream/cron need `internal_operations_provider` + `internal_operations_model`. `cli-*` providers support async natively (see `docs/cli-provider.md`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | **CLI / ACPX providers**      | Optional `cli_agents` / `acpx_agents` register `cli-*` / `acpx-*` via native `createProvider` (pi ≥ 0.84): `/login cli-<agent>` or `/login acpx-<agent>`, model refresh, filter when unavailable. Missing context window / maxTokens / cost filled from models.dev (`~/.pi/pi-config/models.dev.json`, 1-day refresh). Cold-start default restore (#753): gates `startup`\|`resume` (`new` only when no model is selected), empty `enabledModels`, trusted project merge — see `docs/cli-provider.md`. Headless Cursor `--approve-mcps` when `CLI_APPROVE_MCPS` is set (`false` opts out) or the process is a sidecar (`SIDECAR_PORT`; `startSidecar()` stamps it while running and restores it on `close()`). Executable sidecar consumers should call `bindSidecarListenExit()` so bind/`stopped` fatals exit 1. Headless Gemini defaults `GEMINI_CLI_TRUST_WORKSPACE=true` and preserves an explicit parent value (including `false`). |
-| **`/btw` command**            | Quick side questions without polluting conversation history — ephemeral overlay                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | **`/async-status` command**   | Show status of background agents — select one for live output streaming, multi-select and kill (`x`), or kill everything (`a`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | **`ask_user` tool**           | Structured user input with options and free-text — used by workflows                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | **Python/pip enforcement**    | Auto-fixes `python`/`python3` → `uv run python`; blocks `pip`/`pip3` — requires `uv`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -36,7 +35,7 @@ Single extension that provides:
 | **Task tracking**             | Structured task lists for multi-step workflows — live widget, progress tracking, reminder nudges (owned, based on [@tintinweb/pi-tasks](https://github.com/tintinweb/pi-tasks) MIT)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | **Neovim integration**        | Send changed files and review findings to nvim's quickfix list — only active when running inside nvim                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | **Inter-agent communication** | P2P (`/coms`) agent communication — on-demand activation via slash command                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| **Slash commands**            | `/pr-review`, `/issue-review`, `/release`, `/review-local`, `/review-status`, `/query-db`, `/btw`, `/async-status`, `/status`, `/dream`, `/remember`, `/coms`, `/pi-config-settings` — with autocomplete argument hints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| **Slash commands**            | `/pr-review`, `/issue-review`, `/release`, `/review-local`, `/review-status`, `/query-db`, `/async-status`, `/status`, `/dream`, `/remember`, `/coms`, `/pi-config-settings` — with autocomplete argument hints                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | **GitHub autocomplete**       | Type `#` in the editor to get issue/PR suggestions from the current repo — lazy-loaded, 5min cache                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | **Command arg completions**   | Tab-complete arguments for slash commands — providers and models for `/external-ai`, branches for `/review-local`, PR numbers for `/pr-review`, and more                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | **Discord bot**               | Control pi sessions from your phone via Discord DMs — send prompts, answer ask_user dialogs, switch sessions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
@@ -808,6 +807,7 @@ PI_PIDIFF_ENABLE=false pi
 | `myk-pi-tools release create`          | Create a GitHub release with changelog                                                                                                         |
 | `myk-pi-tools db`                      | Review database query commands                                                                                                                 |
 | `myk-pi-tools reviews`                 | Review handling commands (fetch, poll, address, post, store, store-session)                                                                   |
+| `myk-pi-tools reviews poll`            | Poll a PR for review comments until approved or actionable — `--source qodo` reads findings through the `qodo` CLI (structured, with spans and authoritative open/closed status) when the binary is installed and authenticated, and falls back to the GitHub sticky-comment scrape otherwise. Read-only: replies are always posted as GitHub comments via `reviews address` |
 | `myk-pi-tools reviews address`         | Apply replies/statuses to a fetched reviews JSON, then post and store it (see below)                                                           |
 | `myk-pi-tools reviews store-session`   | Store Qodo pr-review-session findings JSON into the reviews DB (idempotent; run at loop convergence)                                           |
 | `myk-pi-tools memory`                  | Project memory commands — persistent per-repo learning                                                                                         |
@@ -961,6 +961,8 @@ The bot starts automatically with pidash when `DISCORD_BOT_TOKEN` is configured.
 ## Development
 
 See [DEVELOPMENT.md](DEVELOPMENT.md) for tips on testing extensions locally, running tests, and managing Python dependencies.
+The repository-wide TypeScript gate is `npm run typecheck` (strict `tsc --noEmit` across all six projects);
+it also runs as a pre-commit hook when TypeScript files change.
 
 ## Prerequisites
 

package/extensions/coms/coms-p2p.ts

@@ -15,7 +15,7 @@
  * Usage: loaded via extensions/coms/index.ts
  */
 
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { applyExtensionDefaults } from "./themeMap.js";
@@ -187,6 +187,22 @@ interface PendingReply {
 	progress?: { note: string; at: string };
 }
 
+/** #951: coms_send tool result details — blocked send or delivered message. */
+type ComsSendDetails =
+	| { blocked: boolean; reason: string; target: string }
+	| { msg_id: string; target: string; target_session: string; hops: number; peer_queue_depth: number; peer_status: string };
+
+/** #951: coms_get tool result details — error, completed reply, or pending progress. */
+type ComsGetDetails =
+	| { status: "error"; error: string }
+	| { status: "complete"; response: unknown; error: string | null; queued_msg_ids: string[] }
+	| { status: "pending"; progress: { note: string; at: string } | null };
+
+/** #951: coms_task_delete tool result details — blocked or deleted. */
+type ComsTaskDeleteDetails =
+	| { blocked: boolean; reason: string }
+	| { target: string; task_id: string };
+
 interface InboundContext {
 	msg_id: string;
 	hops: number;
@@ -2235,7 +2251,7 @@ Do not respond to this message.`;
 		entry.timer = setTimeout(() => {
 			if (entry.result) return;
 			entry.result = { error: "timeout" };
-			try { entry.resolve(entry.result); } catch { /* ignore */ }
+			try { entry.resolve?.(entry.result); } catch { /* ignore */ }
 			// Clean up timed-out entry from both maps
 			const pSet = pendingOutbound.get(target.name);
 			if (pSet) { pSet.delete(msg_id); if (pSet.size === 0) pendingOutbound.delete(target.name); }
@@ -2389,7 +2405,9 @@ Do not respond to this message.`;
 			priority: Type.Optional(Type.Boolean({ description: "Jump the peer's queued message backlog (urgent messages). Default false." })),
 			clearPrevious: Type.Optional(Type.Boolean({ description: "Deprecated and rejected: inspect with coms_queue_inspect, then explicitly clear using preview_id." })),
 		}),
-		async execute(_callId, params) {
+		// #951: explicit result type so the blocked and delivered details shapes form
+		// one union instead of racing TDetails inference.
+		async execute(_callId, params): Promise<AgentToolResult<ComsSendDetails>> {
 			if (!identity) {
 				throw new Error("coms not initialised");
 			}
@@ -2618,7 +2636,7 @@ Do not respond to this message.`;
 		parameters: Type.Object({
 			msg_id: Type.String({ description: "msg_id returned by coms_send." }),
 		}),
-		async execute(_callId, params) {
+		async execute(_callId, params): Promise<AgentToolResult<ComsGetDetails>> {
 			const entry = pendingReplies.get(params.msg_id);
 			if (!entry) {
 				return {
@@ -2731,7 +2749,7 @@ Do not respond to this message.`;
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 			const result = await sendQueueManage(target, "delete", params.msg_id, undefined, params.preview_id);
 			if (result.error) throw new Error(`coms_queue_delete failed: ${result.error}`);
-			return { content: [{ type: "text" as const, text: `coms_queue_delete → ${target.name}\nmsg_id: ${params.msg_id}` }] };
+			return { content: [{ type: "text" as const, text: `coms_queue_delete → ${target.name}\nmsg_id: ${params.msg_id}` }], details: undefined };
 		},
 	});
 
@@ -2749,7 +2767,7 @@ Do not respond to this message.`;
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 			const result = await sendQueueManage(target, "edit", params.msg_id, params.new_content);
 			if (result.error) throw new Error(`coms_queue_edit failed: ${result.error}`);
-			return { content: [{ type: "text" as const, text: `coms_queue_edit → ${target.name}\nmsg_id: ${params.msg_id}` }] };
+			return { content: [{ type: "text" as const, text: `coms_queue_edit → ${target.name}\nmsg_id: ${params.msg_id}` }], details: undefined };
 		},
 	});
 
@@ -2784,7 +2802,7 @@ Do not respond to this message.`;
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 			const result = await sendQueueManage(target, "prioritize", params.msg_id);
 			if (result.error) throw new Error(`coms_queue_prioritize failed: ${result.error}`);
-			return { content: [{ type: "text" as const, text: `coms_queue_prioritize → ${target.name}\nmsg_id: ${params.msg_id}` }] };
+			return { content: [{ type: "text" as const, text: `coms_queue_prioritize → ${target.name}\nmsg_id: ${params.msg_id}` }], details: undefined };
 		},
 	});
 
@@ -2896,7 +2914,7 @@ Do not respond to this message.`;
 			target: Type.String({ description: "Peer name or session_id." }),
 			task_id: Type.String({ description: "Task ID to delete." }),
 		}),
-		async execute(_callId, params) {
+		async execute(_callId, params): Promise<AgentToolResult<ComsTaskDeleteDetails>> {
 			log.debug("coms_task_delete_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
@@ -3721,7 +3739,10 @@ Do not respond to this message.`;
 	// Expose command handlers to pidash for browser command dispatch
 	try {
 		if ((globalThis as any).__coms_p2p_pidash_listener) {
-			try { pi.events.removeListener("pidash:request-commands", (globalThis as any).__coms_p2p_pidash_listener); } catch {}
+			// #951: pi's EventBus exposes only emit/on — no removeListener. This cleanup has
+			// always thrown (swallowed by the catch), so the stale listener is never removed;
+			// latent bug left as-is, typed to match reality.
+			try { (pi.events as { removeListener?: (channel: string, handler: (data: unknown) => void) => void }).removeListener?.("pidash:request-commands", (globalThis as any).__coms_p2p_pidash_listener); } catch {}
 		}
 		const registerWithPidash = () => {
 			pi.events.emit("pidash:register-command", { name: "coms-queue", handler: comsQueueCmdHandler });
@@ -3790,7 +3811,9 @@ Do not respond to this message.`;
 			try {
 				for (const connection of connections) connection.destroy();
 				connections.clear();
-				activeServer.closeAllConnections?.(); activeServer.close(); activeServer.unref();
+				// #951: net.Server has no closeAllConnections at runtime or in @types/node —
+				// the optional call is a graceful no-op; typed accordingly.
+				(activeServer as net.Server & { closeAllConnections?: () => void }).closeAllConnections?.(); activeServer.close(); activeServer.unref();
 			} catch { /* ignore */ }
 		}
 		if (pingWorker) {

package/extensions/coms/coms-wrapper.ts

@@ -166,7 +166,10 @@ export function registerComs(pi: ExtensionAPI) {
     // Expose handler to pidash for browser command dispatch
     try {
         if ((globalThis as any).__coms_pidash_listener) {
-            try { pi.events.removeListener("pidash:request-commands", (globalThis as any).__coms_pidash_listener); } catch {}
+            // #951: pi's EventBus exposes only emit/on — no removeListener. This cleanup has
+            // always thrown (swallowed by the catch), so the stale listener is never removed;
+            // latent bug left as-is, typed to match reality.
+            try { (pi.events as { removeListener?: (channel: string, handler: (data: unknown) => void) => void }).removeListener?.("pidash:request-commands", (globalThis as any).__coms_pidash_listener); } catch {}
         }
         const registerWithPidash = () => pi.events.emit("pidash:register-command", { name: "coms", handler: comsCmdHandler });
         (globalThis as any).__coms_pidash_listener = registerWithPidash;

package/extensions/image-gen/image-gen.ts

@@ -152,7 +152,7 @@ function serveImage(imagePath: string): { url: string; port: string; dir: string
     }
 }
 
-export function createImageGenTool(): ToolDefinition {
+export function createImageGenTool(): ToolDefinition<typeof imageGenSchema> {
     return {
         name: "generate_image",
         label: "GenerateImage",
@@ -173,6 +173,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: "Error: image model is not set. Add image_model to pi-config-settings.json (or PI_IMAGE_MODEL env) and reload pi.",
                     }],
+                    details: undefined,
                 };
             }
             if (!isImageGenModelId(model)) {
@@ -182,6 +183,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `Error: image_model '${model}' is not an image-generation model. Choose a Gemini image model (id contains image or imagen).`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -192,6 +194,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: "Error: No API key found. Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable and restart pi.",
                     }],
+                    details: undefined,
                 };
             }
 
@@ -231,6 +234,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `Error: Gemini API request failed: ${err?.message ?? String(err)}`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -248,6 +252,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `Error: Gemini image request failed (${response.status}): ${message}`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -260,6 +265,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `Error: Failed to parse Gemini response: ${rawText.slice(0, 200)}`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -269,6 +275,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `Error: Image generation blocked by safety filter: ${data.promptFeedback.blockReason}`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -296,6 +303,7 @@ export function createImageGenTool(): ToolDefinition {
                         type: "text" as const,
                         text: `No image data returned from Gemini.${extra}`,
                     }],
+                    details: undefined,
                 };
             }
 
@@ -344,6 +352,7 @@ export function createImageGenTool(): ToolDefinition {
                     type: "text" as const,
                     text: lines.join("\n"),
                 }],
+                details: undefined,
             };
         },
     };

package/extensions/openai-compatible-discovery/index.ts

@@ -1,4 +1,4 @@
-import type { AuthResult, Model, Provider, RefreshModelsContext } from "@earendil-works/pi-ai";
+import type { Api, AuthResult, Model, Provider, RefreshModelsContext } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createLogger } from "../shared/logger.js";
 import {
@@ -47,7 +47,7 @@ function resolvedConnection(source: Provider, auth?: AuthResult, staticHeaders?:
   };
 }
 
-function combineModels(sourceProviderId: string, staticModels: readonly Model[], records: readonly OpenAiCompatibleModelRecord[], baseUrl: string): Model[] {
+function combineModels(sourceProviderId: string, staticModels: readonly Model<Api>[], records: readonly OpenAiCompatibleModelRecord[], baseUrl: string): Model<Api>[] {
   const existingIds = new Set(staticModels.map((model) => model.id));
   const discovered = materializeOpenAiCompatibleModels(records, baseUrl, sourceProviderId)
     .filter((model) => !existingIds.has(model.id));
@@ -59,14 +59,14 @@ async function refreshProviderModels(
   ctx: any,
   sourceProviderId: string,
   source: Provider,
-  staticModels: readonly Model[],
+  staticModels: readonly Model<Api>[],
   refresh: RefreshModelsContext,
   appendSummary: () => boolean,
   discoverModelCapabilities: boolean,
-  rawStaticHeaders?: Record<string, string>,
-  snapshot: { discovered: Model[]; fingerprint?: string; generation: number },
+  rawStaticHeaders: Record<string, string> | undefined,
+  snapshot: { discovered: Model<Api>[]; fingerprint?: string; generation: number },
   lifecycle: { signal: AbortSignal; isCurrent: () => boolean },
-): Promise<Model[]> {
+): Promise<Model<Api>[]> {
   const generation = ++snapshot.generation;
   const active = () => {
     const current = lifecycle.isCurrent();
@@ -206,9 +206,9 @@ export default function (pi: ExtensionAPI) {
         log.warn(`${id}: configured provider was not resolved`);
         continue;
       }
-      const staticModels = (ctx.modelRegistry.getAll() as Model[])
+      const staticModels = (ctx.modelRegistry.getAll() as Model<Api>[])
         .filter((model) => model.provider === id);
-      const snapshot = { discovered: [] as Model[], fingerprint: undefined as string | undefined, generation: 0 };
+      const snapshot = { discovered: [] as Model<Api>[], fingerprint: undefined as string | undefined, generation: 0 };
       // Registration starts an unawaited offline refresh. Its first callback signals
       // that it has acquired its generation, so the network pass can safely supersede it.
       let registrationStarted!: () => void;

package/extensions/orchestrator/ask-user.ts

@@ -48,6 +48,7 @@ export function registerAskUser(
           content: [
             { type: "text", text: "No UI available for user interaction" },
           ],
+          details: undefined,
           isError: true,
         };
       }
@@ -265,17 +266,17 @@ export function registerAskUser(
       unsubscribe();
 
       if (result === null) {
-        return { content: [{ type: "text", text: "User cancelled" }], terminate: true };
+        return { content: [{ type: "text", text: "User cancelled" }], details: undefined, terminate: true };
       }
-      return { content: [{ type: "text", text: result }] };
+      return { content: [{ type: "text", text: result }], details: undefined };
     },
 
     renderCall(args, theme) {
       let t =
         theme.fg("toolTitle", theme.bold("ask_user ")) +
         theme.fg("accent", args.question || "...");
-      if (args.options?.length > 0) {
-        t += `\n  ${theme.fg("dim", args.options.join(" • "))}`;
+      if ((args.options?.length ?? 0) > 0) {
+        t += `\n  ${theme.fg("dim", args.options!.join(" • "))}`;
       }
       return new Text(t, 0, 0);
     },

package/extensions/orchestrator/async-status-ui.ts

@@ -57,7 +57,7 @@ function jobTitle(job: AsyncStatusJobView): string {
  */
 export function formatKillOriginSuffix(
   killOrigin: string | undefined,
-  theme: { fg: (color: string, value: string) => string },
+  theme: Pick<Theme, "fg">,
 ): string {
   if (!killOrigin) {
     log.debug("kill_origin_header: no origin recorded");

package/extensions/orchestrator/cron.ts

@@ -193,7 +193,7 @@ export function registerCron(pi: ExtensionAPI, spawnAsyncAgent: any): { getCronT
     const task = tasks.get(id); if (scope === "session") { if (!task) return false; stop(id); tasks.delete(id); if (sessionStore) writeSessionTasks(sessionStore, [...tasks.values()].filter(t => t.scope === "session")); } else { const file = projectStore(ctx.cwd); let found = false; mutateDurableCronStore(file, old => { found = old.some(t => t.id === id); return old.filter(t => t.id !== id); }); if (!found) return false; if (task) { stop(id); tasks.delete(id); } }
     updateStatus(); return true;
   }
-  pi.registerTool({ name: "cron_manage", description: "Manage scheduled tasks. Set persist=true to keep a task across Pi sessions in this project. Set model to \"provider/model-id\" (or a bare \"model-id\") to pin that cron's model.", parameters: Type.Object({ action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("remove")]), persist: Type.Optional(Type.Boolean()), description: Type.Optional(Type.String()), task: Type.Optional(Type.String()), model: Type.Optional(Type.String()), interval_seconds: Type.Optional(Type.Number()), at_hour: Type.Optional(Type.Number()), at_minute: Type.Optional(Type.Number()), id: Type.Optional(Type.String()) }), async execute(_id, params: any) {
+  pi.registerTool({ name: "cron_manage", description: "Manage scheduled tasks. Set persist=true to keep a task across Pi sessions in this project. Set model to \"provider/model-id\" (or a bare \"model-id\") to pin that cron's model.", parameters: Type.Object({ action: Type.Union([Type.Literal("add"), Type.Literal("list"), Type.Literal("remove")]), persist: Type.Optional(Type.Boolean()), description: Type.Optional(Type.String()), task: Type.Optional(Type.String()), model: Type.Optional(Type.String()), interval_seconds: Type.Optional(Type.Number()), at_hour: Type.Optional(Type.Number()), at_minute: Type.Optional(Type.Number()), id: Type.Optional(Type.String()) }), async execute(_id: string, params: any) {
     const scope: CronScope = params.persist ? "project" : "session";
     try { if (params.action === "add" && (ctx?.mode === "print" || ctx?.mode === "json")) return { content: [{ type: "text", text: "Error: Cron scheduling is unavailable in one-shot mode." }] }; if (params.action === "add") { const task = add(scope, params); return { content: [{ type: "text", text: `Cron ${qualifyCronId(task)} created: ${formatCronSchedule(task)} → ${task.description}${task.model ? ` [${task.model}]` : ""}` }] }; } if (params.action === "remove") return { content: [{ type: "text", text: remove(params.id || "") ? "Cron removed." : "Task not found." }] }; const selected = [...tasks.values()].filter(t => !params.persist || t.scope === "project"); return { content: [{ type: "text", text: selected.length ? selected.map(t => `${qualifyCronId(t)} | ${formatCronSchedule(t)} | ${t.description} | ${t.model || "inherited model"} | ${t.leader === false ? "waiting for leader" : "active"}`).join("\n") : "No scheduled tasks." }] }; } catch (error: any) { return { content: [{ type: "text", text: `Error: ${error.message}` }] }; }
   }, } as any);

package/extensions/orchestrator/graft.ts

@@ -147,11 +147,15 @@ export function acquireBuildLock(root: string, afterClaim?: () => void): (() =>
 function trusted(ctx: any): boolean { return typeof ctx?.isProjectTrusted !== "function" || ctx.isProjectTrusted() === true; }
 function relevant(ask: Ask): Hit[] { const hits = ask.hits?.filter(hit => text(hit.pointer) && text(hit.title)) ?? []; if (!hits.length) return []; if ((typeof ask.coverage === "number" || typeof ask.coverageStrong === "number") && (ask.coverageStrong ?? 0) < .1 && (ask.coverage ?? 0) < .5) return []; return hits.slice(0, 3); }
 function pointerText(hits: Hit[]): string { return hits.map((hit, i) => { const snippet = text(hit.snippet, 140); return ` ${i + 1}. ${text(hit.title)!}: ${text(hit.pointer)!}${snippet ? `\n    ${snippet.replace(/\s+/g, " ")}` : ""}`; }).join("\n"); }
+type GraftNode = { id: string; name: string; path: string };
+type GraftEdge = { source: string; target: string; relation: string };
+type GraftWiring = { nodes?: GraftNode[]; edges?: GraftEdge[] };
 function blastHint(root: string, path: unknown): string | null {
-  const file = typeof path === "string" ? path : null; const graph = file && wiring(root); if (!file || !graph) return null;
-  const names = new Map((graph.nodes ?? []).map((node: any) => [node.id, node]));
-  const ids = new Set((graph.nodes ?? []).filter((node: any) => node.path === file || file.endsWith(`/${node.path}`)).map((node: any) => node.id));
-  const dependents = (graph.edges ?? []).filter((edge: any) => ids.has(edge.target) && !ids.has(edge.source)).slice(0, 8).map((edge: any) => { const node = names.get(edge.source); return ` • ${edge.relation} ← ${node ? `${node.name} (${basename(node.path)})` : edge.source}`; });
+  const file = typeof path === "string" ? path : null; const graph = file && (wiring(root) as GraftWiring | null); if (!file || !graph) return null;
+  const graphNodes = graph.nodes ?? [];
+  const names = new Map<string, GraftNode>(graphNodes.map((node) => [node.id, node] as [string, GraftNode]));
+  const ids = new Set(graphNodes.filter((node) => node.path === file || file.endsWith(`/${node.path}`)).map((node) => node.id));
+  const dependents = (graph.edges ?? []).filter((edge) => ids.has(edge.target) && !ids.has(edge.source)).slice(0, 8).map((edge) => { const node = names.get(edge.source); return ` • ${edge.relation} ← ${node ? `${node.name} (${basename(node.path)})` : edge.source}`; });
   return dependents.length ? `[graft] blast radius for ${basename(file)}, who depends on it:\n${dependents.join("\n")}` : null;
 }
 export function isEligibleGraftStartup(event: any, ctx: any): boolean { return event?.reason === "startup" && ctx?.mode !== "print" && ctx?.mode !== "json" && process.env.PI_SUBAGENT_CHILD !== "1" && !isPiOneshotInvocation(); }

package/extensions/orchestrator/index.ts

@@ -5,7 +5,7 @@
  * - Subagent tool (based on pi's subagent example, with package agent discovery)
  * - Enforcement handlers (python/pip, git protection, dangerous commands)
  * - Rule injection & memory loading (before_agent_start)
- * - Slash commands (/btw, /async-status, /dream-auto)
+ * - Slash commands (/async-status, /dream-auto)
  * - Notifications and status line
  * - Session validation (required tools check)
  * - Async agent infrastructure
@@ -17,7 +17,6 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { registerAskUser } from "./ask-user.js";
 import { registerAsyncAgents } from "./async-agents.js";
-import { registerBtw } from "./btw.js";
 import { registerDreaming } from "./dreaming.js";
 import { registerEnforcement } from "./enforcement.js";
 import { registerProjectSettings } from "./project-settings.js";
@@ -104,7 +103,6 @@ export default function (pi: ExtensionAPI) {
   registerRules(pi, getAsyncJobs);
 
   registerStatusLine(pi, IN_CONTAINER, terminalNotify);
-  registerBtw(pi);
   registerDreaming(pi, spawnAsyncAgent);
   const { getCronTasks } = registerCron(pi, spawnAsyncAgent);
   registerSessionValidation(pi);
@@ -137,12 +135,14 @@ export default function (pi: ExtensionAPI) {
         if (!registry) {
           return {
             content: [{ type: "text" as const, text: "Model registry not available." }],
+            details: undefined,
           };
         }
         models = registry.getAvailable?.() || registry.getAll?.() || [];
       } catch (e: any) {
         return {
           content: [{ type: "text" as const, text: `Failed to list models: ${e?.message || e}` }],
+          details: undefined,
         };
       }
       // Filter out acpx-* providers — they cannot work in subagent children
@@ -154,6 +154,7 @@ export default function (pi: ExtensionAPI) {
       if (filtered.length === 0) {
         return {
           content: [{ type: "text" as const, text: params.provider ? `No models found for provider "${params.provider}".` : "No models available." }],
+          details: undefined,
         };
       }
       // Group by provider for readability
@@ -172,6 +173,7 @@ export default function (pi: ExtensionAPI) {
       }
       return {
         content: [{ type: "text" as const, text: lines.join("\n") }],
+        details: undefined,
       };
     },
   });

package/extensions/orchestrator/memory-embeddings.ts

@@ -94,9 +94,10 @@ async function getPipeline(): Promise<any> {
   pipelineLoading = (async () => {
     try {
       const { pipeline } = await import("@huggingface/transformers");
-      const extractor = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", {
-        quantized: true,
-      });
+      // q8 quantized weights: ~4x smaller and faster than fp32, negligible
+      // accuracy loss for embedding similarity (dtype replaced `quantized` in
+      // @huggingface/transformers v4 — issue #951 follow-up).
+      const extractor = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", { dtype: "q8" });
       pipelineInstance = extractor;
       return extractor;
     } catch {

package/extensions/orchestrator/memory-scoring.ts

@@ -302,7 +302,7 @@ export function loadScores(cwd: string): ScoresFile {
   // the cross-process lock — migrating the snapshot loaded above could
   // append a stale state and erase a concurrent writer's update.
   if (data.hashAlgo !== HASH_ALGO) {
-    getScoresStore(cwd).mutate<ScoresFile>(
+    getScoresStore(cwd).mutate(
       (latest) => {
         if (latest.hashAlgo === HASH_ALGO) return; // a concurrent process already migrated
         migrateScoreKeysInPlace(cwd, latest);
@@ -408,7 +408,7 @@ export function mutateScores(
 ): ScoresFile | null {
   // Ensure key migration has run before mutating (idempotent, cached read)
   loadScores(cwd);
-  return getScoresStore(cwd).mutate<ScoresFile>(fn, {
+  return getScoresStore(cwd).mutate(fn, {
     entries: {},
     lastRebuild: new Date().toISOString(),
     hashAlgo: HASH_ALGO,