@danypops/papyrus 0.24.0 → 0.26.0

package/README.md

@@ -122,7 +122,7 @@ Agent-facing domain tools own lifecycle invariants and sit above this store API:
 - **`docs`** — create/update/list/show, activate/archive/reopen, and document-safe graph links; Note mutations remain behind the Notes facade
 - **`rules`** — create/update/list/show/preview, enable/disable, and attach governance gates to tasks
 - **`skills`** — create/update/list/show/invoke/run, enable/disable, create compatibility templates, and atomically instantiate parameterized workflow runs
-- **`playbooks`** — a completely different beast from Skills, not a subtype: a trigger and an ordered list of steps an agent reads and follows, never mechanically instantiated and never composed the way Skills call other Skills. create/update/list/show/invoke, enable/disable
+- **`playbooks`** — a completely different beast from Skills, not a subtype: a trigger and an ordered list of steps an agent reads and follows, never mechanically instantiated and never composed the way Skills call other Skills. create/update/list/show/invoke, enable/disable. A Playbook can declare named arguments (`{name, description?, required?}`, required defaults true); invoking with some unsupplied lists exactly which required ones are still missing and directs the agent to ask via `discuss` with `live:true` rather than guess
 
 Every tool operation is registered in the daemon’s `/api/v1/ops` registry; parity is verified in tests. The task consumer uses the `tasks.graph` operation, which returns task nodes with explicit parent, child, and dependency IDs rather than leaking SQLite rows or asking the UI to reconstruct relationships.
 
@@ -175,7 +175,7 @@ Blocking is real: `tasks.complete` is refused while any `active` Discussion has
 
 `open`/`reply` can also pose a structured choice instead of (or alongside) free text: `options` (2-10 entries) plus `options_mode` -- `single` is mutually exclusive (exactly one pick), `multi` allows several. The Discussion remembers the pending choice (`extra.discussion.pendingOptions`/`pendingOptionsMode`) until a `reply` answers it with `selected`, validated against exactly what was offered and the mode's cardinality; a reply can also pose the *next* round's choice in the same call.
 
