@danypops/papyrus 0.29.0 → 0.29.2

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

@@ -5,6 +5,7 @@ import {
 } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import { ruleInjectionPreview } from "./rules.ts";
+import { playbookInjectionPreview } from "./playbook-bridge.ts";
 
 export interface ContextPayloadSize {
 	characters: number;
@@ -18,6 +19,7 @@ export interface PapyrusContextInjectionObservation {
 	producerId: string;
 	before: ContextPayloadSize;
 	rules: ContextPayloadSize & { count: number };
+	playbooks: ContextPayloadSize & { count: number };
 	tasks: ContextPayloadSize;
 	injected: ContextPayloadSize;
 	after: ContextPayloadSize;
@@ -30,6 +32,7 @@ export interface PapyrusContextInjectionObservation {
 export interface BuildContextInjectionInput {
 	basePrompt: string;
 	rules: Array<Pick<Artifact, "title" | "body" | "extra">>;
+	playbooks: Array<Pick<Artifact, "title" | "extra">>;
 	taskSummary: string | null;
 	observedAt: number;
 	sequence: number;
@@ -46,13 +49,16 @@ function size(value: string): ContextPayloadSize {
 export function buildContextInjection(input: BuildContextInjectionInput): {
 	prompt: string;
 	ruleBlock: string;
+	playbookBlock: string;
 	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 injected = `${ruleBlock}${taskBlock}`;
+	const injected = `${ruleBlock}${playbookBlock}${taskBlock}`;
 	const prompt = `${input.basePrompt}${injected}`;
 	const fingerprint = createHash("sha256").update(injected).digest("hex");
 	const injectedSize = size(injected);
@@ -60,6 +66,7 @@ export function buildContextInjection(input: BuildContextInjectionInput): {
 	return {
 		prompt,
 		ruleBlock,
+		playbookBlock,
 		taskBlock,
 		observation: {
 			schema: PAPYRUS_CONTEXT_INJECTION_SCHEMA,
@@ -68,6 +75,7 @@ export function buildContextInjection(input: BuildContextInjectionInput): {
 			producerId: input.producerId,
 			before: size(input.basePrompt),
 			rules: { ...size(ruleBlock), count: input.rules.length },
+			playbooks: { ...size(playbookBlock), count: input.playbooks.length },
 			tasks: size(taskBlock),
 			injected: injectedSize,
 			after: afterSize,

package/extension/src/discuss-ask-view.ts

@@ -1126,6 +1126,53 @@ export function isLiveAskPending(): boolean {
 	return livePendingCount > 0;
 }
 
+const DISCUSS_TYPING_COURTESY_POLL_MS = 400;
+const DISCUSS_TYPING_COURTESY_DEFAULT_MAX_WAIT_MS = 15_000;
+
+function resolveTypingCourtesyMaxWaitMs(): number {
+	const raw = process.env["PAPYRUS_DISCUSS_TYPING_COURTESY_MS"];
+	if (raw === undefined) return DISCUSS_TYPING_COURTESY_DEFAULT_MAX_WAIT_MS;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : DISCUSS_TYPING_COURTESY_DEFAULT_MAX_WAIT_MS;
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve) => {
+		if (signal?.aborted) { resolve(); return; }
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+	});
+}
+
+/**
+ * Whether there is a genuine editor draft to wait out right now -- a plain synchronous check so
+ * the common case (no draft) never forces the caller through an extra microtask. Deliberately not
+ * folded into waitForEditorCourtesy itself: an unconditional `await` there -- even one that
+ * resolves immediately -- still yields once, which is enough to let a signal aborted synchronously
+ * right after invoking askQuestion race past the abort listener registered deeper in
+ * askQuestionBlocking and get missed entirely.
+ */
+export function hasEditorCourtesyDraft(ctx: ExtensionContext): boolean {
+	return typeof ctx.ui.getEditorText === "function" && ctx.ui.getEditorText().length > 0;
+}
+
+/**
+ * Waits for a non-empty editor draft to clear before popping the live ask over it. Bounded
+ * (PAPYRUS_DISCUSS_TYPING_COURTESY_MS, default 15s, 0 disables): a draft left sitting unattended
+ * must not withhold the question indefinitely, only a genuinely in-progress reply gets the
+ * courtesy. Only call when hasEditorCourtesyDraft(ctx) is already true.
+ */
+export async function waitForEditorCourtesy(ctx: ExtensionContext, params: Pick<AskQuestionParams, "onUpdate" | "signal">): Promise<void> {
+	const maxWaitMs = resolveTypingCourtesyMaxWaitMs();
+	if (maxWaitMs <= 0) return;
+	const deadline = Date.now() + maxWaitMs;
+	params.onUpdate?.({ content: [{ type: "text", text: "Waiting for you to finish typing before asking..." }], details: undefined });
+	while (Date.now() < deadline && !params.signal?.aborted) {
+		await sleep(DISCUSS_TYPING_COURTESY_POLL_MS, params.signal);
+		if (typeof ctx.ui.getEditorText !== "function" || ctx.ui.getEditorText().length === 0) return;
+	}
+}
+
 /**
  * Discuss's live:true synchronous ask -- interactive AskComponent when a real TUI is available,
  * dialog fallback (ctx.ui.select/input) in RPC/headless mode, no-op undefined without any
@@ -1147,9 +1194,12 @@ async function askQuestionUnguarded(ctx: ExtensionContext, params: AskQuestionPa
 	const displayMode: AskDisplayMode = params.displayMode ?? envDisplayMode ?? "overlay";
 	const normalizedContext = params.context?.trim() || undefined;
 
-	params.onUpdate?.({ content: [{ type: "text", text: "Waiting for human input..." }], details: undefined });
 	livePendingCount += 1;
 	try {
+		// Only actually awaits (yielding a microtask) when there's a real draft to wait out --
+		// see hasEditorCourtesyDraft's own comment for why the common case must stay synchronous.
+		if (hasEditorCourtesyDraft(ctx)) await waitForEditorCourtesy(ctx, params);
+		params.onUpdate?.({ content: [{ type: "text", text: "Waiting for human input..." }], details: undefined });
 		return await askQuestionBlocking(ctx, params, options, allowMultiple, allowFreeform, allowComment, displayMode, normalizedContext);
 	} finally {
 		livePendingCount -= 1;

package/extension/src/index.ts

@@ -23,7 +23,7 @@ import { formatMetadata } from "./artifact-format.ts";
 import { callService } from "./service-client.ts";
 import { registerDomainTools } from "./domain-tools.ts";
 import { isLiveAskPending } from "./discuss-ask-view.ts";
-import { registerPlaybookBridge } from "./playbook-bridge.ts";
+import { PLAYBOOK_BRIDGE_MAX_PLAYBOOKS, registerPlaybookBridge } from "./playbook-bridge.ts";
 import type { TaskGraph, TaskStatus } from "../../src/task-service.ts";
 import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanInput, type ActiveTaskMarker } from "./active-task-continuation.ts";
 import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
@@ -626,13 +626,15 @@ export default async function (pi: ExtensionAPI) {
 	pi.on("before_agent_start", async (event, ctx) => {
 		try {
 			const sessionId = ctx.sessionManager.getSessionId();
-			const [rules, summary] = await Promise.all([
+			const [rules, playbooks, summary] = await Promise.all([
 				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd, session_id: sessionId }),
+				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "extra">>>("playbooks.list", { status: "active", limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS }),
 				callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd, session_id: sessionId }),
 			]);
 			const injection = buildContextInjection({
 				basePrompt: event.systemPrompt ?? "",
 				rules,
+				playbooks,
 				taskSummary: summary,
 				observedAt: Date.now(),
 				sequence: ++contextInjectionSequence,

package/extension/src/playbook-bridge.ts

@@ -21,7 +21,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import { callService } from "./service-client.ts";
 
-const PLAYBOOK_BRIDGE_MAX_PLAYBOOKS = 100;
+export const PLAYBOOK_BRIDGE_MAX_PLAYBOOKS = 100;
 
 function slugify(title: string): string {
 	const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
@@ -37,6 +37,17 @@ export function playbookCommandName(title: string): string {
 	return `playbook:${slugify(title)}`;
 }
 
+/**
+ * One line per active Playbook for context injection -- the passive, every-turn surfacing that
+ * gives the model the same "this exists and might match my task" awareness Pi's own Skill catalog
+ * gives real Skills, without a file-based bridge. See buildContextInjection (rules and open tasks
+ * already work this way).
+ */
+export function playbookInjectionPreview(playbook: Pick<Artifact, "title" | "extra">): string {
+	const trigger = typeof playbook.extra["trigger"] === "string" ? playbook.extra["trigger"] : "manual invocation";
+	return `• ${playbook.title} (when: ${trigger})`;
+}
+
 /** 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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],