@danypops/papyrus 0.25.0 → 0.27.0

package/extension/src/discuss.ts

@@ -16,10 +16,10 @@ import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-a
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { DiscussionAndRounds } from "../../src/discussion-service.ts";
 import { readDiscussionExtra } from "../../src/domain/discussion.ts";
+import { askQuestion } from "./discuss-ask-view.ts";
 import { showArtifactBrowser } from "./artifact-browser.ts";
 import { DISCUSSION_STATE_PRESENTATION, DOC_STATUS_PRESENTATION } from "./artifact-status-presentation.ts";
 import { discussionRoundCountOf, discussionStateOf, showDiscussionDetailView } from "./discussion-detail-view.ts";
-import { pickDiscussionOptions } from "./discussion-picker.ts";
 import { callService } from "./service-client.ts";
 
 const SOURCE = "discuss-tui";
@@ -82,25 +82,13 @@ 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 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 });
-					commandCtx.ui.notify(`Selected: ${selected.join(", ")}`, "info");
-					return;
-				}
-				const content = await commandCtx.ui.input("Reply:", "");
-				if (!content) return;
-				await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content, source: SOURCE });
-				commandCtx.ui.notify("Round added.", "info");
+				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 });
+				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");
 				return;
 			}
 			if (choice === "Defer") {

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

@@ -9,7 +9,7 @@ import type { TaskCompletion, TaskGraph } from "../../src/task-service.ts";
 import type { SkillWorkflowRunResult } from "../../src/skill-execution.ts";
 import type { DiscussionAndRounds } from "../../src/discussion-service.ts";
 import { readDiscussionExtra, type DiscussionRound } from "../../src/domain/discussion.ts";
-import { pickDiscussionOptions } from "./discussion-picker.ts";
+import { askQuestion } from "./discuss-ask-view.ts";
 import type { OperationName } from "../../src/service.ts";
 import { emitTaskFocusEvent } from "./task-focus-events.ts";
 import { sessionSecretField } from "./session-identity.ts";
@@ -32,23 +32,25 @@ function text(message: string, details: unknown = {}) {
 }
 
 /**
- * live:true's synchronous half: renders the same picker /discuss's own "Reply" action uses when
- * the just-created round posed a structured choice, or a plain freeform prompt otherwise -- so
- * "ask" covers both a completely open question and a choice tied to this specific Discussion.
- * Returns undefined on cancel or when no interactive UI is available, never throws -- an
- * unanswered live prompt still leaves the round it already recorded intact.
+ * live:true's synchronous half: reuses the same Discuss-owned ask UI (discuss-ask-view.ts) the
+ * /discuss TUI's own "Reply" action uses when the just-created round posed a structured choice,
+ * or a plain freeform prompt otherwise -- so "ask" covers both a completely open question and a
+ * choice tied to this specific Discussion. Returns undefined on cancel or when no interactive UI
+ * is available, never throws -- an unanswered live prompt still leaves the round it already
+ * recorded intact.
  */
 async function liveAnswer(ctx: ExtensionContext, discussion: Artifact): 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}":`;
 	if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
-		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 };
+		return askQuestion(ctx, {
+			question,
+			options: pending.pendingOptions.map((title) => ({ title })),
+			allowMultiple: pending.pendingOptionsMode === "multi",
+		});
 	}
-	const content = await ctx.ui.input(`Reply to "${discussion.title}":`, "");
-	return content ? { content } : undefined;
+	return askQuestion(ctx, { question });
 }
 
 /**
@@ -69,6 +71,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
@@ -132,15 +143,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") {
@@ -218,17 +229,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);
@@ -294,17 +314,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));
 				}
@@ -318,8 +340,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));
@@ -618,16 +641,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.25.0",
+  "version": "0.27.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

@@ -175,9 +175,6 @@ 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

@@ -443,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"]);
@@ -451,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");
@@ -460,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}`)] : []),
@@ -492,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) {
@@ -647,7 +647,7 @@ export function playbookInvocation(artifacts: ArtifactStore, id: string, provide
 	});
 	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] : []),
@@ -659,7 +659,7 @@ export function playbookInvocation(artifacts: ArtifactStore, id: string, provide
 	].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/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}`);