-Run `/discuss` for the interactive panel: browse every Discussion (the real `active`/`deferred`/`settled` state shown per row, alongside any choice awaiting an answer), open a scrollable transcript showing what was posed and picked in each round, and reply/defer/resume/settle or block/unblock a task without leaving the TUI. Replying to a pending choice shows a real picker -- the native single-select list for `single`, or a checkbox multi-select (space to toggle, enter to confirm) for `multi`, since no built-in multi-select exists in the Pi extension UI. Opening a *new* Discussion is left to the agent (same as Docs/Rules/Skills) -- `/discuss` browses and drives existing ones.
+Run `/discuss` for the interactive panel: browse every Discussion (the real `active`/`deferred`/`settled` state shown per row, alongside any choice awaiting an answer), open a scrollable transcript showing what was posed and picked in each round, and reply/defer/resume/settle or block/unblock a task without leaving the TUI. Replying to a pending choice shows a real picker -- the native single-select list for `single`, or a checkbox multi-select for `multi`, since no built-in multi-select exists in the Pi extension UI. Both modes append a numbered "type your own answer" row -- a genuinely open answer is exactly as valid as any posed option. The multi-select picker supports a number key as a direct quick-select (jump straight to that row instead of scrolling), and steadily highlights checked rows while dimming the rest so the eye reads "what's chosen" independent of cursor position; its cursor row blinks to mark focus. It also auto-cancels after 30s of zero input -- the very first keystroke of any kind stops that countdown permanently for that prompt. Opening a *new* Discussion is left to the agent (same as Docs/Rules/Skills) -- `/discuss` browses and drives existing ones.
 
 ```bash
 papyrus discuss open --title "Naming" --actor alice --content "Should we rename this?" --blocks-json '["task-id"]' --json

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.ts

@@ -83,8 +83,14 @@ export async function showDiscussions(ctx: ExtensionCommandContext): Promise<voi
 			if (choice === "Reply") {
 				const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
 				if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
-					const selected = await pickDiscussionOptions(commandCtx, pending.pendingOptionsMode, pending.pendingOptions);
-					if (!selected) return; // canceled
+					const result = await pickDiscussionOptions(commandCtx, pending.pendingOptionsMode, pending.pendingOptions);
+					if (!result) return; // canceled
+					if (result.kind === "freeform") {
+						await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content: result.text, source: SOURCE });
+						commandCtx.ui.notify("Reply added.", "info");
+						return;
+					}
+					const { selected } = result;
 					const elaboration = await commandCtx.ui.input("Elaborate (optional):", selected.join(", "));
 					if (elaboration === undefined) return; // canceled
 					await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content: elaboration || selected.join(", "), selected, source: SOURCE });

package/extension/src/discussion-picker.ts

@@ -1,47 +1,118 @@
 /**
- * discussion-picker.ts — the structured-choice picker for /discuss's "Reply" action.
+ * discussion-picker.ts — the structured-choice picker for /discuss's "Reply" action and the
+ * discuss tool's own live:true synchronous ask.
  *
- * "single" mode (mutually exclusive) needs nothing bespoke: the Pi extension UI already
- * provides exactly that (ctx.ui.select). "multi" (allow several) has no native equivalent
- * anywhere in @earendil-works/pi-coding-agent or pi-tui (checked both) -- so this is a small,
- * genuinely domain-specific checkbox-list component, not a generic library replacement.
+ * "single" mode (mutually exclusive) needs nothing bespoke for the pick list itself: the Pi
+ * extension UI already provides exactly that (ctx.ui.select). "multi" (allow several) has no
+ * native equivalent anywhere in @earendil-works/pi-coding-agent or pi-tui (checked both) -- so
+ * that one is a small, genuinely domain-specific checkbox-list component, not a generic library
+ * replacement. Both modes get a numbered quick-select (press the row's digit instead of
+ * scrolling with arrows) and an appended "type your own answer" row, itself numbered the same
+ * way -- a genuinely open question is exactly as valid an answer as any of the posed options.
  */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { DISCUSSION_PICKER_IDLE_TIMEOUT_MS, DISCUSSION_PICKER_TICK_MS } from "../../src/constants.ts";
 import type { DiscussionOptionsMode } from "../../src/domain/discussion.ts";
 
-/** Toggle with space, confirm with enter (refuses an empty confirm -- at least one pick is required), cancel with escape. */
-async function pickMultiple(ctx: ExtensionContext, title: string, options: string[]): Promise<string[] | undefined> {
-	return ctx.ui.custom<string[] | undefined>((tui, theme, _keybindings, done) => {
+const FREEFORM_LABEL = "Something else (type your own answer)";
+
+export type DiscussionPickResult = { kind: "selected"; selected: string[] } | { kind: "freeform"; text: string };
+
+/** digit "1".."9" -> index 0-8, "0" -> index 9 (DISCUSSION_OPTIONS_MAX_COUNT is 10) -- standard terminal-menu numbering, not 0-indexed. */
+function digitToIndex(data: string, rowCount: number): number | undefined {
+	if (data === "0") return rowCount >= 10 ? 9 : undefined;
+	if (data.length === 1 && data >= "1" && data <= "9") {
+		const index = Number(data) - 1;
+		return index < rowCount ? index : undefined;
+	}
+	return undefined;
+}
+
+function rowNumberLabel(index: number): string {
+	if (index < 9) return `${index + 1}`;
+	if (index === 9) return "0";
+	return " "; // beyond the 1-9,0 quick-select range (should not happen given DISCUSSION_OPTIONS_MAX_COUNT=10, but never crash rendering)
+}
+
+async function promptFreeformAnswer(ctx: ExtensionContext): Promise<DiscussionPickResult | undefined> {
+	const text = await ctx.ui.input("Your answer:", "");
+	return text ? { kind: "freeform", text } : undefined;
+}
+
+/**
+ * Toggle with space or a row's number, confirm with enter (refuses an empty confirm -- at least
+ * one pick is required), cancel with escape. Picking the freeform row exits the checkbox flow
+ * entirely rather than adding it to the selection.
+ *
+ * Idle countdown: auto-cancels after DISCUSSION_PICKER_IDLE_TIMEOUT_MS of no input at all --
+ * the first keystroke of any kind stops it permanently (not a pause; it never resumes for this
+ * picker instance), since a countdown ticking while someone is actively engaging is pressure,
+ * not a nudge. The same tick also drives a slow, deliberately noticeable blink on the cursor
+ * row -- checked rows stay steadily highlighted, everything else stays dimmed, so the eye reads
+ * "what's chosen" at a glance independent of where the cursor happens to be.
+ */
+async function pickMultiple(ctx: ExtensionContext, title: string, options: string[], allowFreeform: boolean, idleTimeoutMs: number, tickMs: number): Promise<DiscussionPickResult | undefined> {
+	return ctx.ui.custom<DiscussionPickResult | undefined>((tui, theme, _keybindings, done) => {
+		const rows = allowFreeform ? [...options, FREEFORM_LABEL] : options;
+		const freeformIndex = allowFreeform ? rows.length - 1 : -1;
 		const checked = new Set<number>();
 		let selectedIndex = 0;
+		let hasInteracted = false;
+		let remainingMs = idleTimeoutMs;
+		let blinkOn = true;
+		const tick = setInterval(() => {
+			blinkOn = !blinkOn;
+			if (!hasInteracted) {
+				remainingMs -= tickMs;
+				if (remainingMs <= 0) { finish(undefined); return; }
+			}
+			tui.requestRender();
+		}, tickMs);
+		const finish = (value: DiscussionPickResult | undefined) => { clearInterval(tick); done(value); };
+		const chooseFreeform = () => { promptFreeformAnswer(ctx).then(finish); };
+		const toggle = (index: number) => {
+			if (index === freeformIndex) { chooseFreeform(); return; }
+			if (checked.has(index)) checked.delete(index); else checked.add(index);
+			tui.requestRender();
+		};
 		return {
 			invalidate() {},
 			render(width: number): string[] {
 				const lines: string[] = [
 					theme.bold(title),
-					theme.fg("muted", "space toggle \u00b7 enter confirm \u00b7 esc cancel"),
+					theme.fg("muted", "number/space toggle \u00b7 enter confirm \u00b7 esc cancel"),
 					"",
 				];
-				options.forEach((option, index) => {
-					const cursor = index === selectedIndex ? theme.fg("accent", "\u276f") : " ";
-					const box = checked.has(index) ? theme.fg("success", "[x]") : "[ ]";
-					const label = index === selectedIndex ? theme.bold(option) : option;
-					lines.push(truncateToWidth(`${cursor} ${box} ${label}`, width, ""));
+				rows.forEach((option, index) => {
+					const isCursor = index === selectedIndex;
+					const isChecked = checked.has(index);
+					const cursorGlyph = isCursor && blinkOn ? theme.fg("accent", "\u276f") : " ";
+					const box = index === freeformIndex ? "  " : isChecked ? theme.fg("success", "[x]") : "[ ]";
+					let label = option;
+					if (isChecked) label = theme.bold(theme.fg("success", label));
+					else if (isCursor) label = theme.bold(theme.fg("accent", label));
+					else label = theme.fg("dim", label);
+					lines.push(truncateToWidth(`${cursorGlyph} ${rowNumberLabel(index)}. ${box} ${label}`, width, ""));
 				});
 				lines.push("");
 				lines.push(theme.fg("dim", `${checked.size} selected`));
+				if (!hasInteracted) lines.push(theme.fg("dim", `auto-cancels in ${Math.max(0, Math.ceil(remainingMs / 1000))}s (press any key to stop)`));
 				return lines;
 			},
 			handleInput(data: string) {
-				if (matchesKey(data, "up")) selectedIndex = (selectedIndex - 1 + options.length) % options.length;
-				else if (matchesKey(data, "down")) selectedIndex = (selectedIndex + 1) % options.length;
-				else if (data === " ") { if (checked.has(selectedIndex)) checked.delete(selectedIndex); else checked.add(selectedIndex); }
+				hasInteracted = true;
+				const digit = digitToIndex(data, rows.length);
+				if (digit !== undefined) { selectedIndex = digit; toggle(digit); return; }
+				if (matchesKey(data, "up")) selectedIndex = (selectedIndex - 1 + rows.length) % rows.length;
+				else if (matchesKey(data, "down")) selectedIndex = (selectedIndex + 1) % rows.length;
+				else if (data === " ") { toggle(selectedIndex); return; }
 				else if (matchesKey(data, "enter")) {
+					if (selectedIndex === freeformIndex && checked.size === 0) { chooseFreeform(); return; }
 					if (checked.size === 0) return; // refuse an empty confirm -- selecting nothing isn't a valid answer
-					done([...checked].sort((a, b) => a - b).map((index) => options[index]!));
+					finish({ kind: "selected", selected: [...checked].sort((a, b) => a - b).map((index) => rows[index]!) });
 					return;
-				} else if (matchesKey(data, "escape")) { done(undefined); return; }
+				} else if (matchesKey(data, "escape")) { finish(undefined); return; }
 				else return;
 				tui.requestRender();
 			},
@@ -50,15 +121,28 @@ async function pickMultiple(ctx: ExtensionContext, title: string, options: strin
 }
 
 /**
- * Picks one (single) or several (multi) of the given options, or undefined if the user cancels.
- * Takes the base ExtensionContext (just .ui) rather than the wider ExtensionCommandContext, since
- * a tool's execute() only ever receives the former -- the discuss tool's own live mode reuses
- * this same picker, not just the /discuss TUI panel.
+ * Picks one (single) or several (multi) of the given options, or a freeform typed answer
+ * instead, or undefined if the user cancels. Takes the base ExtensionContext (just .ui) rather
+ * than the wider ExtensionCommandContext, since a tool's execute() only ever receives the
+ * former -- the discuss tool's own live mode reuses this same picker, not just the /discuss
+ * TUI panel. Single mode's numbered quick-select is not guaranteed: it delegates to Pi's own
+ * native ctx.ui.select, which this package does not control the key handling of.
  */
-export async function pickDiscussionOptions(ctx: ExtensionContext, mode: DiscussionOptionsMode, options: string[]): Promise<string[] | undefined> {
+export async function pickDiscussionOptions(
+	ctx: ExtensionContext,
+	mode: DiscussionOptionsMode,
+	options: string[],
+	allowFreeform = true,
+	/** Test seam: real timers, not faked global time -- pass tiny values to exercise the idle-cancel/blink logic quickly and deterministically. */
+	idleTimeoutMs = DISCUSSION_PICKER_IDLE_TIMEOUT_MS,
+	tickMs = DISCUSSION_PICKER_TICK_MS,
+): Promise<DiscussionPickResult | undefined> {
 	if (mode === "single") {
-		const pick = await ctx.ui.select("Pick one:", options);
-		return pick ? [pick] : undefined;
+		const rows = allowFreeform ? [...options, FREEFORM_LABEL] : options;
+		const pick = await ctx.ui.select("Pick one:", rows);
+		if (!pick) return undefined;
+		if (allowFreeform && pick === FREEFORM_LABEL) return promptFreeformAnswer(ctx);
+		return { kind: "selected", selected: [pick] };
 	}
-	return pickMultiple(ctx, "Pick one or more:", options);
+	return pickMultiple(ctx, "Pick one or more:", options, allowFreeform, idleTimeoutMs, tickMs);
 }

package/extension/src/docs.ts

@@ -45,13 +45,13 @@ export async function showDocs(ctx: ExtensionCommandContext): Promise<void> {
 				const relation = await commandCtx.ui.select("Relation", DOC_RELATIONS);
 				if (!relation) return;
 				await callService("docs.link", { id: document.id, relation, target_id: targetId });
-				commandCtx.ui.notify(`Linked ${document.id} --${relation}--> ${targetId}`, "info");
+				commandCtx.ui.notify(`Linked "${document.title}" via ${relation}`, "info");
 				return;
 			}
 			const operation = choice === "Activate" ? "docs.activate" : choice === "Archive" ? "docs.archive" : choice === "Reopen" ? "docs.reopen" : undefined;
 			if (operation) {
 				const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: document.id });
-				commandCtx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
+				commandCtx.ui.notify(`${updated.title} → [${updated.status}]`, "info");
 			}
 		},
 	});

package/extension/src/domain-tools.ts

@@ -42,8 +42,10 @@ async function liveAnswer(ctx: ExtensionContext, discussion: Artifact): Promise<
 	if (!ctx.hasUI) return undefined;
 	const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
 	if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
-		const selected = await pickDiscussionOptions(ctx, pending.pendingOptionsMode, pending.pendingOptions);
-		return selected ? { content: selected.join(", "), selected } : undefined;
+		const result = await pickDiscussionOptions(ctx, pending.pendingOptionsMode, pending.pendingOptions);
+		if (!result) return undefined;
+		if (result.kind === "freeform") return { content: result.text };
+		return { content: result.selected.join(", "), selected: result.selected };
 	}
 	const content = await ctx.ui.input(`Reply to "${discussion.title}":`, "");
 	return content ? { content } : undefined;
@@ -67,6 +69,15 @@ export function artifactLines(artifacts: Artifact[]): string[] {
 	return artifacts.map((artifact) => (titleCounts.get(artifact.title)! > 1 ? `${artifactLine(artifact)} (${artifact.id})` : artifactLine(artifact)));
 }
 
+/** Resolves internal ids for model text; ids resurface only when equal titles need disambiguation. */
+async function artifactLabelsById(ids: readonly string[]): Promise<Map<string, string>> {
+	const uniqueIds = [...new Set(ids)];
+	const artifacts = (await Promise.all(uniqueIds.map((id) => callService<Record<string, unknown>, Artifact | null>("artifact.show", { id })))).filter((artifact): artifact is Artifact => artifact !== null);
+	const titleCounts = new Map<string, number>();
+	for (const artifact of artifacts) titleCounts.set(artifact.title, (titleCounts.get(artifact.title) ?? 0) + 1);
+	return new Map(artifacts.map((artifact) => [artifact.id, titleCounts.get(artifact.title)! > 1 ? `${artifact.title} (${artifact.id})` : artifact.title]));
+}
+
 /**
  * Exact, case-insensitive, trimmed title match against an already-fetched candidate set. Throws
  * a clear "not found" or "ambiguous -- use id" error rather than guessing at a fuzzy match -- id
@@ -130,15 +141,15 @@ async function resolveNameArrayField(
  * Returns null when action is neither, so callers fall through to their own dispatch.
  */
 async function handleArtifactRemoveRestore(action: unknown, params: Record<string, unknown>): Promise<ReturnType<typeof text> | null> {
-	// Trashed/restored are still directly showable by id (see artifact-trash.ts), so the title is
-	// available either side of the action -- fetched here purely for a name-primary message; falls
-	// back to the raw id only if the artifact genuinely can't be shown (e.g. an unknown id).
+	// Trashed/restored artifacts stay directly showable, so known identities render by title on
+	// either side of the action. An unresolved explicit id stays in structured/error channels;
+	// normal model text does not turn that backend key into the artifact's public name.
 	const titleOf = async (): Promise<string> => {
 		try {
 			const artifact = await callService<Record<string, unknown>, Artifact | null>("artifact.show", { id: params["id"] });
-			return artifact ? `"${artifact.title}"` : String(params["id"]);
+			return artifact ? `"${artifact.title}"` : "unknown artifact";
 		} catch {
-			return String(params["id"]);
+			return "unknown artifact";
 		}
 	};
 	if (action === "remove") {
@@ -216,17 +227,26 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				// ever holds this extension's own registered session anyway (see session-identity.ts).
 				const resolvedSessionId = params.session_id ?? ctx.sessionManager.getSessionId();
 				const baseRequest = { project_root: params.project_root ?? ctx.cwd, actor: "agent", source: "pi-tool", session_id: resolvedSessionId, ...sessionSecretField(resolvedSessionId as string) };
-				// Resolves every *_name field to its *_id counterpart before dispatch, so every action
-				// below can go on reading id/dependency_id/parent_id/child_id/root_task_id exactly as
-				// before -- id-based calls are unaffected; name-based ones are transparently rewritten.
+				// Resolve the graph root first: every other name lookup must use the caller's final
+				// project/scope/root selection, otherwise `scope: all|graph` silently collapses back
+				// to the current project and forces callers to reach for an id.
+				await resolveNameFields(params, [
+					{ nameKey: "root_task_name", idKey: "root_task_id", listOperation: "tasks.list", baseRequest: { ...baseRequest, scope: "project" } },
+				]);
+				const resolutionRequest = {
+					...baseRequest,
+					...(params.scope === undefined ? {} : { scope: params.scope }),
+					...(params.root_task_id === undefined ? {} : { root_task_id: params.root_task_id }),
+				};
+				// The daemon remains keyed by stable ids; the agent facade resolves names against the
+				// exact requested view before dispatching those internal ids.
 				await resolveNameFields(params, [
-					{ nameKey: "name", idKey: "id", listOperation: "tasks.list", baseRequest },
-					{ nameKey: "dependency_name", idKey: "dependency_id", listOperation: "tasks.list", baseRequest },
-					{ nameKey: "parent_name", idKey: "parent_id", listOperation: "tasks.list", baseRequest },
-					{ nameKey: "child_name", idKey: "child_id", listOperation: "tasks.list", baseRequest },
-					{ nameKey: "root_task_name", idKey: "root_task_id", listOperation: "tasks.list", baseRequest },
+					{ nameKey: "name", idKey: "id", listOperation: "tasks.list", baseRequest: resolutionRequest },
+					{ nameKey: "dependency_name", idKey: "dependency_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
+					{ nameKey: "parent_name", idKey: "parent_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
+					{ nameKey: "child_name", idKey: "child_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
 				]);
-				await resolveNameArrayField(params, "depends_on_names", "depends_on", "tasks.list", baseRequest);
+				await resolveNameArrayField(params, "depends_on_names", "depends_on", "tasks.list", resolutionRequest);
 				const request = { ...params, ...baseRequest };
 				if (action === "create") {
 					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", request);
@@ -292,17 +312,19 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const byId = new Map(plan.nodes.map((node) => [node.id, node]));
 					const titleCounts = new Map<string, number>();
 					for (const node of plan.nodes) titleCounts.set(node.title, (titleCounts.get(node.title) ?? 0) + 1);
+					const nodeLabel = (id: string): string => {
+						const node = byId.get(id);
+						if (!node) return "unknown task";
+						return (titleCounts.get(node.title) ?? 0) > 1 ? `${node.title} (${node.id})` : node.title;
+					};
 					const lines = plan.layers.flatMap((layer, index) => [
 						`Layer ${index + 1}`,
 						...layer.map((id) => {
 							const node = byId.get(id);
-							if (!node) return `  [unknown] ${id}`;
-							return (titleCounts.get(node.title) ?? 0) > 1
-								? `  [${node.state}] ${node.title} (${node.id})`
-								: `  [${node.state}] ${node.title}`;
+							return `  [${node?.state ?? "unknown"}] ${nodeLabel(id)}`;
 						}),
 					]);
-					if (plan.cycleIds.length > 0) lines.push(`Invalid cycle: ${plan.cycleIds.join(", ")}`);
+					if (plan.cycleIds.length > 0) lines.push(`Invalid cycle: ${plan.cycleIds.map(nodeLabel).join(", ")}`);
 					const output = lines.join("\n") || "No tasks in execution plan.";
 					return text(output, createPreviewDetails("tasks.plan", "Task execution plan", output));
 				}
@@ -316,8 +338,9 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}${item.reason ? ` — ${item.reason}` : ""}`).join("\n");
 					const focused = result.focused ? `\nActive: ${artifactLine(result.focused)}` : "";
 					const blockedLines = artifactLines(result.blocked.map((entry) => entry.artifact));
