@danypops/pi-papyrus 0.38.4 → 0.39.0

package/extension/src/domain-tools.ts

@@ -8,6 +8,8 @@ import {
 	type DiscussionRound,
 	type GateResult,
 	type OperationName,
+	type PlaybookInvocationResult,
+	type PlaybookMissingArguments,
 	type WorkflowRunResult,
 	type TaskCompletion,
 	type TaskExecutionPlan,
@@ -138,16 +140,49 @@ export function matchArtifactByName(candidates: Artifact[], name: string): strin
 	return matches[0]!.id;
 }
 
+/**
+ * tasks.list is the one list operation that requires `project_root` and separately supports a
+ * `scope` ("project" | "graph" | "all") to widen or narrow the search. Every other list operation
+ * (docs.list, rules.list, skills.list, playbooks.list, artifact.query, ...) instead treats an
+ * omitted `project_root` as an unscoped/global search (domain-services.ts's listScoped) and has
+ * no `scope` concept at all -- so "search everywhere" means something different for each.
+ */
+const SCOPE_AWARE_LIST_OPERATIONS = new Set<OperationName>(["tasks.list"]);
+
+/** The widened-scope request tried once when a name isn't found under the caller's current scope. */
+function widenedRequest(listOperation: OperationName, baseRequest: Record<string, unknown>): Record<string, unknown> {
+	return SCOPE_AWARE_LIST_OPERATIONS.has(listOperation)
+		? { ...baseRequest, scope: "all" }
+		: { ...baseRequest, project_root: undefined };
+}
+
 /**
  * Resolves a name to its id via `listOperation` (whichever kind's list call is the right search
  * scope -- tasks.list, docs.list, rules.list, skills.list, notes.list, discuss.list, or the
  * kind-agnostic artifact.query for a cross-kind reference like a link target). `baseRequest`
  * should mirror whatever scoping (project_root, etc.) that operation's own "list" action already
  * uses, so resolution never searches a wider or narrower scope than a plain list call would.
+ *
+ * A two-artifact action (depend/contain/gate/link) routinely names artifacts that live in two
+ * different projects, and one call has no way to give two different name fields two different
+ * scopes. When the first lookup finds nothing under the caller's current scope, retry exactly
+ * once against a global search before giving up -- but never when the caller already pinned an
+ * explicit `scope`, so a genuine "not found in the scope I asked for" stays a real error instead
+ * of being silently papered over. `notes`, when given, records that a name only resolved after
+ * widening, so the caller can surface that a search went wider than the caller's default scope
+ * rather than resolving silently.
  */
