@danypops/papyrus 0.27.1 → 0.27.3

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

@@ -62,6 +62,12 @@ export interface AskQuestionParams {
 	allowComment?: boolean;
 	displayMode?: AskDisplayMode;
 	timeout?: number;
+	/**
+	 * Joins a second concurrent call for the same key to the first's in-flight promise instead of
+	 * opening a second picker. Pass a stable id (the target Discussion's id) whenever the caller
+	 * cannot otherwise guarantee only one live ask is ever issued for that same question.
+	 */
+	key?: string;
 	/**
 	 * Streamed once before blocking on the human. A live ask can legitimately sit pending far
 	 * longer than a typical tool call (real human response time, not milliseconds) -- without any
@@ -1073,6 +1079,34 @@ async function askViaDialogs(
 	return createSelectionResponse([selected], comment);
 }
 
+/**
+ * Tracks whether a live ask is genuinely mid-flight, blocked on the human. `ExtensionContext.isIdle()`
+ * means "not streaming a model response" -- it reads true while a slow, human-blocking tool call
+ * like this one is still pending, since the model already finished emitting the tool_call and
+ * is not itself generating anything. Left unguarded, that lets the active-task continuation
+ * driver (extension/src/index.ts's driveActiveTasks, on agent_settled) queue a "continue the
+ * active task" nudge as a `deliverAs: "nextTurn"` message while this exact live ask is still
+ * awaiting an answer -- starting a second, concurrent turn that reasons about the very Discussion
+ * this call is already resolving, independently of it. A live-observed bug (two pickers for the
+ * same question, one orphaned and later auto-resolving with fabricated "defer" text) traced back
+ * to exactly this race. driveActiveTasks checks isLiveAskPending() and skips queuing while true.
+ */
+let livePendingCount = 0;
+
+export function isLiveAskPending(): boolean {
+	return livePendingCount > 0;
+}
+
+/**
+ * Keyed reentrancy join: whatever the exact external cause (an upstream retry, a duplicate turn,
+ * anything outside code this package controls -- verified Pi's own ctx.ui.custom() is a clean,
+ * single-shot, well-guarded call with no retry/timeout logic of its own), a second concurrent
+ * askQuestion() call for the SAME key must never open a second picker for the same question. It
+ * joins the already-in-flight promise instead. Keyed by the target Discussion's id (stable across
+ * a genuine duplicate call, unlike a fresh toolCallId each retry might mint).
+ */
+const pendingByKey = new Map<string, Promise<AskAnswer | undefined>>();
+
 /**
  * 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
@@ -1081,7 +1115,22 @@ async function askViaDialogs(
  */
 export async function askQuestion(ctx: ExtensionContext, params: AskQuestionParams): Promise<AskAnswer | undefined> {
 	if (!ctx.hasUI || !ctx.ui) return undefined;
+	if (params.key !== undefined) {
+		const existing = pendingByKey.get(params.key);
+		if (existing) return existing;
+	}
+	const promise = askQuestionUnguarded(ctx, params);
+	if (params.key !== undefined) {
+		const key = params.key;
+		pendingByKey.set(key, promise);
+		void promise.finally(() => {
+			if (pendingByKey.get(key) === promise) pendingByKey.delete(key);
+		});
+	}
+	return promise;
+}
 
+async function askQuestionUnguarded(ctx: ExtensionContext, params: AskQuestionParams): Promise<AskAnswer | undefined> {
 	const options = params.options ?? [];
 	const allowMultiple = params.allowMultiple ?? false;
 	const allowFreeform = params.allowFreeform ?? true;
@@ -1092,7 +1141,24 @@ export async function askQuestion(ctx: ExtensionContext, params: AskQuestionPara
 	const normalizedContext = params.context?.trim() || undefined;
 
 	params.onUpdate?.({ content: [{ type: "text", text: "Waiting for human input..." }], details: undefined });
+	livePendingCount += 1;
+	try {
+		return await askQuestionBlocking(ctx, params, options, allowMultiple, allowFreeform, allowComment, displayMode, normalizedContext);
+	} finally {
+		livePendingCount -= 1;
+	}
+}
 
+async function askQuestionBlocking(
+	ctx: ExtensionContext,
+	params: AskQuestionParams,
+	options: AskOption[],
+	allowMultiple: boolean,
+	allowFreeform: boolean,
+	allowComment: boolean,
+	displayMode: AskDisplayMode,
+	normalizedContext: string | undefined,
+): Promise<AskAnswer | undefined> {
 	if (options.length === 0) {
 		const prompt = normalizedContext ? `${params.question}\n\nContext:\n${normalizedContext}` : params.question;
 		const answer = await ctx.ui.input(prompt, "Type your answer...", params.timeout ? { timeout: params.timeout } : undefined);

package/extension/src/discuss.ts

@@ -84,8 +84,8 @@ export async function showDiscussions(ctx: ExtensionCommandContext): Promise<voi
 				const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
 				const question = `Reply to "${discussion.title}":`;
 				const answer = pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode
-					? await askQuestion(commandCtx, { question, options: pending.pendingOptions.map((title) => ({ title })), allowMultiple: pending.pendingOptionsMode === "multi" })
-					: await askQuestion(commandCtx, { question });
+					? await askQuestion(commandCtx, { question, options: pending.pendingOptions.map((title) => ({ title })), allowMultiple: pending.pendingOptionsMode === "multi", key: discussion.id })
+					: await askQuestion(commandCtx, { question, key: discussion.id });
 				if (!answer) return; // canceled
 				await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content: answer.content, ...(answer.selected ? { selected: answer.selected } : {}), source: SOURCE });
 				commandCtx.ui.notify(answer.selected ? `Selected: ${answer.selected.join(", ")}` : "Reply added.", "info");

package/extension/src/domain-tools.ts

@@ -49,9 +49,10 @@ async function liveAnswer(ctx: ExtensionContext, discussion: Artifact, onUpdate:
 			options: pending.pendingOptions.map((title) => ({ title })),
 			allowMultiple: pending.pendingOptionsMode === "multi",
 			onUpdate,
+			key: discussion.id,
 		});
 	}
-	return askQuestion(ctx, { question, onUpdate });
+	return askQuestion(ctx, { question, onUpdate, key: discussion.id });
 }
 
 /**

package/extension/src/index.ts

@@ -22,6 +22,7 @@ import type { GateResult } from "../../src/domain/gate.ts";
 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 type { TaskGraph, TaskStatus } from "../../src/task-service.ts";
 import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanInput, type ActiveTaskMarker } from "./active-task-continuation.ts";
@@ -202,6 +203,11 @@ export default async function (pi: ExtensionAPI) {
 
 	const driveActiveTasks = async (ctx: ExtensionContext): Promise<void> => {
 		if (ctx.mode !== "tui" && ctx.mode !== "rpc") return;
+		// ctx.isIdle() means "not streaming a model response" -- it reads true while a live discuss
+		// ask is still genuinely pending, blocked on the human. Queuing a "continue the active task"
+		// nudge here would start a second, concurrent turn reasoning about the very Discussion this
+		// live ask is already resolving. See discuss-ask-view.ts's isLiveAskPending() doc comment.
+		if (isLiveAskPending()) return;
 		try {
 			const sessionId = ctx.sessionManager.getSessionId();
 			const active = await callService<Record<string, unknown>, ActiveTaskMarker | null>("tasks.active", { project_root: ctx.cwd, session_id: sessionId });

package/package.json

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