pi-orchestrator-config 4.4.0 → 4.5.0

package/README.md

@@ -28,6 +28,7 @@ Single extension that provides:
 | **Git status**                | Live git status in status line with colored icons — updates after every tool call. Shows clickable `#N` when the branch has an open PR. Last-activity clock `⏱ HH:MM (Xm/Xh ago)` shows time since last response                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | **Desktop notifications**     | Notifies via `notify-send` on task completion, waiting for input, and action required                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | **File preview**              | Serves generated HTML/frontend files via HTTP for browser preview from container                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| **Graft integration**         | When `graft_enable=true`, main agents and subagents query the local Graft graph before raw project navigation on substantive prompts. Children only consume graphs. Stale graphs remain usable, retrieval failures fall back to raw tools, and main processes coordinate rebuilds with a cross-process lock.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | **Pidash dashboard**          | Live web dashboard — multi-session monitoring, browser messaging, model switching, live session name updates, reasoning token display                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | **Pidiff viewer**             | Per-project diff viewer with review comments — branch diffs, file tree, inline comments, git-based ignore rules                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | **Dreaming**                  | Background memory consolidation — extracts memories from sessions, deduplicates, maintains topic-based memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
@@ -157,7 +158,7 @@ The installer covers:
 
 - **Pi Packages** — pi-config, pi-vertex-claude, pi-web-access, myk-pi-tools, bun
 - **Python Tools** — prek
-- **npm Packages** — mcpc, acpx, agent-browser
+- **npm Packages** — mcpc, acpx, agent-browser, graft
 - **Browser Automation** — playwright + chromium
 - **Environment Setup** — gitignore configuration
 
@@ -404,6 +405,29 @@ Set `image_model` in `pi-config-settings.json` or use `PI_IMAGE_MODEL` env var.
 
 In containers, images are auto-served via HTTP for browser preview.
 
+### Graft repository graph (optional)
+
+Set `graft_enable` to `true` in `.pi/pi-config-settings.json` (or set
+`PI_GRAFT_ENABLE=true`) to enable local Graft repository graph context:
+
+```json
+{
+  "graft_enable": true
+}
+```
+
+Graft requires Node.js 22+, npm 12+, node-gyp prerequisites (Python 3, `make`, and
+G++), and the `graft` CLI. The container includes them; native installs can use
+`uv run scripts/install.py`. The installer downloads `@nanonets/graft@latest` with
+scripts disabled into a dedicated npm prefix, audits that isolated dependency tree
+for lifecycle scripts, and strictly rebuilds it with only those packages approved.
+The completed prefix is then published under the global npm prefix and its `graft`
+binary linked globally, so unrelated global packages are never evaluated. The
+installer verifies `graft --version`; `DO_NOT_TRACK=1` disables Graft telemetry.
+When enabled, Graft reads the trusted project and writes a regenerable `./graft/`
+cache. Delete that directory or set `graft_enable` to `false` to disable it. If the
+native CLI is unavailable or its installation fails, pi continues without Graft.
+
 ### Cache Miss Notices
 
 Enable `showCacheMissNotices` in pi settings to see transcript notices on significant prompt-cache misses — useful for investigating unexpected token costs:
@@ -425,6 +449,23 @@ Run pi inside a disposable container for **filesystem isolation** — the agent
 - **Consistent tooling** — All required tools pre-installed in a single image
 - **Disposable** — Container is destroyed after each session (`--rm`)
 