-async function resolveArtifactIdByName(listOperation: OperationName, baseRequest: Record<string, unknown>, name: string): Promise<string> {
+async function resolveArtifactIdByName(listOperation: OperationName, baseRequest: Record<string, unknown>, name: string, notes?: string[]): Promise<string> {
 	const candidates = await callService<Record<string, unknown>, Artifact[]>(listOperation, { ...baseRequest, text: name });
-	return matchArtifactByName(candidates, name);
+	try {
+		return matchArtifactByName(candidates, name);
+	} catch (error) {
+		if (!(error instanceof Error) || !error.message.startsWith("no artifact named") || baseRequest["scope"] !== undefined) throw error;
+		const widenedCandidates = await callService<Record<string, unknown>, Artifact[]>(listOperation, { ...widenedRequest(listOperation, baseRequest), text: name });
+		const id = matchArtifactByName(widenedCandidates, name);
+		notes?.push(`"${name}" was not found in the current project scope; resolved across all projects instead.`);
+		return id;
+	}
 }
 
 /**
@@ -167,15 +202,21 @@ export function normalizeJsonEncodedField(params: Record<string, unknown>, key:
 	}
 }
 
-/** Resolves every {nameKey -> idKey} pair present and not already satisfied by an explicit id, in place. */
+/**
+ * Resolves every {nameKey -> idKey} pair present and not already satisfied by an explicit id, in
+ * place. `notes`, when given, collects a message for each name that only resolved by widening
+ * past the caller's own scope (see resolveArtifactIdByName) -- callers that want that surfaced
+ * to the model/human pass an array here and append it to their own response text.
+ */
 export async function resolveNameFields(
 	params: Record<string, unknown>,
 	fields: ReadonlyArray<{ nameKey: string; idKey: string; listOperation: OperationName; baseRequest: Record<string, unknown> }>,
+	notes?: string[],
 ): Promise<void> {
 	for (const { nameKey, idKey, listOperation, baseRequest } of fields) {
 		const nameValue = params[nameKey];
 		if (typeof nameValue === "string" && nameValue.length > 0 && !params[idKey]) {
-			params[idKey] = await resolveArtifactIdByName(listOperation, baseRequest, nameValue);
+			params[idKey] = await resolveArtifactIdByName(listOperation, baseRequest, nameValue, notes);
 		}
 	}
 }
@@ -187,10 +228,11 @@ async function resolveNameArrayField(
 	idsKey: string,
 	listOperation: OperationName,
 	baseRequest: Record<string, unknown>,
+	notes?: string[],
 ): Promise<void> {
 	const names = params[namesKey];
 	if (Array.isArray(names) && names.length > 0 && !params[idsKey]) {
-		params[idsKey] = await Promise.all(names.map((entry) => resolveArtifactIdByName(listOperation, baseRequest, String(entry))));
+		params[idsKey] = await Promise.all(names.map((entry) => resolveArtifactIdByName(listOperation, baseRequest, String(entry), notes)));
 	}
 }
 
@@ -248,7 +290,7 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, update, list, show, history, context, scope, set_scope, assign_project, graph, plan, active, focused, focus, pause, unpause, clear_focus, start, submit, complete, reject, retry, cancel, cancel_subtree, run_gates, set_checklist, set_gates, depend, undepend, contain, uncontain, remove, remove_subtree, restore, claim, heartbeat_lease, release_lease, lease, event_feed. Lifecycle: todo → in-progress → review → done; review failure → rejected → retry → in-progress; canceled is terminal. Focus and lease are independent of lifecycle and of each other -- multiple sessions can focus the same task while only one holds its lease (claim throws if a different owner already holds one; release/heartbeat need the exact token claim returned; owner defaults to this session's id). context returns the full plan (the system prompt itself only carries a one-line pointer) -- call it explicitly after a compaction or before reconciling. complete runs gates + checklist-proof review, then focuses one ready successor. cancel_subtree cancels a task and its whole containment subtree in one call, skipping tasks already done/canceled. remove/restore use a time-gated trash (refuses the live Focus); remove_subtree trashes a whole `contains` subtree in one call; undepend/uncontain are idempotent no-ops when the edge is already absent. update recovers an accidentally-terminal task via status=todo + reason, without rewriting real history; update never touches gates (title/body/labels/status only) -- use set_gates to replace a task's gate commands after creation. Prefer `name` (exact title) over `id` -- id is a backend detail, resolved automatically, needed only to disambiguate a shared title; `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` are the same pattern for their `_id` counterparts.",
+		description: "Task domain tool. ACTIONS: create, update, list, show, history, context, scope, set_scope, assign_project, graph, plan, active, focused, focus, pause, unpause, clear_focus, start, submit, complete, reject, retry, cancel, cancel_subtree, run_gates, set_checklist, set_gates, depend, undepend, contain, uncontain, remove, remove_subtree, restore, claim, heartbeat_lease, release_lease, lease, event_feed. Lifecycle: todo → in-progress → review → done; review failure → rejected → retry → in-progress; canceled is terminal. Focus and lease are independent of lifecycle and of each other -- multiple sessions can focus the same task while only one holds its lease (claim throws if a different owner already holds one; release/heartbeat need the exact token claim returned; owner defaults to this session's id). context returns the full plan (the system prompt itself only carries a one-line pointer) -- call it explicitly after a compaction or before reconciling. complete runs gates + checklist-proof review, then focuses one ready successor. cancel_subtree cancels a task and its whole containment subtree in one call, skipping tasks already done/canceled. remove/restore use a time-gated trash (refuses the live Focus); remove_subtree trashes a whole `contains` subtree in one call; undepend/uncontain are idempotent no-ops when the edge is already absent. update recovers an accidentally-terminal task via status=todo + reason, without rewriting real history; update never touches gates (title/body/labels/status only) -- use set_gates to replace a task's gate commands after creation. Prefer `name` (exact title) over `id` -- id is a backend detail, resolved automatically, needed only to disambiguate a shared title; `parent_name`/`child_name`/`root_task_name` are the same pattern for their `_id` counterparts. For a prerequisite, use `dependency_name` (singular, resolved to `dependency_id`) with the `depend`/`undepend` actions; `depends_on_names` (plural array, resolved to `depends_on`) is only for `create`'s initial dependency set -- passing the wrong one of the two to `depend` leaves `dependency_id` unset and fails with a `dependency_id is required` error. A name resolved outside this call's own project scope (e.g. depending on a task in a different project) is retried once against every project before failing, and the response notes when that happened.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -299,12 +341,17 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 				// ever holds this extension's own registered session anyway (see session-identity.ts).
 				const resolvedSessionId = params.session_id ?? ctx.sessionManager.getSessionId();
 				const baseRequest = { project_root: params.project_root ?? ctx.cwd, actor: "agent", source: "pi-tool", session_id: resolvedSessionId, ...sessionSecretField(resolvedSessionId as string) };
+				// Collects a note whenever a name field below only resolved by widening past this call's
+				// own project scope (see resolveArtifactIdByName) -- surfaced at the end of this action's
+				// own response text rather than resolved silently, since a cross-project depend/contain
+				// is exactly the case a shared per-call scope can't otherwise express.
+				const notes: string[] = [];
 				// Resolve the graph root first: every other name lookup must use the caller's final
 				// project/scope/root selection, otherwise `scope: all|graph` silently collapses back
 				// to the current project and forces callers to reach for an id.
 				await resolveNameFields(params, [
 					{ nameKey: "root_task_name", idKey: "root_task_id", listOperation: "tasks.list", baseRequest: { ...baseRequest, scope: "project" } },
-				]);
+				], notes);
 				const resolutionRequest = {
 					...baseRequest,
 					...(params.scope === undefined ? {} : { scope: params.scope }),
@@ -317,9 +364,10 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 					{ nameKey: "dependency_name", idKey: "dependency_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
 					{ nameKey: "parent_name", idKey: "parent_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
 					{ nameKey: "child_name", idKey: "child_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
-				]);
-				await resolveNameArrayField(params, "depends_on_names", "depends_on", "tasks.list", resolutionRequest);
+				], notes);
+				await resolveNameArrayField(params, "depends_on_names", "depends_on", "tasks.list", resolutionRequest, notes);
 				const request = { ...params, ...baseRequest };
