@danypops/papyrus 0.25.0 → 0.27.0

package/extension/src/active-task-continuation.ts

@@ -43,7 +43,7 @@ function continuationPrompt(task: ActiveTaskMarker): string {
 		"Reconcile its lifecycle, take the next concrete action, use tools, submit it for review when implementation effort is ready, and run gates plus checklist review before completion.",
 		"Do not shrink the task's scope to whatever fits in this turn, and do not treat a status update or summary as a substitute for doing the work or as proof of completion.",
 		"If something blocks progress, do not reject or pause on the first obstacle -- only after it genuinely recurs, and only when the task truly cannot proceed without external input.",
-		`Active task: ${task.id}: ${task.title.slice(0, TITLE_LIMIT)}`,
+		`Active task: ${task.title.slice(0, TITLE_LIMIT)}`,
 	].join("\n");
 }
 

package/extension/src/artifact-browser.ts

@@ -78,7 +78,7 @@ export async function showArtifactDetails(
 			depth: DETAIL_GRAPH_DEPTH,
 			max_nodes: DETAIL_GRAPH_NODES,
 		});
-		if (!artifact) { ctx.ui.notify(`Artifact ${id} not found`, "error"); return; }
+		if (!artifact) { ctx.ui.notify("Artifact not found", "error"); return; }
 		await showArtifactDetailView(ctx, artifact);
 	} catch (error) {
 		ctx.ui.notify(`Show details failed: ${error instanceof Error ? error.message : error}`, "error");
@@ -92,7 +92,7 @@ export async function linkFromArtifact(ctx: ExtensionCommandContext, fromId: str
 	if (!relation) return;
 	try {
 		await callService("graph.link", { from: fromId, relation, to: target });
-		ctx.ui.notify(`Linked ${fromId} --${relation}--> ${target}`, "info");
+		ctx.ui.notify(`Artifacts linked via ${relation}`, "info");
 	} catch (error) {
 		ctx.ui.notify(`Link failed: ${error instanceof Error ? error.message : error}`, "error");
 	}
@@ -101,8 +101,8 @@ export async function linkFromArtifact(ctx: ExtensionCommandContext, fromId: str
 export async function setArtifactStatus(ctx: ExtensionCommandContext, id: string, status: string): Promise<void> {
 	try {
 		const artifact = await callService<Record<string, unknown>, Artifact | null>("graph.status", { id, status });
-		if (!artifact) { ctx.ui.notify(`Artifact ${id} not found`, "error"); return; }
-		ctx.ui.notify(`${artifact.id} → [${artifact.status}]`, "info");
+		if (!artifact) { ctx.ui.notify("Artifact not found", "error"); return; }
+		ctx.ui.notify(`${artifact.title} → [${artifact.status}]`, "info");
 	} catch (error) {
 		ctx.ui.notify(`Status change failed: ${error instanceof Error ? error.message : error}`, "error");
 	}

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

@@ -0,0 +1,193 @@
+/**
+ * discuss-ask-layout.ts — row layout for the searchable single-select list used by Discuss's
+ * live:true ask UI (discuss-ask-view.ts). Wraps long option titles/descriptions to a target
+ * width and returns flat annotated rows, windowed around the current selection when the full
+ * list would overflow the available rows.
+ *
+ * Adapted from pi-ask-user's single-select-layout.ts (MIT, Copyright (c) 2026 Enzo Lucchesi --
+ * see THIRD_PARTY_LICENSES.md) so Discuss owns this UI directly instead of depending on that
+ * package at runtime.
+ */
+
+export interface AskOption {
+	title: string;
+	description?: string;
+}
+
+export interface AnnotatedRow {
+	line: string;
+	selected: boolean;
+}
+
+export interface RenderSingleSelectRowsParams {
+	options: AskOption[];
+	selectedIndex: number;
+	width: number;
+	allowFreeform: boolean;
+	allowComment?: boolean;
+	commentEnabled?: boolean;
+	maxRows?: number;
+	hideDescriptions?: boolean;
+}
+
+function wrapText(text: string, width: number): string[] {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	if (!normalized) return [""];
+	if (width <= 1) return normalized.split("");
+
+	const words = normalized.split(" ");
+	const lines: string[] = [];
+	let current = "";
+
+	for (const word of words) {
+		if (!current) {
+			if (word.length <= width) {
+				current = word;
+			} else {
+				for (let i = 0; i < word.length; i += width) {
+					lines.push(word.slice(i, i + width));
+				}
+			}
+			continue;
+		}
+
+		const candidate = `${current} ${word}`;
+		if (candidate.length <= width) {
+			current = candidate;
+			continue;
+		}
+
+		lines.push(current);
+		if (word.length <= width) {
+			current = word;
+		} else {
+			current = "";
+			for (let i = 0; i < word.length; i += width) {
+				const chunk = word.slice(i, i + width);
+				if (chunk.length === width || i + width < word.length) lines.push(chunk);
+				else current = chunk;
+			}
+		}
+	}
+
+	if (current) lines.push(current);
+	return lines;
+}
+
+function padLine(prefix: string, content: string): string {
+	return `${prefix}${content}`.trimEnd();
+}
+
+interface ItemBlock {
+	itemIndex: number;
+	lines: string[];
+}
+
+type ListItem =
+	| { type: "option"; option: AskOption }
+	| { type: "comment-toggle"; option: AskOption }
+	| { type: "freeform"; option: AskOption };
+
+function buildItemBlocks(
+	options: AskOption[],
+	width: number,
+	allowFreeform: boolean,
+	allowComment: boolean,
+	commentEnabled: boolean,
+	selectedIndex: number,
+	hideDescriptions = false,
+): ItemBlock[] {
+	const normalizedWidth = Math.max(12, width);
+	const freeformLabel = "Type something. — Enter a custom response";
+	const commentToggleLabel = `${commentEnabled ? "[✓]" : "[ ]"} Add extra context after selection`;
+	const allItems: ListItem[] = options.map((option) => ({ type: "option", option }));
+	if (allowComment) allItems.push({ type: "comment-toggle", option: { title: commentToggleLabel } });
+	if (allowFreeform) allItems.push({ type: "freeform", option: { title: freeformLabel } });
+
+	return allItems.map((item, itemIndex) => {
+		const pointer = itemIndex === selectedIndex ? "→" : " ";
+		const lines: string[] = [];
+
+		if (item.type === "comment-toggle" || item.type === "freeform") {
+			const prefix = `${pointer}   `;
+			const wrapped = wrapText(item.option.title, Math.max(8, normalizedWidth - prefix.length));
+			wrapped.forEach((line, lineIndex) => {
+				lines.push(padLine(lineIndex === 0 ? prefix : " ".repeat(prefix.length), line));
+			});
+			return { itemIndex, lines };
+		}
+
+		const numberPrefix = `${pointer} ${itemIndex + 1}. `;
+		const continuationPrefix = " ".repeat(numberPrefix.length);
+		const titleLines = wrapText(item.option.title, Math.max(8, normalizedWidth - numberPrefix.length));
+		titleLines.forEach((line, lineIndex) => {
+			lines.push(padLine(lineIndex === 0 ? numberPrefix : continuationPrefix, line));
+		});
+
+		if (item.option.description && !hideDescriptions) {
+			const descriptionPrefix = "      ";
+			const descriptionLines = wrapText(item.option.description, Math.max(8, normalizedWidth - descriptionPrefix.length));
+			descriptionLines.forEach((line) => lines.push(padLine(descriptionPrefix, line)));
+		}
+
+		return { itemIndex, lines };
+	});
+}
+
+function flatten(blocks: ItemBlock[], selectedIndex: number): AnnotatedRow[] {
+	return blocks.flatMap((block) => block.lines.map((line) => ({ line, selected: block.itemIndex === selectedIndex })));
+}
+
+export function renderSingleSelectRows({
+	options,
+	selectedIndex,
+	width,
+	allowFreeform,
+	allowComment = false,
+	commentEnabled = false,
+	maxRows,
+	hideDescriptions,
+}: RenderSingleSelectRowsParams): AnnotatedRow[] {
+	const itemCount = options.length + (allowComment ? 1 : 0) + (allowFreeform ? 1 : 0);
+	const blocks = buildItemBlocks(options, width, allowFreeform, allowComment, commentEnabled, selectedIndex, hideDescriptions);
+	const allRows = flatten(blocks, selectedIndex);
+
+	if (!Number.isFinite(maxRows) || !maxRows || maxRows <= 0 || allRows.length <= maxRows) return allRows;
+
+	const safeMaxRows = Math.max(1, Math.floor(maxRows));
+	const selectedBlock = blocks[selectedIndex] ?? blocks[0];
+	if (!selectedBlock) return [];
+
+	const indicator = `  (${selectedIndex + 1}/${itemCount})`;
+	const availableRows = safeMaxRows > 1 ? safeMaxRows - 1 : 1;
+
+	if (selectedBlock.lines.length >= availableRows) {
+		const visible = selectedBlock.lines.slice(0, availableRows).map((line) => ({ line, selected: true }));
+		if (safeMaxRows > 1) visible.push({ line: indicator, selected: false });
+		return visible.slice(0, safeMaxRows);
+	}
+
+	let start = selectedIndex;
+	let end = selectedIndex + 1;
+	let usedRows = selectedBlock.lines.length;
+
+	while (true) {
+		const nextCanFit = end < blocks.length && usedRows + blocks[end]!.lines.length <= availableRows;
+		if (nextCanFit) {
+			usedRows += blocks[end]!.lines.length;
+			end += 1;
+			continue;
+		}
+		const prevCanFit = start > 0 && usedRows + blocks[start - 1]!.lines.length <= availableRows;
+		if (prevCanFit) {
+			start -= 1;
+			usedRows += blocks[start]!.lines.length;
+			continue;
+		}
+		break;
+	}
+
+	const visible = flatten(blocks.slice(start, end), selectedIndex);
+	visible.push({ line: indicator, selected: false });
+	return visible.slice(0, safeMaxRows);
+}