@danypops/pi-papyrus 0.57.4 → 0.57.6

package/extension/src/context/activation-context.ts

@@ -0,0 +1,43 @@
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+
+export interface ActivationContextInput {
+	languages?: string[];
+	file_extensions?: string[];
+	session_capabilities?: string[];
+}
+
+const LANGUAGE_MARKERS: ReadonlyArray<{ language: string; files: string[] }> = [
+	{ language: "typescript", files: ["tsconfig.json"] },
+	{ language: "javascript", files: ["package.json"] },
+	{ language: "rust", files: ["Cargo.toml"] },
+	{ language: "go", files: ["go.mod"] },
+	{ language: "python", files: ["pyproject.toml", "requirements.txt"] },
+	{ language: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts"] },
+	{ language: "kotlin", files: ["build.gradle.kts"] },
+	{ language: "swift", files: ["Package.swift"] },
+	{ language: "zig", files: ["build.zig"] },
+];
+
+const PATH_TOKEN = /(?:^|[\s"'`(])([^\s"'`()]+\.[A-Za-z0-9]{1,10})(?=$|[\s"'`),:])/g;
+const MAX_EXTENSIONS = 32;
+const MAX_CAPABILITIES = 32;
+
+/** Derives only bounded, deterministic turn signals. It never executes project code or interprets free-form predicates. */
+export function buildActivationContext(cwd: string, prompt: string, selectedTools: readonly string[] = []): ActivationContextInput {
+	const languages = LANGUAGE_MARKERS.filter((entry) => entry.files.some((file) => existsSync(join(cwd, file))))
+		.map((entry) => entry.language)
+		.sort();
+	const extensions = new Set<string>();
+	for (const match of prompt.matchAll(PATH_TOKEN)) {
+		const extension = extname(match[1]!).toLowerCase();
+		if (extension) extensions.add(extension);
+		if (extensions.size >= MAX_EXTENSIONS) break;
+	}
+	const capabilities = [...new Set(selectedTools.filter((tool) => tool.length > 0))].sort().slice(0, MAX_CAPABILITIES);
+	return {
+		...(languages.length > 0 ? { languages } : {}),
+		...(extensions.size > 0 ? { file_extensions: [...extensions].sort() } : {}),
+		...(capabilities.length > 0 ? { session_capabilities: capabilities } : {}),
+	};
+}

package/extension/src/context/context-budget.ts

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import type { ContextSegmentItem } from "@danypops/jittor";
 import { type Artifact, CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN, CONTEXT_TREE_MAX_NODES, type TaskGraph } from "@danypops/papyrus";
+import { playbookInjectionPreview } from "../playbook/playbook-bridge.ts";
 import { ruleInjectionPreview } from "../rules/rules.ts";
 import { discoverSkillDirectories, type SkillCatalogFootprint, scanSkillCatalogFootprint } from "./skill-catalog-footprint.ts";
 
@@ -27,6 +28,10 @@ export interface ContextBudget {
 		totalCharacters: number;
 		totalEstimatedTokens: number;
 	};
+	playbooks: {
+		entries: Array<{ title: string; estimatedTokens: number }>;
+		totalEstimatedTokens: number;
+	};
 	skills: SkillCatalogFootprint;
 	totalEstimatedTokens: number;
 }
@@ -61,12 +66,26 @@ export function computeContextBudget(
 	rules: ReadonlyArray<Pick<Artifact, "id" | "title" | "body" | "extra">>,
 	cwd: string,
 	homeDirectory: string = homedir(),
+	playbooks: ReadonlyArray<Pick<Artifact, "title" | "extra">> = [],
 ): ContextBudget {
 	const settingsSkills = readSettingsSkillPaths(`${homeDirectory}/.pi/agent/settings.json`);
 	const directories = discoverSkillDirectories(homeDirectory, cwd, settingsSkills);
 	const skills = scanSkillCatalogFootprint(directories);
 	const ruleBudget = computeRuleBudget(rules);
-	return { rules: ruleBudget, skills, totalEstimatedTokens: ruleBudget.totalEstimatedTokens + skills.totalEstimatedTokens };
+	const playbookEntries = playbooks.map((playbook) => ({
+		title: playbook.title,
+		estimatedTokens: Math.ceil(playbookInjectionPreview(playbook).length / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN),
+	}));
+	const playbookBudget = {
+		entries: playbookEntries,
+		totalEstimatedTokens: playbookEntries.reduce((sum, entry) => sum + entry.estimatedTokens, 0),
+	};
+	return {
+		rules: ruleBudget,
+		playbooks: playbookBudget,
+		skills,
+		totalEstimatedTokens: ruleBudget.totalEstimatedTokens + playbookBudget.totalEstimatedTokens + skills.totalEstimatedTokens,
+	};
 }
 
 /** Sums a possibly-nested item tree's tokens recursively -- every node's own contribution, not just top-level items. */

package/extension/src/context/context-hub-contribution.ts

@@ -17,6 +17,7 @@ export function papyrusContextSegment(
 	ruleBudget: ContextBudget["rules"],
 	taskItems: ContextSegmentItem[],
 	skills: SkillCatalogFootprint,
+	playbookBudget?: ContextBudget["playbooks"],
 ): ContextSegment {
 	const items: ContextSegmentItem[] = [];
 	if (ruleBudget.entries.length > 0) {
@@ -26,6 +27,13 @@ export function papyrusContextSegment(
 			children: ruleBudget.entries.map((entry) => ({ label: entry.title, estimatedTokens: entry.estimatedTokens })),
 		});
 	}
+	if ((playbookBudget?.entries.length ?? 0) > 0) {
+		items.push({
+			label: "Available Playbooks",
+			estimatedTokens: playbookBudget!.totalEstimatedTokens,
+			children: playbookBudget!.entries.map((entry) => ({ label: entry.title, estimatedTokens: entry.estimatedTokens })),
+		});
+	}
 	if (taskItems.length > 0) {
 		items.push({ label: "Open Tasks", estimatedTokens: sumItemTree(taskItems), children: taskItems });
 	}
@@ -38,7 +46,7 @@ export function papyrusContextSegment(
 	}
 	return {
 		key: "papyrus",
-		label: "Papyrus (Rules, Tasks, Skills)",
+		label: "Papyrus (Rules, Playbooks, Tasks, Skills)",
 		estimatedTokens: items.reduce((sum, item) => sum + item.estimatedTokens, 0),
 		confidence: "exact-cooperative",
 		...(items.length > 0 ? { items } : {}),

package/extension/src/context/context-injection-telemetry.ts

@@ -1,5 +1,11 @@
 import { createHash } from "node:crypto";
-import { type Artifact, CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN, PAPYRUS_CONTEXT_INJECTION_SCHEMA } from "@danypops/papyrus";
+import {
+	type Artifact,
+	activationConfig,
+	CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN,
+	PAPYRUS_CONTEXT_INJECTION_MAX_TOKENS,
+	PAPYRUS_CONTEXT_INJECTION_SCHEMA,
+} from "@danypops/papyrus";
 import { playbookInjectionPreview } from "../playbook/playbook-bridge.ts";
 import { ruleInjectionPreview } from "../rules/rules.ts";
 
@@ -14,8 +20,8 @@ export interface PapyrusContextInjectionObservation {
 	sequence: number;
 	producerId: string;
 	before: ContextPayloadSize;
-	rules: ContextPayloadSize & { count: number };
-	playbooks: ContextPayloadSize & { count: number };
+	rules: ContextPayloadSize & { count: number; omitted: number };
+	playbooks: ContextPayloadSize & { count: number; omitted: number };
 	tasks: ContextPayloadSize;
 	injected: ContextPayloadSize;
 	after: ContextPayloadSize;
@@ -34,9 +40,75 @@ export interface BuildContextInjectionInput {
 	sequence: number;
 	producerId: string;
 	previousFingerprint?: string;
+	maxEstimatedTokens?: number;
 }
 
 const encoder = new TextEncoder();
+const RULE_HEADER = "\n\n## Active rules (Papyrus)\n\n";
+const PLAYBOOK_HEADER = "\n\n## Available playbooks (Papyrus)\n\n";
+const TASK_HEADER = "\n\n## Open tasks (Papyrus)\n\n";
+
+function ruleText(rule: Pick<Artifact, "title" | "body" | "extra">): string {
+	const config = activationConfig(rule.extra, "full");
+	const condition = typeof rule.extra.condition === "string" ? ` (when: ${rule.extra.condition})` : "";
+	if (config.injection === "catalog") return `• ${rule.title}${condition}`;
+	return ruleInjectionPreview(rule);
+}
+
+interface InjectionCandidate {
+	kind: "rule" | "playbook";
+	text: string;
+	priority: number;
+	stableKey: string;
+	index: number;
+}
+
+function selectWithinBudget(
+	input: BuildContextInjectionInput,
+	taskBlock: string,
+): { ruleIndexes: Set<number>; playbookIndexes: Set<number> } {
+	const maxCharacters = (input.maxEstimatedTokens ?? PAPYRUS_CONTEXT_INJECTION_MAX_TOKENS) * CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN;
+	let used = taskBlock.length;
+	let hasRule = false;
+	let hasPlaybook = false;
+	const candidates: InjectionCandidate[] = [
+		...input.rules.map((rule, index) => ({
+			kind: "rule" as const,
+			text: ruleText(rule),
+			priority: activationConfig(rule.extra, "full").priority,
+			stableKey: `${rule.title}\u0000${index}`,
+			index,
+		})),
+		...input.playbooks.map((playbook, index) => ({
+			kind: "playbook" as const,
+			text: playbookInjectionPreview(playbook),
+			priority: activationConfig(playbook.extra, "catalog").priority,
+			stableKey: `${playbook.title}\u0000${index}`,
+			index,
+		})),
+	].filter((candidate) => {
+		const source = candidate.kind === "rule" ? input.rules[candidate.index] : input.playbooks[candidate.index];
+		return activationConfig(source!.extra, candidate.kind === "rule" ? "full" : "catalog").injection !== "on-demand";
+	});
+	candidates.sort((left, right) => right.priority - left.priority || left.stableKey.localeCompare(right.stableKey));
+	const ruleIndexes = new Set<number>();
+	const playbookIndexes = new Set<number>();
+	for (const candidate of candidates) {
+		const firstOfKind = candidate.kind === "rule" ? !hasRule : !hasPlaybook;
+		const overhead = firstOfKind ? (candidate.kind === "rule" ? RULE_HEADER.length + 1 : PLAYBOOK_HEADER.length + 1) : 1;
+		const cost = candidate.text.length + overhead;
+		if (used + cost > maxCharacters) continue;
+		used += cost;
+		if (candidate.kind === "rule") {
+			ruleIndexes.add(candidate.index);
+			hasRule = true;
+		} else {
+			playbookIndexes.add(candidate.index);
+			hasPlaybook = true;
+		}
+	}
+	return { ruleIndexes, playbookIndexes };
+}
 
 function size(value: string): ContextPayloadSize {
 	return { characters: value.length, bytes: encoder.encode(value).byteLength };
@@ -49,11 +121,14 @@ export function buildContextInjection(input: BuildContextInjectionInput): {
 	taskBlock: string;
 	observation: PapyrusContextInjectionObservation;
 } {
-	const ruleContent = input.rules.map(ruleInjectionPreview).join("\n");
-	const ruleBlock = ruleContent ? `\n\n## Active rules (Papyrus)\n\n${ruleContent}\n` : "";
-	const playbookContent = input.playbooks.map(playbookInjectionPreview).join("\n");
-	const playbookBlock = playbookContent ? `\n\n## Available playbooks (Papyrus)\n\n${playbookContent}\n` : "";
-	const taskBlock = input.taskSummary ? `\n\n## Open tasks (Papyrus)\n\n${input.taskSummary}\n` : "";
+	const taskBlock = input.taskSummary ? `${TASK_HEADER}${input.taskSummary}\n` : "";
+	const selected = selectWithinBudget(input, taskBlock);
+	const selectedRules = input.rules.filter((_rule, index) => selected.ruleIndexes.has(index));
+	const selectedPlaybooks = input.playbooks.filter((_playbook, index) => selected.playbookIndexes.has(index));
+	const ruleContent = selectedRules.map(ruleText).join("\n");
+	const ruleBlock = ruleContent ? `${RULE_HEADER}${ruleContent}\n` : "";
+	const playbookContent = selectedPlaybooks.map(playbookInjectionPreview).join("\n");
+	const playbookBlock = playbookContent ? `${PLAYBOOK_HEADER}${playbookContent}\n` : "";
 	const injected = `${ruleBlock}${playbookBlock}${taskBlock}`;
 	const prompt = `${input.basePrompt}${injected}`;
 	const fingerprint = createHash("sha256").update(injected).digest("hex");
@@ -70,8 +145,12 @@ export function buildContextInjection(input: BuildContextInjectionInput): {
 			sequence: input.sequence,
 			producerId: input.producerId,
 			before: size(input.basePrompt),
-			rules: { ...size(ruleBlock), count: input.rules.length },
-			playbooks: { ...size(playbookBlock), count: input.playbooks.length },
+			rules: { ...size(ruleBlock), count: selectedRules.length, omitted: input.rules.length - selectedRules.length },
+			playbooks: {
+				...size(playbookBlock),
+				count: selectedPlaybooks.length,
+				omitted: input.playbooks.length - selectedPlaybooks.length,
+			},
 			tasks: size(taskBlock),
 			injected: injectedSize,
 			after: afterSize,

package/extension/src/index.ts

@@ -34,6 +34,7 @@ import { AutoRotatingWindow, renderCardRow, type WidgetSection } from "malevich-
 import { Type } from "typebox";
 import { formatMetadata } from "./artifact/artifact-format.ts";
 import { BoundedPoll } from "./bounded-poll.ts";
+import { buildActivationContext } from "./context/activation-context.ts";
 import { buildTaskItemTree, computeContextBudget } from "./context/context-budget.ts";
 import { PAPYRUS_CONTEXT_HUB_PRODUCER_NAME, papyrusContextSegment } from "./context/context-hub-contribution.ts";
 import { buildContextInjection } from "./context/context-injection-telemetry.ts";
@@ -917,15 +918,20 @@ export default async function (pi: ExtensionAPI) {
 		let result: { systemPrompt: string } | undefined;
 		try {
 			const sessionId = ctx.sessionManager.getSessionId();
+			const activationContext = buildActivationContext(ctx.cwd, event.prompt, event.systemPromptOptions.selectedTools);
 			const [rules, playbooks, summary, taskGraph] = await Promise.all([
 				callService<Record<string, unknown>, Array<Pick<Artifact, "id" | "title" | "body" | "extra">>>("rules.injectable", {
 					project_root: ctx.cwd,
 					session_id: sessionId,
+					activation_context: activationContext,
 				}),
 				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "extra">>>("playbooks.list", {
 					status: "active",
 					project_root: ctx.cwd,
 					applicable: true,
+					activated: true,
+					activation_context: activationContext,
+					session_id: sessionId,
 					limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS,
 				}),
 				callService<Record<string, unknown>, string | null>("tasks.context", {
@@ -951,13 +957,13 @@ export default async function (pi: ExtensionAPI) {
 			// Context Hub contribution is best-effort observability for /context -- its own failure
 			// must never block this turn's actual rules/tasks injection above.
 			try {
-				const { rules: ruleBudget, skills } = computeContextBudget(rules, ctx.cwd);
+				const { rules: ruleBudget, playbooks: playbookBudget, skills } = computeContextBudget(rules, ctx.cwd, undefined, playbooks);
 				pi.events.emit(CONTEXT_HUB_CONTRIBUTION_CHANNEL, {
 					schema: CONTEXT_HUB_CONTRIBUTION_SCHEMA,
 					observedAt: Date.now(),
 					sequence: ++contextHubContributionSequence,
 					producerName: PAPYRUS_CONTEXT_HUB_PRODUCER_NAME,
-					segment: papyrusContextSegment(ruleBudget, buildTaskItemTree(taskGraph), skills),
+					segment: papyrusContextSegment(ruleBudget, buildTaskItemTree(taskGraph), skills, playbookBudget),
 				});
 			} catch {
 				// Malformed/unreachable daemon data for this turn's contribution -- drop it silently.

package/extension/src/playbook/playbook-bridge.ts

@@ -20,6 +20,7 @@
 
 import type { Artifact } from "@danypops/papyrus";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { buildActivationContext } from "../context/activation-context.ts";
 import { callService } from "../service-client.ts";
 
 export const PLAYBOOK_BRIDGE_MAX_PLAYBOOKS = 100;
@@ -33,8 +34,19 @@ function slugify(title: string): string {
 	return slug.length > 0 ? slug : "playbook";
 }
 
-async function activePlaybooks(): Promise<Artifact[]> {
-	return callService<Record<string, unknown>, Artifact[]>("playbooks.list", { status: "active", limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS });
+async function activePlaybooks(projectRoot?: string, capabilities: readonly string[] = []): Promise<Artifact[]> {
+	return callService<Record<string, unknown>, Artifact[]>("playbooks.list", {
+		status: "active",
+		limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS,
+		...(projectRoot === undefined
+			? {}
+			: {
+					project_root: projectRoot,
+					applicable: true,
+					activated: true,
+					activation_context: buildActivationContext(projectRoot, "", capabilities),
+				}),
+	});
 }
 
 /** Exported for direct testing without a real ExtensionAPI. */
@@ -54,8 +66,11 @@ export function playbookInjectionPreview(playbook: Pick<Artifact, "title" | "ext
 }
 
 /** Exported for direct testing without a real ExtensionAPI: what would be registered right now. */
-export async function planPlaybookCommandRegistrations(): Promise<Array<{ name: string; id: string; title: string; trigger: string }>> {
-	const playbooks = await activePlaybooks();
+export async function planPlaybookCommandRegistrations(
+	projectRoot?: string,
+	capabilities: readonly string[] = [],
+): Promise<Array<{ name: string; id: string; title: string; trigger: string }>> {
+	const playbooks = await activePlaybooks(projectRoot, capabilities);
 	const usedNames = new Set<string>();
 	return playbooks.map((playbook) => {
 		let name = playbookCommandName(playbook.title);
@@ -67,14 +82,21 @@ export async function planPlaybookCommandRegistrations(): Promise<Array<{ name:
 }
 
 export function registerPlaybookBridge(pi: ExtensionAPI): void {
-	const refresh = async () => {
+	const refresh = async (projectRoot?: string) => {
 		try {
-			const registrations = await planPlaybookCommandRegistrations();
+			const registrations = await planPlaybookCommandRegistrations(projectRoot, pi.getActiveTools?.() ?? []);
 			for (const { name, id, title, trigger } of registrations) {
 				pi.registerCommand(name, {
 					description: trigger,
 					handler: async (_args, ctx) => {
 						try {
+							if (ctx.cwd) {
+								const currentlyActive = await activePlaybooks(ctx.cwd, pi.getActiveTools?.() ?? []);
+								if (!currentlyActive.some((playbook) => playbook.id === id)) {
+									ctx.ui.notify(`"${title}" is not enabled for this project context`, "error");
+									return;
+								}
+							}
 							// Re-fetched live, not captured at registration time: a lingering stale
 							// command (renamed or disabled since, since registerCommand can't be
 							// unregistered) must fail cleanly, never run deleted/stale content.
@@ -103,8 +125,8 @@ export function registerPlaybookBridge(pi: ExtensionAPI): void {
 			// "no new/updated playbook commands this cycle", not a broken session start.
 		}
 	};
-	pi.on("resources_discover", async () => {
-		await refresh();
+	pi.on("resources_discover", async (event) => {
+		await refresh(event?.cwd);
 		return {};
 	});
 }

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

@@ -39,7 +39,7 @@ import { emitTaskFocusEvent } from "../task/task-focus-events.ts";
 import { recordRenderDiagnostic, shapeFingerprint } from "./render-diagnostics.ts";
 import { papyrusVehiclePresentations, papyrusVehicleRenderers } from "./vehicle-artifact-renderers.ts";
 
-const REGISTERED_PERMISSIONS = [
+export const PAPYRUS_VEHICLE_PERMISSIONS = [
 	"notes:read",
 	"notes:write",
 	"rules:read",
@@ -54,7 +54,9 @@ const REGISTERED_PERMISSIONS = [
 	"discuss:write",
 	"artifact:read",
 	"artifact:write",
-];
+	"binders:read",
+	"binders:write",
+] as const;
 
 /** Task Focus's own internal write needs a real, per-session secret -- see below. Every other tasks.* operation reads session_id purely for read-scoping and needs no secret. */
 const FOCUS_MUTATION_OPERATIONS = new Set(["tasks.focus", "tasks.pause", "tasks.unpause", "tasks.clear_focus"]);
@@ -148,7 +150,7 @@ export function registerNotesVehicle(pi: ExtensionAPI): Promise<RegisteredPiVehi
 			recordRenderDiagnostic({ event: "vehicle-ready", kind: event.kind, ...("attempt" in event ? { attempt: event.attempt } : {}) });
 			notifyReadyEvent(event);
 		},
-		permissions: REGISTERED_PERMISSIONS,
+		permissions: PAPYRUS_VEHICLE_PERMISSIONS,
 		principal: { id: "pi-papyrus" },
 		renderers: papyrusVehicleRenderers,
 		// papyrusVehiclePresentations projects a bounded, versioned PapyrusToolDetails DTO

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-papyrus",
-  "version": "0.57.4",
+  "version": "0.57.6",
   "description": "Pi host extension for Papyrus: native tools, TUI panels, and context injection over the daemon-backed graph store",
   "type": "module",
   "keywords": ["pi-package"],
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@danypops/jittor": "^0.19.2",
-    "@danypops/papyrus": "^0.60.2",
+    "@danypops/papyrus": "^0.60.5",
     "@danypops/vehicle-client": "^0.10.3",
     "@danypops/vehicle-core": "^0.18.5",
     "@danypops/vehicle-server": "^0.25.2",