+					const dependencyLabels = await artifactLabelsById(result.blocked.flatMap((entry) => entry.dependencyIds));
 					const blocked = result.blocked.length > 0
-						? `\nBlocked: ${result.blocked.map((entry, index) => `${blockedLines[index]} waits for ${entry.dependencyIds.join(", ")}`).join("; ")}`
+						? `\nBlocked: ${result.blocked.map((entry, index) => `${blockedLines[index]} waits for ${entry.dependencyIds.map((id) => dependencyLabels.get(id) ?? "unknown task").join(", ")}`).join("; ")}`
 						: "";
 					const output = `${result.completed ? "Completed" : "Rejected"}: ${artifactLine(result.artifact)}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`;
 					return text(output, createPreviewDetails("tasks.complete", "Task completion", output));
@@ -524,11 +547,12 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "playbooks",
 		label: "Playbooks",
-		description: "Playbook domain tool -- a completely different beast from the skills tool, not a subtype of it. A Playbook is a trigger and an ordered list of steps an agent reads and follows; it is never mechanically instantiated the way a Skill's artifact-template or workflow blueprint is, and it never composes other Playbooks. ACTIONS: create, list, show, invoke, enable, disable, assign_project, update, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. invoke renders the trigger/steps/tools into guidance plus any real linked artifacts. update changes title/body/labels (at least one required) and is refused for a read-only external projection. remove moves a Playbook to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the playbook's exact title) over `id` -- id is a backend implementation detail, resolved from name automatically.",
+		description: "Playbook domain tool -- a completely different beast from the skills tool, not a subtype of it. A Playbook is a trigger and an ordered list of steps an agent reads and follows; it is never mechanically instantiated the way a Skill's artifact-template or workflow blueprint is, and it never composes other Playbooks. ACTIONS: create, list, show, invoke, enable, disable, assign_project, update, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. On create, `arguments` declares named inputs the Playbook needs: [{name, description?, required?}] (required defaults true). On invoke, `arguments` supplies known values as {name: value}; invoke renders which declared REQUIRED arguments are still missing and directs you to ask the human for them via the discuss tool with live:true -- never guess or invent a value for a missing required argument. update changes title/body/labels (at least one required) and is refused for a read-only external projection. remove moves a Playbook to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the playbook's exact title) over `id` -- id is a backend implementation detail, resolved from name automatically.",
 		parameters: Type.Object({
 			action: Type.String(), id: Type.Optional(Type.String()), name: Type.Optional(Type.String()), title: Type.Optional(Type.String()),
 			body: Type.Optional(Type.String()), trigger: Type.Optional(Type.String()), steps: Type.Optional(Type.Array(Type.String())),
 			tools: Type.Optional(Type.Array(Type.String())), labels: Type.Optional(Type.Array(Type.String())),
+			arguments: Type.Optional(Type.Unknown()),
 			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())), status: Type.Optional(Type.String()),
 			text: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()),
 			project_root: Type.Optional(Type.String()), reason: Type.Optional(Type.String()),