+**Graft (optional `graft_enable`):** The image installs the latest
+`@nanonets/graft` with `DO_NOT_TRACK=1`. It downloads with scripts disabled, derives
+an exact script allowlist by auditing the installed package's reachable dependency
+metadata in a dedicated npm prefix, then strictly rebuilds that isolated tree with
+those approvals. Only after the rebuild succeeds is the completed prefix moved under
+the global npm prefix and its `graft` binary linked globally. This prevents unrelated
+global packages from entering npm's strict preflight. The allowlist is command-scoped
+and changes with `@latest`; other npm commands keep npm 12's install-script
+protections. The image includes Python 3,
+`make`, and the GCC/G++ toolchain required by node-gyp for Graft and other native
+npm packages; these remain available for reliable package rebuilds. The build then
+verifies `graft --version`. Enable Graft in trusted project or global pi-config
+settings; it reads the project locally and stores its regenerable graph in `./graft/`. Set
+`graft_enable` to `false` and delete that directory to disable and remove the cache.
+Native installations require Node.js 22+, npm 12+, Python 3, `make`, and G++; the
+installer uses the same audited strict installation and failure remains non-fatal.
+
 **CLI provider binaries (optional `cli_agents`):** The image installs the CLIs used by
 `cli-*` providers — `claude` (Claude Code), `gemini` (`@google/gemini-cli`), and
 `agent` (Cursor Agent CLI). Enable with `cli_agents` in settings (e.g.
@@ -691,6 +732,7 @@ PI_PIDIFF_ENABLE=false pi
 | `acpx`              | Agent proxy for remote models                                                                                                                                                                                                                                                                                                  |
 | `kubectl` / `oc`    | Kubernetes and OpenShift CLI                                                                                                                                                                                                                                                                                                   |
 | `agent-browser`     | Browser automation CLI (navigate, click, screenshot, forms)                                                                                                                                                                                                                                                                    |
+| `graft`             | Local repository code graph for opt-in `graft_enable`; graph cache is stored in the mounted project’s `./graft/` directory                                                                                                                                                                                                        |
 | `procps`            | Process utilities (ps, top, pgrep, pkill)                                                                                                                                                                                                                                                                                      |
 | `passwd`            | `usermod`/`groupmod` — init remaps user `node` to `PI_HOST_UID`/`PI_HOST_GID`                                                                                                                                                                                                                                                  |
 | `docker` / `podman` | Container CLIs (used via `docker-safe` read-only wrapper)                                                                                                                                                                                                                                                                      |
@@ -844,7 +886,7 @@ See [DEVELOPMENT.md](DEVELOPMENT.md) for tips on testing extensions locally, run
 
 ## Prerequisites
 
-- [pi](https://github.com/badlogic/pi-mono) (minimum version: **0.84.4**). Pidash uses Pi's `ui_prompt_start` and `ui_prompt_end` events to show prompt wait separately from agent work.
+- [pi](https://github.com/badlogic/pi-mono) (minimum version: **0.87.0**). Pidash uses Pi's `ui_prompt_start` and `ui_prompt_end` events to show prompt wait separately from agent work.
 - `gh` CLI (for GitHub operations)
 - `uv` (for Python execution)
 - `myk-pi-tools` (optional, for `/pr-review` and `/release`)

package/extensions/coms/coms-p2p.ts

@@ -848,10 +848,11 @@ export default function (pi: ExtensionAPI) {
 		ackOk(socket, env.msg_id);
 	}
 
-	function buildAgentCard(): AgentCard {
+	async function buildAgentCard(): Promise<AgentCard> {
 		const ctx = currentCtx;
 		const ident = identity;
 		const pct = ctx ? Math.round(ctx.getContextUsage()?.percent ?? 0) : 0;
+		log.debug("build_agent_card", { hasIdentity: !!ident });
 		return {
 			name: ident?.name ?? "unknown",
 			purpose: ident?.purpose ?? "",
@@ -859,22 +860,24 @@ export default function (pi: ExtensionAPI) {
 			color: ident?.color ?? "#36F9F6",
 			context_used_pct: pct,
 			queue_depth: getPendingInboundCount(),
-			tasks_summary: readTaskSummary(currentCtx?.cwd ?? process.cwd(), currentCtx?.sessionManager?.getSessionId?.()),
+			tasks_summary: await readTaskSummary(currentCtx?.cwd ?? process.cwd(), currentCtx?.sessionManager?.getSessionId?.()),
 		};
 	}
 
 	/** Push current agent card to ping worker so it can respond independently */
-	function updatePingWorkerCard(): void {
+	async function updatePingWorkerCard(): Promise<void> {
+		log.debug("update_ping_worker_card", { ready: pingWorkerReady });
 		if (!pingWorker || !pingWorkerReady) return;
 		try {
-			const card = buildAgentCard();
+			const card = await buildAgentCard();
 			const pong: Pong = { type: "pong", msg_id: "", agent_card: card };
 			pingWorker.postMessage({ type: "update_card", pong });
 		} catch { /* ignore */ }
 	}
 
-	function handlePing(socket: net.Socket, env: PingEnvelope): void {
-		const card = buildAgentCard();
+	async function handlePing(socket: net.Socket, env: PingEnvelope): Promise<void> {
+		log.debug("handle_ping", { msgId: env.msg_id });
+		const card = await buildAgentCard();
 		const pong: Pong = { type: "pong", msg_id: env.msg_id, agent_card: card };
 		try {
 			socket.write(JSON.stringify(pong) + "\n");
@@ -883,7 +886,7 @@ export default function (pi: ExtensionAPI) {
 		}
 		try { socket.end(); } catch { /* ignore */ }
 		// Also update worker with latest card
-		updatePingWorkerCard();
+		await updatePingWorkerCard();
 	}
 
 	function isValidEnvelope(obj: any): obj is Envelope {
@@ -935,7 +938,7 @@ export default function (pi: ExtensionAPI) {
 				} else if (parsed.type === "response") {
 					handleResponse(socket, parsed as ResponseEnvelope);
 				} else if (parsed.type === "ping") {
-					handlePing(socket, parsed as PingEnvelope);
+					void handlePing(socket, parsed as PingEnvelope).catch(() => nack(socket, parsed.msg_id, "internal error"));
 				} else if (parsed.type === "task_update") {
 					handleTaskUpdate(socket, parsed as TaskUpdateEnvelope);
 				} else if (parsed.type === "queue_manage") {
@@ -1994,7 +1997,7 @@ Do not respond to this message.`;
 			// Append sender's active tasks for this peer to the prompt
 			let promptText = params.prompt;
 			try {
-				const { listTasksForSession } = require("../pitasks/index.js");
+				const { listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const allTasks = listTasksForSession(targetPiSessionId, target.cwd) || [];
 				const myTasks = allTasks.filter((t: any) =>
@@ -2021,27 +2024,8 @@ Do not respond to this message.`;
 				tasks: params.tasks ?? null,
 			};
 
-			// Send the envelope synchronously and wait for the receiver's ack.
-			await sendEnvelope(target.endpoint, env);
-			comsSendCalledThisTurn.add(target.coms_session_id);
-
-			// Auto-create tasks on the target's task store (sender-side, instant)
-			if (params.tasks && params.tasks.length > 0 && target.coms_session_id) {
-				try {
-					const count = createComsInboundTasks(
-						params.tasks,
-						{ sender_session: identity.coms_session_id, sender_name: identity.name, sender_endpoint: identity.endpoint },
-						target.pi_session_id || target.coms_session_id,
-						target.cwd,
-					);
-					if (count > 0) {
-						log.info("tasks_auto_created", msg_id, "to", target.name, "count", count);
-					}
-				} catch { /* best-effort */ }
-			}
-
-			// Register a pending entry whose promise the receiver-side handleResponse
-			// (or the timeout below) will settle.
+			// Register before sending. A peer may acknowledge and respond before
+			// task creation's dynamic import completes.
 			let resolveFn!: (v: { response?: any; error?: string | null }) => void;
 			let rejectFn!: (e: Error) => void;
 			const promise = new Promise<{ response?: any; error?: string | null }>((res, rej) => {
@@ -2069,13 +2053,37 @@ Do not respond to this message.`;
 			try { (entry.timer as any).unref?.(); } catch { /* ignore */ }
 			pendingReplies.set(msg_id, entry);
 
-			log.debug("outbound_prompt", msg_id, "to", target.name, "hops", hops);
-
-			// Track pending outbound
 			const targetKey = target.name;
 			if (!pendingOutbound.has(targetKey)) pendingOutbound.set(targetKey, new Set());
 			pendingOutbound.get(targetKey)!.add(msg_id);
 
+			try {
+				await sendEnvelope(target.endpoint, env);
+			} catch (error) {
+				pendingReplies.delete(msg_id);
+				pendingOutbound.get(targetKey)?.delete(msg_id);
+				if (pendingOutbound.get(targetKey)?.size === 0) pendingOutbound.delete(targetKey);
+				if (entry.timer) clearTimeout(entry.timer);
+				throw error;
+			}
+			comsSendCalledThisTurn.add(target.coms_session_id);
+
+			if (params.tasks && params.tasks.length > 0 && target.coms_session_id) {
+				try {
+					const count = await createComsInboundTasks(
+						params.tasks,
+						{ sender_session: identity.coms_session_id, sender_name: identity.name, sender_endpoint: identity.endpoint },
+						target.pi_session_id || target.coms_session_id,
+						target.cwd,
+					);
+					if (count > 0) log.info("tasks_auto_created", msg_id, "to", target.name, "count", count);
+				} catch (error) {
+					log.warn("tasks_auto_create_failed", { msg_id, target: target.name, error: error instanceof Error ? error.message : String(error) });
+				}
+			}
+
+			log.debug("outbound_prompt", msg_id, "to", target.name, "hops", hops);
+
 			// Peer status from peerCards
 			const peerCard = peerCards.get(target.coms_session_id);
 			const peer_queue_depth = peerCard?.queue_depth ?? 0;
@@ -2305,6 +2313,7 @@ Do not respond to this message.`;
 			}), { description: "Tasks to create on the peer" }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_tasks_create_start", { target: params.target, count: params.tasks?.length ?? 0 });
 			if (!identity) throw new Error("coms not initialised");
 			if (!params.tasks || params.tasks.length === 0) throw new Error("coms_tasks_create requires at least one task");
 			const target = await resolveTarget(params.target);
@@ -2320,7 +2329,7 @@ Do not respond to this message.`;
 			if (identity.endpoint) meta.sender_endpoint = identity.endpoint;
 
 			try {
-				const { createTasksForSession, listTasksForSession, updateTaskForSession } = require("../pitasks/index.js");
+				const { createTasksForSession, listTasksForSession, updateTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 
 				// Create all tasks in one batch
@@ -2401,12 +2410,13 @@ Do not respond to this message.`;
 			task_id: Type.String({ description: "Task ID to delete." }),
 		}),
 		async execute(_callId, params) {
+			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);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession, deleteTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, deleteTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found`);
@@ -2440,12 +2450,13 @@ Do not respond to this message.`;
 			target: Type.String({ description: "Peer name or session_id." }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_list_start", { target: params.target });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { listTasksForSession } = require("../pitasks/index.js");
+				const { listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const tasks = listTasksForSession(targetPiSessionId, target.cwd);
 				log.debug("coms_task_list", target.name, "tasks", tasks?.length ?? 0);
@@ -2494,12 +2505,13 @@ Do not respond to this message.`;
 			task_id: Type.String({ description: "Task ID to retrieve." }),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_get_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, listTasksForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found on ${target.name}`);
@@ -2512,7 +2524,6 @@ Do not respond to this message.`;
 				if (task.owner) lines.push(`Owner: ${task.owner}`);
 				lines.push(`Description: ${desc}`);
 				if (task.blockedBy?.length > 0) {
-					const { listTasksForSession } = require("../pitasks/index.js");
 					const allTasks = listTasksForSession(targetPiSessionId, target.cwd);
 					const openBlockers = task.blockedBy.filter((bid: string) => {
 						const blocker = allTasks.find((bt: any) => bt.id === bid);
@@ -2549,12 +2560,13 @@ Do not respond to this message.`;
 			addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that block this task" })),
 		}),
 		async execute(_callId, params) {
+			log.debug("coms_task_update_start", { target: params.target, taskId: params.task_id });
 			if (!identity) throw new Error("coms not initialised");
 			const target = await resolveTarget(params.target);
 			if (!target) throw new Error(`coms: no live agent matching "${params.target}"`);
 
 			try {
-				const { getTaskForSession, updateTaskForSession } = require("../pitasks/index.js");
+				const { getTaskForSession, updateTaskForSession } = await import("../pitasks/index.js");
 				const targetPiSessionId = target.pi_session_id || target.coms_session_id;
 				const task = getTaskForSession(targetPiSessionId, params.task_id, target.cwd);
 				if (!task) throw new Error(`Task #${params.task_id} not found on ${target.name}`);

package/extensions/coms/coms-shared.ts

@@ -461,9 +461,10 @@ export function readFrontmatterFromArgv(argv: string[]): { name?: string; descri
 	}
 }
 
-export function readTaskSummary(_cwd: string, _sessionId?: string): { total: number; completed: number; in_progress: number } | null {
+export async function readTaskSummary(_cwd: string, _sessionId?: string): Promise<{ total: number; completed: number; in_progress: number } | null> {
+	log.debug("read_task_summary", { hasSessionId: !!_sessionId });
 	try {
-		const { listTasks } = require("../pitasks/index.js");
+		const { listTasks } = await import("../pitasks/index.js");
 		const tasks = listTasks();
 		if (!tasks || tasks.length === 0) return null;
 		let total = 0, completed = 0, in_progress = 0;
@@ -650,17 +651,18 @@ const MAX_TASK_FIELD_LEN = 2000;
  * Runs on the SENDER side — uses createTaskForSession with the target's session ID.
  * TaskStore handles locking, file format, everything.
  */
-export function createComsInboundTasks(
+export async function createComsInboundTasks(
 	tasks: Array<{ subject: string; description: string }>,
 	origin: ComsOrigin,
 	targetSessionId: string,
 	targetCwd?: string,
-): number {
+): Promise<number> {
+	log.debug("create_coms_inbound_tasks", { targetSessionId, count: tasks?.length ?? 0 });
 	if (!tasks || tasks.length === 0 || !targetSessionId) return 0;
 
 	let createTaskForSession: any;
 	try {
-		createTaskForSession = require("../pitasks/index.js").createTaskForSession;
+		createTaskForSession = (await import("../pitasks/index.js")).createTaskForSession;
 	} catch { return 0; }
 	if (!createTaskForSession) return 0;
 

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

@@ -4,13 +4,16 @@ import { createRuntimeProvider } from "../shared/create-runtime-provider.js";
 import { createLogger } from "../shared/logger.js";
 import {
   OpenAiCompatibleDiscoveryCache,
+  buildLiteLlmCapabilitiesUrl,
   buildOpenAiCompatibleModelsRequest,
+  enrichLiteLlmReasoning,
   findEligibleOpenAiCompatibleProviderConfigsResult,
   formatOpenAiCompatibleDiscoverySummary,
   materializeOpenAiCompatibleModels,
   openAiCompatibleConnectionFingerprint,
   redactOpenAiCompatibleDiagnostic,
   resolveStaticOpenAiCompatibleHeaders,
+  type LiteLlmCapabilityRecord,
   type OpenAiCompatibleModelRecord,
   type ResolvedOpenAiCompatibleConnection,
 } from "../shared/openai-compatible-discovery.js";
@@ -28,6 +31,18 @@ function responseRecords(payload: unknown): OpenAiCompatibleModelRecord[] {
   });
 }
 
+function capabilityRecords(payload: unknown): LiteLlmCapabilityRecord[] {
+  if (!payload || typeof payload !== "object" || !Array.isArray((payload as { data?: unknown }).data))
+    throw new Error("LiteLLM capability response must contain a data array");
+  return (payload as { data: unknown[] }).data.filter(
+    (record): record is LiteLlmCapabilityRecord => Boolean(record) && typeof record === "object" && !Array.isArray(record),
+  );
+}
+
+function isLiteLlmProvider(sourceProviderId: string, source: Provider): boolean {
+  return `${sourceProviderId} ${source.name ?? ""}`.toLowerCase().includes("litellm");
+}
+
 function resolvedConnection(source: Provider, auth?: AuthResult, staticHeaders?: Record<string, string>): ResolvedOpenAiCompatibleConnection {
   return {
     baseUrl: auth?.auth.baseUrl ?? source.baseUrl,
@@ -84,7 +99,20 @@ async function discoverProvider(
         signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]),
       });
       if (!response.ok) throw new Error(`OpenAI-compatible /v1/models returned HTTP ${response.status}`);
-      return responseRecords(await response.json());
+      const records = responseRecords(await response.json());
+      if (!isLiteLlmProvider(sourceProviderId, source)) return records;
+      try {
+        const capabilityResponse = await fetch(buildLiteLlmCapabilitiesUrl(request.url), {
+          headers: request.headers,
+          redirect: "error",
+          signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]),
+        });
+        if (!capabilityResponse.ok) throw new Error(`LiteLLM capability endpoint returned HTTP ${capabilityResponse.status}`);
+        return enrichLiteLlmReasoning(records, capabilityRecords(await capabilityResponse.json()));
+      } catch (error) {
+        log.warn(`${sourceProviderId}: reasoning capability enrichment unavailable`, redactOpenAiCompatibleDiagnostic(error instanceof Error ? error.message : String(error), connection));
+        return records;
+      }
     } catch (error) {
       log.warn(`${sourceProviderId}: discovery refresh failed`, redactOpenAiCompatibleDiagnostic(error instanceof Error ? error.message : String(error), connection));
       throw error;

package/extensions/orchestrator/agents.ts

@@ -9,7 +9,13 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("agents");
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 export type AgentScope = "user" | "project" | "both";
 
@@ -103,7 +109,9 @@ function findNearestProjectAgentsDir(cwd: string): string | null {
  * and the agents are in ../../agents/ relative to this file.
  */
 function getPackageAgentsDir(): string {
-	return path.resolve(__dirname, "..", "..", "agents");
+	const resolvedPath = path.resolve(MODULE_DIR, "..", "..", "agents");
+	log.debug("resolved package agents directory", { path: resolvedPath });
+	return resolvedPath;
 }
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {

package/extensions/orchestrator/async-agents.ts

@@ -15,6 +15,7 @@ const require = createRequire(import.meta.url);
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig, AgentDiscoveryResult } from "./agents.js";
 import { resolveAgentModelProvider } from "./resolve-agent-model.js";
+import { withGraftTools } from "./graft.js";
 import { getPiInvocation, getProjectTmpDir, parseProcStartTime, djb2Hash } from "./utils.js";
 import { addReviewerPending, recordReviewerResult, countFindings, readReviewState } from "./pi-config-review-state.js";
 import {
@@ -924,7 +925,8 @@ export function registerAsyncAgents(
     piArgs.push("--session-id", deterministicSessionId);
     if (effectiveModel) piArgs.push("--model", effectiveModel);
     if (effectiveProvider) piArgs.push("--provider", effectiveProvider);
-    if (agent.tools?.length) piArgs.push("--tools", agent.tools.join(","));
+    const tools = withGraftTools(agent.tools, getSetting(cwd, "graft_enable"));
+    if (tools?.length) piArgs.push("--tools", tools.join(","));
 
     if (agent.systemPrompt?.trim()) {
       const promptPath = path.join(workerDir, "system-prompt.md");