@danypops/papyrus 0.27.11 → 0.27.13

package/extension/src/discuss.ts

@@ -83,9 +83,13 @@ export async function showDiscussions(ctx: ExtensionCommandContext): Promise<voi
 			if (choice === "Reply") {
 				const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
 				const question = `Reply to "${discussion.title}":`;
+				// Same fix as the live discuss tool: the title alone isn't the actual question -- show
+				// the most recent round's real content as context, not a bare title prompt.
+				const transcript = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.show", { id: discussion.id });
+				const context = transcript.rounds.at(-1)?.content?.trim() || undefined;
 				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, context, options: pending.pendingOptions.map((title) => ({ title })), allowMultiple: pending.pendingOptionsMode === "multi" })
+					: await askQuestion(commandCtx, { question, context });
 				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

@@ -39,20 +39,25 @@ function text(message: string, details: unknown = {}) {
  * is available, never throws -- an unanswered live prompt still leaves the round it already
  * recorded intact.
  */
-async function liveAnswer(ctx: ExtensionContext, discussion: Artifact, onUpdate: AgentToolUpdateCallback | undefined, signal: AbortSignal | undefined): Promise<{ content: string; selected?: string[] } | undefined> {
+async function liveAnswer(ctx: ExtensionContext, discussion: Artifact, latestContent: string | undefined, onUpdate: AgentToolUpdateCallback | undefined, signal: AbortSignal | undefined): Promise<{ content: string; selected?: string[] } | undefined> {
 	if (!ctx.hasUI) return undefined;
 	const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
 	const question = `Reply to "${discussion.title}":`;
+	// The discussion's title alone is often not the actual question -- a human staring at a bare
+	// "Reply to '<title>':" prompt with no visible content has no way to tell what's being asked.
+	// The just-recorded round's own content is the real question text; show it as context.
+	const context = latestContent?.trim() || undefined;
 	if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
 		return askQuestion(ctx, {
 			question,
+			context,
 			options: pending.pendingOptions.map((title) => ({ title })),
 			allowMultiple: pending.pendingOptionsMode === "multi",
 			onUpdate,
 			signal,
 		});
 	}
-	return askQuestion(ctx, { question, onUpdate, signal });
+	return askQuestion(ctx, { question, context, onUpdate, signal });
 }
 
 /**
@@ -722,7 +727,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 						? text(`Opened discussion ${artifactLine(result.discussion)}`, createArtifactDetails("discuss.open", result.discussion))
 						: text(`Round ${result.rounds[0]?.roundNumber} added to "${result.discussion.title}"`, createArtifactDetails("discuss.reply", result.discussion));
 					if (params.live !== true) return fallback;
-					const answer = await liveAnswer(ctx, result.discussion, onUpdate, signal);
+					const answer = await liveAnswer(ctx, result.discussion, result.rounds[0]?.content, onUpdate, signal);
 					if (!answer) return fallback;
 					const answered = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.reply", {
 						id: result.discussion.id, actor: "human", content: answer.content, ...(answer.selected ? { selected: answer.selected } : {}), source: "discuss-live",

package/package.json

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

package/src/ops.ts

@@ -529,14 +529,17 @@ export function runGates(db: Db, artifactId: string, options: GateRunOptions = {
 				}
 			}
 			case "command": {
-				const { execSync } = require_("node:child_process");
-				try {
-					const output = execSync(gate.target, { encoding: "utf-8", timeout: GATE_COMMAND_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"], ...(cwd ? { cwd } : {}) }).trim();
-					const passed = gate.expect ? output.includes(gate.expect) : true;
-					return { gate, passed, output: output.slice(0, GATE_OUTPUT_LIMIT) };
-				} catch (e) {
-					return { gate, passed: false, output: e instanceof Error ? e.message.slice(0, GATE_OUTPUT_LIMIT) : "command failed" };
-				}
+				// spawnSync + manual stdout/stderr concatenation, not execSync: execSync's return value is
+				// stdout only. Many real commands (bun test's own per-test lines and its pass/fail summary
+				// among them) write their actual output to stderr, so an execSync-based match against
+				// gate.expect saw only the first line of a banner and never the result -- every such gate
+				// failed regardless of whether the command actually passed.
+				const { spawnSync } = require_("node:child_process");
+				const result = spawnSync(gate.target, { shell: true, encoding: "utf-8", timeout: GATE_COMMAND_TIMEOUT_MS, ...(cwd ? { cwd } : {}) });
+				if (result.error) return { gate, passed: false, output: result.error.message.slice(0, GATE_OUTPUT_LIMIT) };
+				const combined = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+				const passed = result.status === 0 && (gate.expect ? combined.includes(gate.expect) : true);
+				return { gate, passed, output: combined.slice(0, GATE_OUTPUT_LIMIT) || (result.status === 0 ? "ok" : `command exited with code ${result.status}`) };
 			}
 			case "test": {
 				const { execSync } = require_("node:child_process");
@@ -564,7 +567,7 @@ export function runGates(db: Db, artifactId: string, options: GateRunOptions = {
  *      indefinitely after Papyrus considers the gate "timed out". Spawning detached (its own
  *      process group) and killing the negated pid on our own timer reaches the whole tree.
  */
-function executeGateCommand(command: string, timeout: number, cwd?: string): Promise<{ passed: boolean; output: string }> {
+function executeGateCommand(command: string, timeout: number, cwd?: string): Promise<{ passed: boolean; output: string; matchable: string }> {
 	// `spawn(..., { shell: true, detached: true })` instead of the `exec()` convenience wrapper:
 	// `detached` (needed to make the shell the leader of its own process group, so the negated pid
 	// below reaches every descendant, not just the shell) is not part of Node's `exec()`/
@@ -587,17 +590,21 @@ function executeGateCommand(command: string, timeout: number, cwd?: string): Pro
 		child.stdout?.on("data", append);
 		child.stderr?.on("data", append);
 
-		const finish = (result: { passed: boolean; output: string }): void => {
+		const finish = (result: { passed: boolean; output: string; matchable: string }): void => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timer);
 			resolve(result);
 		};
 
-		child.on("error", (error) => finish({ passed: false, output: error.message.slice(0, GATE_OUTPUT_LIMIT) }));
+		child.on("error", (error) => finish({ passed: false, output: error.message.slice(0, GATE_OUTPUT_LIMIT), matchable: error.message }));
 		child.on("close", (code) => {
-			const output = buffered.trim().slice(0, GATE_OUTPUT_LIMIT);
-			finish({ passed: code === 0, output: output || (code === 0 ? "ok" : `command exited with code ${code}`) });
+			// `matchable` carries the full (GATE_MAX_BUFFER_BYTES-bounded) buffer so the caller's
+			// gate.expect substring check sees the whole run, not just the first GATE_OUTPUT_LIMIT
+			// characters -- a real bun test run's pass/fail summary is its last line, not its first.
+			const full = buffered.trim();
+			const output = full.slice(0, GATE_OUTPUT_LIMIT);
+			finish({ passed: code === 0, output: output || (code === 0 ? "ok" : `command exited with code ${code}`), matchable: full });
 		});
 
 		const timer = setTimeout(() => {
@@ -609,7 +616,7 @@ function executeGateCommand(command: string, timeout: number, cwd?: string): Pro
 					child.kill("SIGKILL");
 				}
 			}
-			finish({ passed: false, output: `gate command timed out after ${timeout}ms` });
+			finish({ passed: false, output: `gate command timed out after ${timeout}ms`, matchable: "" });
 		}, timeout);
 	});
 }
@@ -651,7 +658,7 @@ export async function runGatesAsync(db: Db, artifactId: string, options: GateRun
 			const executed = await executeGateCommand(command, timeout, options.cwd);
 			results.push({
 				gate,
-				passed: executed.passed && (gate.expect ? executed.output.includes(gate.expect) : true),
+				passed: executed.passed && (gate.expect ? executed.matchable.includes(gate.expect) : true),
 				output: executed.output,
 			});
 		} else {