@@ -615,16 +639,14 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const execution = run.execution.nodes.map((node) => (runTitleCounts.get(node.title) ?? 0) > 1
 						? `  [${node.state}] ${node.title} (${node.id})`
 						: `  [${node.state}] ${node.title}`).join("\n");
-					// Root task titles are free here (already present in execution.nodes); created docs/rules
-					// are a different kind not covered by this run's own execution nodes, so those still list by
-					// id below -- fetching their titles would mean an extra round-trip per artifact.
 					const nodeById = new Map(run.execution.nodes.map((node) => [node.id, node]));
-					const rootLabels = run.rootTaskIds.map((id) => nodeById.get(id)?.title ?? id);
+					const rootLabels = run.rootTaskIds.map((id) => nodeById.get(id)?.title ?? "unknown task");
+					const createdLabels = await artifactLabelsById([...run.created.docs, ...run.created.rules]);
 					return text([
 						`Created Skill run ${run.runId}: ${run.created.tasks.length} tasks, ${run.created.rules.length} rules, ${run.created.docs.length} docs.`,
 						`Ready roots: ${rootLabels.join(", ") || "none"}.`,
-						`Context docs: ${run.created.docs.join(", ") || "none"}.`,
-						`Scoped rules: ${run.created.rules.join(", ") || "none"}.`,
+						`Context docs: ${run.created.docs.map((id) => createdLabels.get(id) ?? "unknown document").join(", ") || "none"}.`,
+						`Scoped rules: ${run.created.rules.map((id) => createdLabels.get(id) ?? "unknown rule").join(", ") || "none"}.`,
 						...(execution ? ["Execution:", execution] : []),
 					].join("\n"), createInvocationDetails("skills.run", run.runId, {
 						tasks: run.created.tasks,

package/extension/src/index.ts

@@ -47,6 +47,27 @@ function text(value: string, details: unknown = {}) {
 	return { content: [{ type: "text" as const, text: modelContent.text }], details };
 }
 
+function artifactTextLabel(artifact: Artifact): string {
+	return `[${artifact.kind}|${artifact.status}] ${artifact.title}`;
+}
+
+function artifactTextLines(artifacts: readonly Artifact[]): string[] {
+	const titleCounts = new Map<string, number>();
+	for (const artifact of artifacts) titleCounts.set(artifact.title, (titleCounts.get(artifact.title) ?? 0) + 1);
+	return artifacts.map((artifact) => titleCounts.get(artifact.title)! > 1
+		? `${artifactTextLabel(artifact)} (${artifact.id})`
+		: artifactTextLabel(artifact));
+}
+
+/** Resolves graph protocol ids into model-facing names; equal titles retain ids only to disambiguate. */
+async function artifactNamesById(ids: readonly string[]): Promise<Map<string, string>> {
+	const uniqueIds = [...new Set(ids)];
+	const artifacts = (await Promise.all(uniqueIds.map((id) => callService<Record<string, unknown>, Artifact | null>("artifact.show", { id })))).filter((artifact): artifact is Artifact => artifact !== null);
+	const titleCounts = new Map<string, number>();
+	for (const artifact of artifacts) titleCounts.set(artifact.title, (titleCounts.get(artifact.title) ?? 0) + 1);
+	return new Map(artifacts.map((artifact) => [artifact.id, titleCounts.get(artifact.title)! > 1 ? `${artifact.title} (${artifact.id})` : artifact.title]));
+}
+
 // ---------------------------------------------------------------------------
 // Task widget (TodoOverlay pattern from rpiv-todo: factory form, requestRender)
 // ---------------------------------------------------------------------------
@@ -272,7 +293,7 @@ export default async function (pi: ExtensionAPI) {
 					...params,
 					...(params.kind === "task" ? { project_root: params.project_root ?? ctx.cwd } : {}),
 				});
-				return text(`Created ${a.id} [${a.kind}|${a.status}] ${a.title}`, createArtifactDetails("artifact.create", a));
+				return text(`Created ${artifactTextLabel(a)}`, createArtifactDetails("artifact.create", a));
 			} catch (e) {
 				throw new Error(`papyrus_create failed: ${e instanceof Error ? e.message : e}`);
 			}
@@ -295,7 +316,7 @@ export default async function (pi: ExtensionAPI) {
 			try {
 				const rows = await callService<Record<string, unknown>, Artifact[]>("artifact.query", { ...params, limit: params.limit ?? 50 });
 				if (rows.length === 0) return text("No artifacts found.", createArtifactListDetails("artifact.query", rows));
-				const lines = rows.map((row, index) => `${index + 1}. ${row.id} [${row.kind}|${row.status}] ${row.title}`);
+				const lines = artifactTextLines(rows).map((line, index) => `${index + 1}. ${line}`);
 				return text(`${rows.length} artifact(s):\n\n${lines.join("\n")}`, createArtifactListDetails("artifact.query", rows));
 			} catch (e) {
 				throw new Error(`papyrus_query failed: ${e instanceof Error ? e.message : e}`);
@@ -332,12 +353,15 @@ export default async function (pi: ExtensionAPI) {
 			try {
 				if (params.action === "link") {
 					await callService("graph.link", { from: params.from!, relation: params.relation!, to: params.to! });
-					const output = `Linked ${params.from} --${params.relation}--> ${params.to}`;
+					const names = await artifactNamesById([params.from!, params.to!]);
+					const output = `Linked "${names.get(params.from!) ?? "unknown artifact"}" --${params.relation}--> "${names.get(params.to!) ?? "unknown artifact"}"`;
 					return text(output, createPreviewDetails("graph.link", "Artifact relationship", output));
 				}
 				if (params.action === "unlink") {
 					const result = await callService<Record<string, unknown>, { removed: boolean }>("graph.unlink", { from: params.from!, relation: params.relation!, to: params.to! });
-					const output = result.removed ? `Unlinked ${params.from} --${params.relation}--> ${params.to}` : `No such relationship: ${params.from} --${params.relation}--> ${params.to}`;
+					const names = await artifactNamesById([params.from!, params.to!]);
+					const relationship = `"${names.get(params.from!) ?? "unknown artifact"}" --${params.relation}--> "${names.get(params.to!) ?? "unknown artifact"}"`;
+					const output = result.removed ? `Unlinked ${relationship}` : `No such relationship: ${relationship}`;
 					return text(output, createPreviewDetails("graph.unlink", "Artifact relationship", output));
 				}
 				if (params.action === "tree") {
@@ -351,22 +375,25 @@ export default async function (pi: ExtensionAPI) {
 					if (!a) throw new Error(`artifact ${root} not found`);
 					const edges = a.edges ?? [];
 					if (edges.length === 0) return text(`${a.title} — no edges`, createGraphDetails("graph.tree", [a], []));
+					const names = await artifactNamesById(edges.flatMap((edge) => [edge.from, edge.to]));
 					return text(
-						`Subgraph from ${a.title} (${edges.length} edges):\n\n${edges.map((edge: any) => `  ${edge.from} --${edge.relation}--> ${edge.to}`).join("\n")}`,
+						`Subgraph from ${a.title} (${edges.length} edges):\n\n${edges.map((edge) => `  "${names.get(edge.from) ?? "unknown artifact"}" --${edge.relation}--> "${names.get(edge.to) ?? "unknown artifact"}"`).join("\n")}`,
 						createGraphDetails("graph.tree", [a], edges),
 					);
 				}
 				if (params.action === "status") {
 					const a = await callService<Record<string, unknown>, Artifact | null>("graph.status", { id: params.id!, status: params.status! });
 					if (!a) throw new Error(`artifact ${params.id} not found`);
-					return text(`Updated ${a.id} → [${a.status}]`, createArtifactDetails("graph.status", a));
+					return text(`Updated "${a.title}" → [${a.status}]`, createArtifactDetails("graph.status", a));
 				}
 				if (params.action === "history") {
 					const page = await callService<Record<string, unknown>, { events: Array<Record<string, unknown>> }>("graph.history", {
 						id: params.id, actor: params.actor, session_id: params.session_id, since: params.since, limit: params.limit,
 					});
 					if (page.events.length === 0) return text("No recorded events.", createPreviewDetails("graph.history", "Mutation event log", "No recorded events."));
-					const output = page.events.map((event) => `${event["occurredAt"]} ${event["artifactId"]} ${event["type"]} · ${event["actor"]}/${event["source"]}`).join("\n");
+					const eventIds = page.events.map((event) => event["artifactId"]).filter((id): id is string => typeof id === "string");
+					const names = await artifactNamesById(eventIds);
+					const output = page.events.map((event) => `${event["occurredAt"]} "${typeof event["artifactId"] === "string" ? names.get(event["artifactId"]) ?? "unknown artifact" : "unknown artifact"}" ${event["type"]} · ${event["actor"]}/${event["source"]}`).join("\n");
 					return text(output, createPreviewDetails("graph.history", "Mutation event log", output));
 				}
 				throw new Error(`unknown action: ${params.action}; use link, tree, status, or history`);
@@ -397,12 +424,13 @@ export default async function (pi: ExtensionAPI) {
 					max_nodes: params.max_nodes,
 				});
 				if (!a) throw new Error(`artifact ${params.id} not found`);
-				let out = `${a.id} [${a.kind}|${a.status}]\n${a.title}\n\n${a.body}`;
+				let out = `${artifactTextLabel(a)}\n\n${a.body}`;
 				if (Object.keys(a.extra).length > 0) {
 					out += `\n\nMetadata:\n${formatMetadata(a.extra).map((line) => `  ${line}`).join("\n")}`;
 				}
 				if (a.edges?.length) {
-					out += `\n\nEdges:\n${a.edges.map((edge) => `  ${edge.from} --${edge.relation}--> ${edge.to}`).join("\n")}`;
+					const names = await artifactNamesById(a.edges.flatMap((edge) => [edge.from, edge.to]));
+					out += `\n\nEdges:\n${a.edges.map((edge) => `  "${names.get(edge.from) ?? "unknown artifact"}" --${edge.relation}--> "${names.get(edge.to) ?? "unknown artifact"}"`).join("\n")}`;
 				}
 				if (params.run_gates) {
 					const results = await callService<Record<string, unknown>, GateResult[]>("gates.run", { id: params.id });

package/extension/src/playbooks.ts

@@ -86,12 +86,12 @@ export async function showPlaybooks(ctx: ExtensionCommandContext): Promise<void>
 				const relation = await commandCtx.ui.select("Relation", PLAYBOOK_RELATIONS);
 				if (!relation) return;
 				await callService("graph.link", { from: playbook.id, relation, to: targetId });
-				commandCtx.ui.notify(`Linked ${playbook.id} --${relation}--> ${targetId}`, "info");
+				commandCtx.ui.notify(`Linked "${playbook.title}" via ${relation}`, "info");
 				return;
 			}
 			const operation = choice === "Disable" ? "playbooks.disable" : "playbooks.enable";
 			const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: playbook.id });
-			commandCtx.ui.notify(`${updated.id} \u2192 [${updated.status}]`, "info");
+			commandCtx.ui.notify(`${updated.title} \u2192 [${updated.status}]`, "info");
 		},
 	});
 }