+				const result = await (async (): Promise<ReturnType<typeof text>> => {
 				if (action === "create") {
 					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", request);
 					return text(`Created task ${artifactLine(artifact)}`, createArtifactDetails("tasks.create", artifact));
@@ -482,6 +530,9 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 				const artifact = await callService<Record<string, unknown>, Artifact>(operation, request);
 				if (operation === "tasks.focus") emitTaskFocusEvent({ taskId: artifact.id, sessionId: request.session_id as string, status: "focused" });
 				return text(artifactLine(artifact), createArtifactDetails(operation, artifact));
+				})();
+				if (notes.length > 0 && result.content[0]?.type === "text") result.content[0].text += `\n\n${notes.join("\n")}`;
+				return result;
 			} catch (error) {
 				throw new Error(`tasks failed: ${error instanceof Error ? error.message : error}`);
 			}
@@ -489,121 +540,9 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 	});
 }
 
-// notes.* is registered as a real Vehicle (see ../vehicle-notes-client.ts and index.ts),
-// not a hand-rolled pi.registerTool() -- the first domain migrated off the
-// action-dispatch mega-tool pattern this file's other tools still use.
-
-export function registerDocsTool(pi: ExtensionAPI): void {
-	pi.registerTool({
-		name: "docs",
-		label: "Documents",
-		description: "Document domain tool. ACTIONS: create, list, show, activate, archive, reopen, link, assign_project, update, remove, remove_subtree, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. update changes title/body/labels (at least one required) and is refused for a read-only external projection (e.g. web-spider-ingested Docs) -- capture a correction as a new linked Doc instead. remove moves a Doc to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline; remove_subtree extends this to a whole `contains` subtree in one call. PREFER `name` (the doc's exact title) over `id`, and `target_name` over `target_id` for link -- both are backend implementation details, resolved from name automatically (target_name searches across every kind, since a link target can be a doc, task, rule, or skill). Prefer this over low-level papyrus_* tools for document work.",
-		parameters: Type.Object({
-			action: Type.String(),
-			id: Type.Optional(Type.String()),
-			name: Type.Optional(Type.String()),
-			title: Type.Optional(Type.String()),
-			body: Type.Optional(Type.String()),
-			subtype: Type.Optional(Type.String()),
-			status: Type.Optional(Type.String()),
-			text: Type.Optional(Type.String()),
-			limit: Type.Optional(Type.Number()),
-			labels: Type.Optional(Type.Array(Type.String())),
-			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-			template_id: Type.Optional(Type.String()),
-			relation: Type.Optional(Type.String()),
-			target_id: Type.Optional(Type.String()),
-			target_name: Type.Optional(Type.String()),
-			project_root: Type.Optional(Type.String()),
-			reason: Type.Optional(Type.String()),
-		}),
-		renderCall(args, theme) { return renderPapyrusToolCall("Documents", args, theme); },
-		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
-		async execute(_id, rawParams) {
-			try {
-				const params: Record<string, unknown> = { ...rawParams };
-				const action = params.action;
-				const scopeRequest = { project_root: params.project_root };
-				await resolveNameFields(params, [
-					{ nameKey: "name", idKey: "id", listOperation: "docs.list", baseRequest: scopeRequest },
-					// Kind-agnostic: a link target can be a doc, task, rule, or skill, so this searches every kind rather than only docs.
-					{ nameKey: "target_name", idKey: "target_id", listOperation: "artifact.query", baseRequest: scopeRequest },
-				]);
-				if (action === "create") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("docs.create", params);
-					return text(`Created document ${artifactLine(artifact)}`, createArtifactDetails("docs.create", artifact));
-				}
-				if (action === "list") {
-					const rows = await callService<Record<string, unknown>, Artifact[]>("docs.list", params);
-					return text(rows.length ? artifactLines(rows).join("\n") : "No documents found.", createArtifactListDetails("docs.list", rows));
-				}
-				if (action === "show") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("docs.show", params);
-					return text(`${artifactLine(artifact)}\n\n${artifact.body}`, createArtifactDetails("docs.show", artifact));
-				}
-				const trashResult = await handleArtifactRemoveRestore(action, params);
-				if (trashResult) return trashResult;
-				const operations = { activate: "docs.activate", archive: "docs.archive", reopen: "docs.reopen", link: "docs.link", assign_project: "docs.assign_project", update: "docs.update" } as const;
-				const operation = operations[action as keyof typeof operations];
-				if (!operation) throw new Error(`unknown docs action: ${action}`);
-				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
-				return text(artifactLine(artifact), createArtifactDetails(operation, artifact));
-			} catch (error) {
-				throw new Error(`docs failed: ${error instanceof Error ? error.message : error}`);
-			}
-		},
-	});
-}
-
-export function registerRulesTool(pi: ExtensionAPI): void {
-	pi.registerTool({
-		name: "rules",
-		label: "Rules",
-		description: "Rule domain tool. ACTIONS: create, list, show, preview, enable, disable, gate, assign_project, update, remove, remove_subtree, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. Active rules inject into the agent system prompt. update changes title/body/labels (at least one required); body updates still enforce the same combined condition+action+body context-tax bound as creation, and are refused for a read-only external projection. remove moves a Rule to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline; remove_subtree extends this to a whole `contains` subtree in one call. PREFER `name` (the rule's exact title) over `id`, and `task_name` over `task_id` for gate -- both are backend implementation details, resolved from name automatically.",
-		parameters: Type.Object({
-			action: Type.String(), id: Type.Optional(Type.String()), name: Type.Optional(Type.String()), title: Type.Optional(Type.String()),
-			body: Type.Optional(Type.String()), condition: Type.Optional(Type.String()), rule_action: Type.Optional(Type.String()),
-			severity: Type.Optional(Type.String()), labels: Type.Optional(Type.Array(Type.String())),
-			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())), status: Type.Optional(Type.String()),
-			text: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()), task_id: Type.Optional(Type.String()),
-			task_name: Type.Optional(Type.String()),
-			project_root: Type.Optional(Type.String()), reason: Type.Optional(Type.String()),
-		}),
-		renderCall(args, theme) { return renderPapyrusToolCall("Rules", args, theme); },
-		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
-		async execute(_id, rawParams, _signal, _onUpdate, ctx) {
-			try {
-				const params: Record<string, unknown> = { ...rawParams };
-				const action = params.action;
-				await resolveNameFields(params, [
-					{ nameKey: "name", idKey: "id", listOperation: "rules.list", baseRequest: { project_root: params.project_root } },
-					{ nameKey: "task_name", idKey: "task_id", listOperation: "tasks.list", baseRequest: { project_root: params.project_root ?? ctx.cwd } },
-				]);
-				if (action === "create") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("rules.create", params);
-					return text(`Created rule ${artifactLine(artifact)}`, createArtifactDetails("rules.create", artifact));
-				}
-				if (action === "list") {
-					const rows = await callService<Record<string, unknown>, Artifact[]>("rules.list", params);
-					return text(rows.length ? artifactLines(rows).join("\n") : "No rules found.", createArtifactListDetails("rules.list", rows));
-				}
-				if (action === "preview") {
-					const preview = await callService<Record<string, unknown>, string>("rules.preview", params);
-					return text(preview, createPreviewDetails("rules.preview", "Rule preview", preview));
-				}
-				const trashResult = await handleArtifactRemoveRestore(action, params);
-				if (trashResult) return trashResult;
-				const operations = { show: "rules.show", enable: "rules.enable", disable: "rules.disable", gate: "rules.gate", assign_project: "rules.assign_project", update: "rules.update" } as const;
-				const operation = operations[action as keyof typeof operations];
-				if (!operation) throw new Error(`unknown rules action: ${action}`);
-				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
-				return text(`${artifactLine(artifact)}${action === "show" ? `\n\n${artifact.body}` : ""}`, createArtifactDetails(operation, artifact));
-			} catch (error) {
-				throw new Error(`rules failed: ${error instanceof Error ? error.message : error}`);
-			}
-		},
-	});
-}
+// notes.*, rules.*, docs.*, and the shared artifact.* are registered as Vehicles
+// (see ../vehicle-notes-client.ts and @danypops/papyrus's src/vehicle/papyrus-vehicle.ts),
+// not pi.registerTool()s in this file.
 
 export function registerPlaybooksTool(pi: ExtensionAPI): void {
 	pi.registerTool({
@@ -672,13 +611,33 @@ export function registerPlaybooksTool(pi: ExtensionAPI): void {
 					return text(rendered, createPreviewDetails("playbooks.preview", "Playbook preview", rendered));
 				}
 				if (action === "invoke") {
-					const invocation = await callService<Record<string, unknown>, { entryTaskId?: string; rootTaskIds?: string[]; created?: { tasks: string[] }; missingArguments?: string[] }>("playbooks.invoke", params);
-					if (invocation.missingArguments) {
+					const invocation = await callService<Record<string, unknown>, PlaybookInvocationResult | PlaybookMissingArguments>("playbooks.invoke", params);
+					if ("missingArguments" in invocation) {
 						const message = `Missing required argument(s): ${invocation.missingArguments.join(", ")}. Nothing was created -- ask the human for these (discuss tool, live:true), then invoke again.`;
-						return text(message, createPreviewDetails("playbooks.invoke", "Playbook invocation", message));
+						return text(message, createInvocationDetails("playbooks.invoke", invocation.playbookId, { tasks: [], docs: [], rules: [], roots: [] }));
 					}
-					const message = `Invoked: ${invocation.created?.tasks.length ?? 0} task(s) created, entry task ${invocation.entryTaskId} now focused. Drive it forward with the tasks tool (start/submit/complete) -- contains/depends_on wiring auto-focuses each next step.`;
-					return text(message, createPreviewDetails("playbooks.invoke", "Playbook invocation", JSON.stringify(invocation, null, 2)));
+					const nodeTitleCounts = new Map<string, number>();
+					for (const node of invocation.execution.nodes) nodeTitleCounts.set(node.title, (nodeTitleCounts.get(node.title) ?? 0) + 1);
+					const execution = invocation.execution.nodes.map((node) => (nodeTitleCounts.get(node.title) ?? 0) > 1
+						? `  [${node.state}] ${node.title} (${node.id})`
+						: `  [${node.state}] ${node.title}`).join("\n");
+					const nodeById = new Map(invocation.execution.nodes.map((node) => [node.id, node]));
+					const rootLabels = invocation.rootTaskIds.map((id) => nodeById.get(id)?.title ?? "unknown task");
+					const entryLabel = nodeById.get(invocation.entryTaskId)?.title ?? invocation.entryTaskId;
+					const createdLabels = await artifactLabelsById([...invocation.created.docs, ...invocation.created.rules]);
+					return text([
+						`Invoked playbook run ${invocation.runId}: ${invocation.created.tasks.length} task(s), ${invocation.created.rules.length} rule(s), ${invocation.created.docs.length} doc(s) created.`,
+						`Entry task now focused: ${entryLabel}. Drive it forward with the tasks tool (start/submit/complete) -- contains/depends_on wiring auto-focuses each next step.`,
+						`Ready roots: ${rootLabels.join(", ") || "none"}.`,
+						`Context docs: ${invocation.created.docs.map((id) => createdLabels.get(id) ?? "unknown document").join(", ") || "none"}.`,
+						`Scoped rules: ${invocation.created.rules.map((id) => createdLabels.get(id) ?? "unknown rule").join(", ") || "none"}.`,
+						...(execution ? ["Execution:", execution] : []),
+					].join("\n"), createInvocationDetails("playbooks.invoke", invocation.runId, {
+						tasks: invocation.created.tasks,
+						docs: invocation.created.docs,
+						rules: invocation.created.rules,
+						roots: invocation.rootTaskIds,
+					}));
 				}
 				const trashResult = await handleArtifactRemoveRestore(action, params);
 				if (trashResult) return trashResult;
@@ -879,10 +838,12 @@ export function registerDiscussTool(pi: ExtensionAPI): void {
 }
 
 /** Thin orchestrator: each domain's tool is independently navigable/testable via its own registerXTool function. */
+// docs and rules are no longer registered here -- both migrated onto Vehicle
+// (registerNotesVehicle in vehicle-notes-client.ts, wired at session_start in
+// index.ts), replacing their own pi.registerTool() mega-tools. See
+// @danypops/papyrus's src/vehicle/papyrus-vehicle.ts for the server side.
 export function registerDomainTools(pi: ExtensionAPI): void {
 	registerTasksTool(pi);
-	registerDocsTool(pi);
-	registerRulesTool(pi);
 	registerPlaybooksTool(pi);
 	registerSkillsTool(pi);
 	registerDiscussTool(pi);

package/extension/src/vehicle-notes-client.ts

@@ -1,39 +1,29 @@
 /**
- * Registers notes.* as a real Vehicle instead of a hand-rolled `pi.registerTool()`
- * mega-tool -- see @danypops/papyrus's src/vehicle/notes-vehicle.ts for the
- * VehicleRegistry side. Same daemon, same handle file, same Bearer token every
- * other Papyrus RPC call already uses (resolveVehicleClientTarget mirrors
- * resolvePushChannelTarget's own resolution).
+ * Registers every Vehicle-projected domain (notes.*, rules.*, docs.*, artifact.*)
+ * as real Pi tools -- see @danypops/papyrus's src/vehicle/papyrus-vehicle.ts.
  *
- * Papyrus's daemon is expected to already be running as an installed service
- * (see `packed install-service`), not auto-spawned on first use -- so unlike
- * registerVehicleTools' README example, failure here (daemon not started yet,
- * stale handle) is tolerated the same silent-degrade way
- * subscribeTaskPushChannel already tolerates it, rather than letting a
- * daemon-not-running condition abort the rest of extension setup. There is
- * no retry-on-later-connect for a tool that was never registered at all --
- * Pi has no way to add one after the fact outside the initial registration
- * flow.
+ * Fails silently on a stale/unreachable daemon handle instead of aborting extension
+ * setup: Papyrus's daemon doesn't auto-spawn, and a tool that failed to register
+ * here has no later retry path.
  *
- * Resolves the target through service-client.ts's currentVehicleClientTarget()
- * (test-injectable, see setVehicleClientTargetResolverForTests), never
- * @danypops/papyrus's resolveVehicleClientTarget() directly -- this runs from
- * the bare extension entrypoint on every registerPapyrus(api) call, so an
- * un-injected default would resolve the real daemonStateDir() in any test
- * exercising the full entrypoint, not just ones about notes.
+ * Uses service-client.ts's currentVehicleClientTarget() (test-injectable) rather
+ * than resolveVehicleClientTarget() directly, so a test exercising the full
+ * extension entrypoint doesn't resolve a real daemonStateDir().
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { RemoteVehicleClient } from "@danypops/vehicle-client/http";
 import { registerVehicleTools } from "@danypops/vehicle-client-pi";
 import { currentVehicleClientTarget } from "./service-client.ts";
 
+const REGISTERED_PERMISSIONS = ["notes:read", "notes:write", "rules:read", "rules:write", "docs:read", "docs:write", "artifact:read", "artifact:write"];
+
 export async function registerNotesVehicle(pi: ExtensionAPI): Promise<void> {
 	const target = currentVehicleClientTarget();
 	if (!target) return;
 	try {
 		const client = new RemoteVehicleClient({ baseUrl: target.baseUrl, token: target.token });
 		await registerVehicleTools(pi, client, {
-			permissions: ["notes:read", "notes:write"],
+			permissions: REGISTERED_PERMISSIONS,
 			principal: { id: "pi-papyrus" },
 		});
 	} catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-papyrus",
-  "version": "0.38.4",
+  "version": "0.39.0",
   "description": "Pi host extension for Papyrus: native tools, TUI panels, and context injection over the daemon-backed graph store",
   "type": "module",
   "keywords": ["pi-package"],
@@ -17,7 +17,7 @@
     "typebox": "*"
   },
   "dependencies": {
-    "@danypops/papyrus": "^0.38.1",
+    "@danypops/papyrus": "^0.39.0",
     "@danypops/vehicle-core": "^0.1.1",
     "@danypops/vehicle-server": "^0.1.1",
     "@danypops/vehicle-client": "^0.1.1",