@danypops/papyrus 0.25.0 → 0.26.0

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

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

package/extension/src/artifact-browser.ts

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

package/extension/src/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

@@ -69,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
@@ -132,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") {
@@ -218,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);
@@ -294,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));
 				}
@@ -318,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));
@@ -618,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.25.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/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}`);