package/extension/src/rules.ts

@@ -44,7 +44,7 @@ export async function showRules(ctx: ExtensionCommandContext): Promise<void> {
 			} else {
 				const operation = choice === "Disable" ? "rules.disable" : "rules.enable";
 				const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: rule.id });
-				commandCtx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
+				commandCtx.ui.notify(`${updated.title} → [${updated.status}]`, "info");
 			}
 		},
 	});

package/extension/src/skills.ts

@@ -32,11 +32,11 @@ export function skillRowMeta(skill: Artifact): string {
 
 export function skillInvocationPrompt(skill: Artifact): string {
 	if (skill.subtype === "artifact-template") {
-		return [`Create an artifact using Papyrus template \"${skill.title}\".`, `template_id: ${skill.id}`, "Ask for or infer the title and all required template fields, then call papyrus_create."].join("\n");
+		return [`Create an artifact using Papyrus template \"${skill.title}\".`, `template_name: ${skill.title}`, "Ask for or infer the title and all required template fields, then call the skills domain tool with action=instantiate."].join("\n");
 	}
 	if (skill.subtype === "workflow") {
 		return [
-			`Run Papyrus workflow Skill \"${skill.title}\" (${skill.id}).`,
+			`Run Papyrus workflow Skill \"${skill.title}\".`,
 			"Collect its required arguments, then call the skills domain tool with action=run.",
 		].join("\n");
 	}
@@ -44,7 +44,7 @@ export function skillInvocationPrompt(skill: Artifact): string {
 	const steps = strings(skill.extra["steps"]);
 	const tools = strings(skill.extra["tools"]);
 	return [
-		`Apply Papyrus skill \"${skill.title}\" (${skill.id}).`,
+		`Apply Papyrus skill \"${skill.title}\".`,
 		`Trigger: ${trigger}`,
 		...(skill.body ? [`Context: ${skill.body}`] : []),
 		...(steps.length > 0 ? ["Steps:", ...steps.map((step, index) => `${index + 1}. ${step}`)] : []),
@@ -120,7 +120,7 @@ export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
 			} else {
 				const operation = choice === "Disable" ? "skills.disable" : "skills.enable";
 				const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: skill.id });
-				commandCtx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
+				commandCtx.ui.notify(`${updated.title} → [${updated.status}]`, "info");
 			}
 		},
 	});

package/extension/src/tasks.ts

@@ -32,6 +32,12 @@ const STATUS_ACTIONS: Record<string, string[]> = {
 
 type TaskRow = Artifact;
 
+function taskChoiceLabels(tasks: readonly Artifact[]): string[] {
+	const titleCounts = new Map<string, number>();
+	for (const task of tasks) titleCounts.set(task.title, (titleCounts.get(task.title) ?? 0) + 1);
+	return tasks.map((task) => titleCounts.get(task.title)! > 1 ? `${task.title} (${task.id})` : task.title);
+}
+
 export interface TaskHierarchyRow {
 	task: TaskRow;
 	depth: number;
@@ -101,9 +107,10 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			if (scope === "graph") {
 				const projectGraph = await loadTaskGraph(ctx.cwd, sessionId, "project");
 				const roots = projectGraph.rootIds.map((id) => projectGraph.nodes.find((node) => node.task.id === id)?.task).filter((task): task is Artifact => task !== undefined);
-				const selected = await ctx.ui.select("Focused root or epic", roots.map((task) => `${task.title} · ${task.id}`));
+				const rootLabels = taskChoiceLabels(roots);
+				const selected = await ctx.ui.select("Focused root or epic", rootLabels);
 				if (!selected) continue;
-				rootTaskId = roots.find((task) => `${task.title} · ${task.id}` === selected)?.id;
+				rootTaskId = roots[rootLabels.indexOf(selected)]?.id;
 				if (!rootTaskId) continue;
 			}
 			await callService("tasks.set_scope", { project_root: ctx.cwd, scope, ...(rootTaskId ? { root_task_id: rootTaskId } : {}) });
@@ -131,17 +138,20 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 
 		if (choice === "Remove dependency" || choice === "Remove from parent") {
 			const relatedIds = choice === "Remove dependency" ? node!.dependencyIds : node!.parentIds;
-			const relatedTitles = relatedIds.map((relatedId) => `${graph.nodes.find((entry) => entry.task.id === relatedId)?.task.title ?? relatedId} · ${relatedId}`);
+			const relatedTasks = relatedIds.map((relatedId) => graph.nodes.find((entry) => entry.task.id === relatedId)?.task).filter((task): task is Artifact => task !== undefined);
+			const relatedTitles = taskChoiceLabels(relatedTasks);
 			const selected = await ctx.ui.select(choice === "Remove dependency" ? "Remove which dependency?" : "Remove from which parent?", relatedTitles);
 			if (!selected) continue;
-			const relatedId = relatedIds[relatedTitles.indexOf(selected)]!;
+			const relatedTask = relatedTasks[relatedTitles.indexOf(selected)];
+			if (!relatedTask) continue;
+			const relatedId = relatedTask.id;
 			try {
 				if (choice === "Remove dependency") {
 					await callService("tasks.undepend", { id: action.row.id, dependency_id: relatedId, actor: "user", source: "tasks-tui", session_id: sessionId });
-					ctx.ui.notify(`Removed dependency on ${relatedId}`, "info");
+					ctx.ui.notify(`Removed dependency on ${relatedTask.title}`, "info");
 				} else {
 					await callService("tasks.uncontain", { parent_id: relatedId, child_id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
-					ctx.ui.notify(`Removed from parent ${relatedId}`, "info");
+					ctx.ui.notify(`Removed from parent ${relatedTask.title}`, "info");
 				}
 			} catch (error) {
 				ctx.ui.notify(`Relationship removal failed: ${error instanceof Error ? error.message : error}`, "error");
@@ -222,19 +232,20 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target}`).join("\n");
 					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}`).join("\n");
 					const focused = result.focused ? `\nActive: ${result.focused.title}` : "";
+					const taskById = new Map(graph.nodes.map((entry) => [entry.task.id, entry.task]));
 					const blocked = result.blocked.length > 0
-						? `\nWaiting: ${result.blocked.map((entry) => `${entry.artifact.title} needs ${entry.dependencyIds.join(", ")}`).join("; ")}`
+						? `\nWaiting: ${result.blocked.map((entry) => `${entry.artifact.title} needs ${entry.dependencyIds.map((id) => taskById.get(id)?.title ?? "unknown task").join(", ")}`).join("; ")}`
 						: "";
 					ctx.ui.notify(
 						result.completed
-							? `Completed ${result.artifact.id}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`
+							? `Completed ${result.artifact.title}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`
 							: `Review rejected${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`,
 						result.completed ? "info" : "warning",
 					);
 				} else {
 					const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
 					action.row.status = updated.status;
-					ctx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
+					ctx.ui.notify(`${updated.title} → [${updated.status}]`, "info");
 				}
 			} catch (error) {
 				ctx.ui.notify(`Task action failed: ${error instanceof Error ? error.message : error}`, "error");

package/extension/src/tool-rendering/artifact-card.ts

@@ -85,7 +85,7 @@ export class ArtifactCard implements Component {
 		const status = `${statusGlyph(artifact.status)} ${artifact.status}`;
 		const header = [
 			this.theme.fg("toolTitle", this.theme.bold(`${kindGlyph(artifact.kind)} ${artifact.kind.toUpperCase()}`)),
-			this.theme.fg("accent", artifact.id),
+			...(this.expanded ? [this.theme.fg("accent", artifact.id)] : []),
 			this.theme.fg(statusColor(artifact.status), status),
 		].join("  ");
 		const lines = [truncateToWidth(header, safeWidth)];

package/package.json

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

package/src/constants.ts

@@ -100,6 +100,9 @@ export const SKILL_MAX_RENDERED_BYTES = 1_048_576;
 export const SKILL_INVOCATION_MAX_LINKED_ARTIFACTS = 20;
 export const SKILL_INVOCATION_MAX_CALL_DEPTH = 4;
 export const PLAYBOOK_INVOCATION_MAX_LINKED_ARTIFACTS = 20;
+export const PLAYBOOK_ARGUMENT_MAX_COUNT = 20;
+export const PLAYBOOK_ARGUMENT_NAME_MAX_LENGTH = 64;
+export const PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH = 500;
 
 /**
  * At the core, a workflow Skill creates Tasks and begins a pipeline -- an Ansible playbook or
@@ -172,6 +175,9 @@ export const DISCUSSION_ACTOR_MAX_LENGTH = 128;
 export const DISCUSSION_OPTIONS_MIN_COUNT = 2;
 export const DISCUSSION_OPTIONS_MAX_COUNT = 10;
 export const DISCUSSION_OPTION_MAX_LENGTH = 200;
+/** The multi-select picker's idle auto-cancel countdown and its render tick (also drives the cursor-row blink). Single-select has no equivalent -- it delegates to Pi's own native ctx.ui.select, whose input loop this package does not control. */
+export const DISCUSSION_PICKER_IDLE_TIMEOUT_MS = 30_000;
+export const DISCUSSION_PICKER_TICK_MS = 500;
 /** Bounds for the generic graph projection protocol (external bounded contexts). */
 export const GRAPH_PROJECTION_MAX_ARTIFACTS_PER_BATCH = 500;
 export const GRAPH_PROJECTION_MAX_EDGES_PER_BATCH = 1_000;

package/src/domain-services.ts

@@ -4,6 +4,9 @@ import {
 	ARTIFACT_LABEL_MAX_LENGTH,
 	ARTIFACT_SCOPE_MAX_ARTIFACTS,
 	ARTIFACT_TITLE_MAX_LENGTH,
+	PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH,
+	PLAYBOOK_ARGUMENT_MAX_COUNT,
+	PLAYBOOK_ARGUMENT_NAME_MAX_LENGTH,
 	PLAYBOOK_INVOCATION_MAX_LINKED_ARTIFACTS,
 	RULE_TEXT_HARD_LIMIT_CHARACTERS,
 	SKILL_INVOCATION_MAX_CALL_DEPTH,
@@ -440,7 +443,7 @@ export function updateSkill(artifacts: ArtifactStore, id: string, input: UpdateS
 
 function skillInvocationBody(skill: Artifact): string {
 	if (skill.subtype === "artifact-template") {
-		return `Create an artifact using Papyrus template "${skill.title}".\ntemplate_id: ${skill.id}\nAsk for or infer all required template fields, then call the skills domain tool instantiate action.`;
+		return `Create an artifact using Papyrus template "${skill.title}".\ntemplate_name: ${skill.title}\nAsk for or infer all required template fields, then call the skills domain tool instantiate action.`;
 	}
 	if (skill.subtype === "workflow") {
 		const definition = validateSkillDefinition(skill.extra["definition"]);
@@ -448,7 +451,7 @@ function skillInvocationBody(skill: Artifact): string {
 			.filter(([, input]) => input.required && input.default === undefined)
 			.map(([name]) => name);
 		return [
-			`Run Papyrus workflow Skill "${skill.title}" (${skill.id}).`,
+			`Run Papyrus workflow Skill "${skill.title}".`,
 			`Required arguments: ${required.length > 0 ? required.join(", ") : "none"}.`,
 			"Call the skills domain tool with action=run and arguments after collecting required values.",
 		].join("\n");
@@ -457,7 +460,7 @@ function skillInvocationBody(skill: Artifact): string {
 	const steps = Array.isArray(skill.extra["steps"]) ? skill.extra["steps"].filter((step): step is string => typeof step === "string") : [];
 	const tools = Array.isArray(skill.extra["tools"]) ? skill.extra["tools"].filter((tool): tool is string => typeof tool === "string") : [];
 	return [
-		`Apply Papyrus skill "${skill.title}" (${skill.id}).`,
+		`Apply Papyrus skill "${skill.title}".`,
 		`Trigger: ${trigger}`,
 		...(skill.body ? [`Context: ${skill.body}`] : []),
 		...(steps.length ? ["Steps:", ...steps.map((step, index) => `${index + 1}. ${step}`)] : []),
@@ -489,16 +492,16 @@ export function skillInvocation(artifacts: ArtifactStore, id: string, visited: S
 		const target = artifacts.get(edge.to);
 		if (!target) continue; // dangling edge -- defensive, should not happen
 		if (target.kind !== "skill") {
-			linkedArtifactLines.push(`- ${edge.relation} ${target.kind} "${target.title}" (${target.id})`);
+			linkedArtifactLines.push(`- ${edge.relation} ${target.kind} "${target.title}"`);
 			continue;
 		}
 		if (visited.has(target.id)) {
-			linkedSkillSections.push(`Also linked via ${edge.relation} to skill "${target.title}" (${target.id}) -- already invoked above in this chain, not repeated.`);
+			linkedSkillSections.push(`Also linked via ${edge.relation} to skill "${target.title}" -- already invoked above in this chain, not repeated.`);
 		} else if (depth + 1 > SKILL_INVOCATION_MAX_CALL_DEPTH) {
-			linkedSkillSections.push(`Also linked via ${edge.relation} to skill "${target.title}" (${target.id}) -- call depth limit reached, invoke it separately.`);
+			linkedSkillSections.push(`Also linked via ${edge.relation} to skill "${target.title}" -- call depth limit reached, invoke it separately.`);
 		} else {
 			const nested = skillInvocation(artifacts, target.id, visited, depth + 1);
-			linkedSkillSections.push(`Also invoke linked skill (${edge.relation}) "${target.title}" (${target.id}):\n${nested}`);
+			linkedSkillSections.push(`Also invoke linked skill (${edge.relation}) "${target.title}":\n${nested}`);
 		}
 	}
 	if (linkedArtifactLines.length > 0) {
@@ -522,12 +525,46 @@ export function transitionSkill(artifacts: ArtifactStore, id: string, action: Sk
  * mechanically instantiated into other artifacts; a Playbook is never instantiated, it's read
  * and followed, and it never composes other Playbooks the way a Skill can call another Skill.
  */
+export interface PlaybookArgument {
+	name: string;
+	description?: string;
+	/** Defaults true: naming an argument at all is a signal it matters, so an author must opt out explicitly to make one optional. */
+	required: boolean;
+}
+
+/** Rejects malformed input rather than silently dropping a bad entry -- the same posture creation validation already takes everywhere else. */
+function validatePlaybookArguments(value: unknown): PlaybookArgument[] | undefined {
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value)) throw new Error("playbook arguments must be an array");
+	if (value.length > PLAYBOOK_ARGUMENT_MAX_COUNT) throw new Error(`playbook arguments cannot exceed ${PLAYBOOK_ARGUMENT_MAX_COUNT} entries`);
+	const seen = new Set<string>();
+	return value.map((entry, index) => {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new Error(`argument at index ${index} must be an object`);
+		const record = entry as Record<string, unknown>;
+		const name = record["name"];
+		if (typeof name !== "string" || name.trim().length === 0 || name.length > PLAYBOOK_ARGUMENT_NAME_MAX_LENGTH) {
+			throw new Error(`argument name must be between 1 and ${PLAYBOOK_ARGUMENT_NAME_MAX_LENGTH} characters`);
+		}
+		if (seen.has(name)) throw new Error(`argument name "${name}" is declared more than once`);
+		seen.add(name);
+		const description = record["description"];
+		if (description !== undefined && (typeof description !== "string" || description.length > PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH)) {
+			throw new Error(`argument "${name}" description cannot exceed ${PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH} characters`);
+		}
+		const required = record["required"];
+		if (required !== undefined && typeof required !== "boolean") throw new Error(`argument "${name}" required must be a boolean`);
+		return { name, ...(description !== undefined ? { description: description as string } : {}), required: required !== false };
+	});
+}
+
 export interface CreatePlaybookInput {
 	title: string;
 	body?: string;
 	trigger?: string;
 	steps?: string[];
 	tools?: string[];
+	/** Declares named arguments this Playbook needs -- see playbookInvocation for how a missing required one surfaces. */
+	arguments?: unknown;
 	labels?: string[];
 	extra?: Record<string, unknown>;
 	projectRoot?: string;
@@ -538,6 +575,7 @@ export type UpdatePlaybookInput = UpdateContentInput;
 
 export function createPlaybook(artifacts: ArtifactStore, scopes: ArtifactScopeStore, input: CreatePlaybookInput, context?: ArtifactEventContext): Artifact {
 	const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
+	const declaredArguments = validatePlaybookArguments(input.arguments);
 	const playbook = artifacts.create({
 		kind: "playbook",
 		status: "active", // explicit; see createDocument for why defaultStatusFor is not trusted here
@@ -549,6 +587,7 @@ export function createPlaybook(artifacts: ArtifactStore, scopes: ArtifactScopeSt
 			...(input.trigger ? { trigger: input.trigger } : {}),
 			...(input.steps ? { steps: input.steps } : {}),
 			...(input.tools ? { tools: input.tools } : {}),
+			...(declaredArguments ? { arguments: declaredArguments } : {}),
 		},
 	}, context);
 	scopes.assign(playbook.id, projectRoot, projectRoot === undefined ? "unscoped" : "explicit");
@@ -587,22 +626,40 @@ export function transitionPlaybook(artifacts: ArtifactStore, id: string, action:
 	return artifacts.setStatus(id, target, context)!;
 }
 
-/** Renders trigger/steps/tools into readable guidance, plus any real linked artifacts. No nested playbook-calls-playbook composition -- a Playbook is a flat procedure, not a composable bundle. */
-export function playbookInvocation(artifacts: ArtifactStore, id: string): string {
+/**
+ * Renders trigger/steps/tools/arguments into readable guidance, plus any real linked artifacts.
+ * No nested playbook-calls-playbook composition -- a Playbook is a flat procedure, not a
+ * composable bundle. `provided` is the caller's already-known argument values (e.g. from the
+ * conversation so far); any declared *required* argument missing from it is called out
+ * explicitly, directing the agent to discuss (live:true) rather than guess or silently proceed.
+ */
+export function playbookInvocation(artifacts: ArtifactStore, id: string, provided: Record<string, string> = {}): string {
 	const playbook = requireKind(artifacts, id, "playbook");
 	const trigger = typeof playbook.extra["trigger"] === "string" ? playbook.extra["trigger"] : "manual invocation";
 	const steps = Array.isArray(playbook.extra["steps"]) ? playbook.extra["steps"].filter((step): step is string => typeof step === "string") : [];
 	const tools = Array.isArray(playbook.extra["tools"]) ? playbook.extra["tools"].filter((tool): tool is string => typeof tool === "string") : [];
+	const declaredArguments = Array.isArray(playbook.extra["arguments"]) ? (playbook.extra["arguments"] as PlaybookArgument[]) : [];
+	const argumentLines = declaredArguments.map((argument) => {
+		const value = provided[argument.name];
+		if (value !== undefined) return `- ${argument.name}: ${value}`;
+		const qualifier = argument.required ? "required" : "optional";
+		return `- ${argument.name} (${qualifier}${argument.description ? `: ${argument.description}` : ""}) -- not yet provided`;
+	});
+	const missingRequired = declaredArguments.filter((argument) => argument.required && provided[argument.name] === undefined);
 	const sections = [[
-		`Apply Papyrus playbook "${playbook.title}" (${playbook.id}).`,
+		`Apply Papyrus playbook "${playbook.title}".`,
 		`Trigger: ${trigger}`,
 		...(playbook.body ? [`Context: ${playbook.body}`] : []),
+		...(argumentLines.length > 0 ? ["Arguments:", ...argumentLines] : []),
+		...(missingRequired.length > 0
+			? [`Missing required argument(s): ${missingRequired.map((argument) => argument.name).join(", ")}. Ask the human for these directly -- the discuss tool with live:true asks synchronously and gets a real answer in this same turn -- before proceeding with the steps below. Do not guess or invent a value.`]
+			: []),
 		...(steps.length ? ["Steps:", ...steps.map((step, index) => `${index + 1}. ${step}`)] : []),
 		...(tools.length ? [`Tools: ${tools.join(", ")}`] : []),
 	].join("\n")];
 	const edges = artifacts.relationships({ artifactIds: [id] }).filter((edge) => edge.from === id).slice(0, PLAYBOOK_INVOCATION_MAX_LINKED_ARTIFACTS);
 	const linkedLines = edges
-		.map((edge) => { const target = artifacts.get(edge.to); return target ? `- ${edge.relation} ${target.kind} "${target.title}" (${target.id})` : undefined; })
+		.map((edge) => { const target = artifacts.get(edge.to); return target ? `- ${edge.relation} ${target.kind} "${target.title}"` : undefined; })
 		.filter((line): line is string => line !== undefined);
 	if (linkedLines.length > 0) sections.push(["Linked context (query Papyrus for full detail before proceeding):", ...linkedLines].join("\n"));
 	return sections.join("\n\n");

package/src/modules/playbooks.ts

@@ -61,12 +61,13 @@ export function playbooksOperations(artifacts: ArtifactStore, scopes: ArtifactSc
 		define("playbooks.create", (input: OperationInput) => createPlaybook(artifacts, scopes, {
 			title: string(input, "title"), body: optionalString(input, "body"), trigger: optionalString(input, "trigger"),
 			steps: input["steps"] as string[] | undefined, tools: input["tools"] as string[] | undefined,
+			arguments: input["arguments"],
 			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
 			projectRoot: optionalString(input, "project_root"),
 		}, eventContext(input))),
 		define("playbooks.list", (input: OperationInput) => listPlaybooks(artifacts, scopes, artifactFilter(input))),
 		define("playbooks.show", (input: OperationInput) => showPlaybook(artifacts, string(input, "id"))),
-		define("playbooks.invoke", (input: OperationInput) => playbookInvocation(artifacts, string(input, "id"))),
+		define("playbooks.invoke", (input: OperationInput) => playbookInvocation(artifacts, string(input, "id"), input["arguments"] as Record<string, string> | undefined)),
 		define("playbooks.enable", (input: OperationInput) => transitionPlaybook(artifacts, string(input, "id"), "enable", eventContext(input))),
 		define("playbooks.disable", (input: OperationInput) => transitionPlaybook(artifacts, string(input, "id"), "disable", eventContext(input))),
 		define("playbooks.assign_project", (input: OperationInput) => assignPlaybookProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),

package/src/task-context.ts

@@ -29,7 +29,7 @@ function renderCurrent(task: Artifact): string[] {
 	const desired = task.body.trim() || task.title;
 	const gates = gatesFrom(task);
 	return [
-		`Current: ${task.title} (${task.id})`,
+		`Current: ${task.title}`,
 		`Desired: ${desired}`,
 		`Verify: ${gates.length > 0 ? gates.map(renderGate).join("; ") : "inspect the desired outcome; no automated gates configured"}`,
 	];
@@ -56,7 +56,7 @@ function deferredBlockingDiscussions(artifacts: ArtifactStore, activeTaskId: str
 			if (!inScope(edge.to, activeTaskId, taskIds)) continue;
 			const blockedTask = artifacts.get(edge.to);
 			if (!blockedTask || blockedTask.status === "done" || blockedTask.status === "canceled") continue;
-			lines.push(`${discussion.title} (${discussion.id}) -- blocks "${blockedTask.title}"`);
+			lines.push(`${discussion.title} -- blocks "${blockedTask.title}"`);
 		}
 	}
 	return lines;
@@ -77,8 +77,8 @@ export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, tas
 	const rejected = open.filter((task) => task.status === "rejected").slice(0, TASK_CONTEXT_REJECTED_LIMIT);
 	const lines = tasks.length > 0 ? [`Progress: ${done}/${tasks.length} done`] : [];
 	for (const task of current) lines.push(...renderCurrent(task));
-	if (next) lines.push(`Next: ${next.title} (${next.id})`);
-	if (rejected.length > 0) lines.push(`Rejected: ${rejected.map((task) => `${task.title} (${task.id})`).join(", ")}`);
+	if (next) lines.push(`Next: ${next.title}`);
+	if (rejected.length > 0) lines.push(`Rejected: ${rejected.map((task) => task.title).join(", ")}`);
 	if (deferredDiscussions.length > 0) {
 		lines.push("", "Deferred discussions blocking this scope -- resume and re-surface these, do not leave them dormant:");
 		for (const line of deferredDiscussions) lines.push(`• ${line}`);