@danypops/papyrus 0.21.4 → 0.21.6

package/extension/src/discuss.ts

@@ -25,6 +25,29 @@ import { callService } from "./service-client.ts";
 const SOURCE = "discuss-tui";
 const ACTOR = "human";
 
+/** Tasks a human could plausibly want to block on -- excludes terminal ones, since blocking already-finished or canceled work is meaningless. */
+export async function openTaskChoices(cwd: string): Promise<Artifact[]> {
+	const rows = await callService<Record<string, unknown>, Artifact[]>("tasks.list", { project_root: cwd });
+	return rows.filter((task) => task.status !== "done" && task.status !== "canceled");
+}
+
+/** Resolves the task ids a Discussion currently has a `blocks` edge to, by title -- so "Unblock" only ever offers tasks actually blocked by this one, never the whole task list. */
+export async function blockedTaskChoices(discussionId: string): Promise<Artifact[]> {
+	const tree = await callService<Record<string, unknown>, Artifact>("graph.tree", { id: discussionId, depth: 1 });
+	const blockedIds = (tree.edges ?? []).filter((edge) => edge.relation === "blocks" && edge.from === discussionId).map((edge) => edge.to);
+	const tasks = await Promise.all(blockedIds.map((id) => callService<Record<string, unknown>, Artifact | null>("tasks.show", { id }).catch(() => null)));
+	return tasks.filter((task): task is Artifact => task !== null);
+}
+
+/** Picking a task by title, the same ui.select pattern used for Discuss's own single-choice options -- no ecosystem extension (Pi's own docs/examples, pi-tasks) builds a bespoke fuzzy picker for a plain "choose one named thing" list. */
+export async function pickTaskByName(ctx: ExtensionCommandContext, title: string, tasks: Artifact[]): Promise<Artifact | undefined> {
+	if (tasks.length === 0) { ctx.ui.notify("No open tasks to choose from.", "info"); return undefined; }
+	const label = await ctx.ui.select(title, tasks.map((task) => `${task.title} [${task.status}]`));
+	if (!label) return undefined;
+	const index = tasks.map((task) => `${task.title} [${task.status}]`).indexOf(label);
+	return index === -1 ? undefined : tasks[index];
+}
+
 export function discussionRowMeta(discussion: Artifact, theme: Theme): string {
 	const state = discussionStateOf(discussion);
 	const presentation = DISCUSSION_STATE_PRESENTATION[state];
@@ -93,17 +116,19 @@ export async function showDiscussions(ctx: ExtensionCommandContext): Promise<voi
 				return;
 			}
 			if (choice === "Block a task") {
-				const taskId = await commandCtx.ui.input("Task artifact id to block:", "");
-				if (!taskId) return;
-				await callService("discuss.block", { id: discussion.id, task_id: taskId, actor: ACTOR, source: SOURCE });
-				commandCtx.ui.notify(`${discussion.id} now blocks ${taskId}`, "info");
+				const target = await pickTaskByName(commandCtx, "Block which task?", await openTaskChoices(commandCtx.cwd));
+				if (!target) return;
+				await callService("discuss.block", { id: discussion.id, task_id: target.id, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify(`"${discussion.title}" now blocks "${target.title}"`, "info");
 				return;
 			}
 			if (choice === "Unblock a task") {
-				const taskId = await commandCtx.ui.input("Task artifact id to unblock:", "");
-				if (!taskId) return;
-				const result = await callService<Record<string, unknown>, { unblocked: boolean }>("discuss.unblock", { id: discussion.id, task_id: taskId, actor: ACTOR, source: SOURCE });
-				commandCtx.ui.notify(result.unblocked ? `${discussion.id} no longer blocks ${taskId}` : "No such blocking relationship.", "info");
+				const blocked = await blockedTaskChoices(discussion.id);
+				if (blocked.length === 0) { commandCtx.ui.notify("This discussion isn't blocking any task.", "info"); return; }
+				const target = await pickTaskByName(commandCtx, "Unblock which task?", blocked);
+				if (!target) return;
+				const result = await callService<Record<string, unknown>, { unblocked: boolean }>("discuss.unblock", { id: discussion.id, task_id: target.id, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify(result.unblocked ? `"${discussion.title}" no longer blocks "${target.title}"` : "No such blocking relationship.", "info");
 			}
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "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

@@ -7,7 +7,7 @@ export const DAEMON_PROBE_TIMEOUT_MS = 800;
 export const DAEMON_UNIT_NAME = "papyrus.service";
 export const DAEMON_DIR_ENV = "PAPYRUS_DAEMON_DIR";
 export const SQLITE_BUSY_TIMEOUT_MS = 5_000;
-export const SQLITE_SCHEMA_VERSION = 16;
+export const SQLITE_SCHEMA_VERSION = 17;
 export const SERVICE_MAX_BODY_BYTES = 1_048_576;
 
 export const WAL_CHECKPOINT_INTERVAL_MS = 60_000;

package/src/db.ts

@@ -490,6 +490,20 @@ const FUTURE_MIGRATIONS: ReadonlyArray<PapyrusMigration> = [
 			}
 		},
 	},
+	{
+		version: 17,
+		name: "discussion-task-kind",
+		// See domain/discussion.ts for why. Status remaps the same loosely-followed way the
+		// doc column always worked: active/deferred -> in-progress, archived -> done.
+		up: (db) => {
+			db.exec(`
+				UPDATE artifacts SET kind = 'task', status = CASE status
+					WHEN 'archived' THEN 'done'
+					ELSE 'in-progress' END
+				WHERE kind = 'doc' AND subtype = 'discussion';
+			`);
+		},
+	},
 ];
 
 /**

package/src/discussion-service.ts

@@ -80,11 +80,11 @@ export class Discussions {
 		const posed = this.validatePosedOptions(input.options, input.optionsMode);
 		return this.artifacts.atomic(() => {
 			const discussion = this.artifacts.create({
-				kind: "doc",
+				kind: "task",
 				subtype: DISCUSSION_SUBTYPE,
 				title: input.title,
 				body: input.body ?? "",
-				status: "active",
+				status: "in-progress",
 				labels: input.labels,
 				extra: {
 					discussion: {
@@ -163,7 +163,7 @@ export class Discussions {
 				...discussion.extra,
 				discussion: { ...state, state: "settled", settlement: validSettlement, settledAt: new Date().toISOString() },
 			}, context)!;
-			return this.artifacts.setStatus(discussionId, "archived", context) ?? updated;
+			return this.artifacts.setStatus(discussionId, "done", context) ?? updated;
 		});
 	}
 
@@ -173,7 +173,7 @@ export class Discussions {
 		if (this.extra(discussion).state === "settled") throw new DiscussionError(`discussion "${discussionId}" is settled; it can no longer block anything`);
 		const task = this.artifacts.get(taskId);
 		if (!task) throw new DiscussionError(`task "${taskId}" not found`);
-		if (task.kind !== "task") throw new DiscussionError(`artifact "${taskId}" is not a task`);
+		if (task.kind !== "task" || isDiscussionArtifact(task)) throw new DiscussionError(`artifact "${taskId}" is not a task`);
 		this.artifacts.link({ from: discussionId, relation: "blocks", to: taskId }, context);
 	}
 
@@ -197,7 +197,7 @@ export class Discussions {
 		// (limit omitted) can never fall through to queryArtifacts' own unbounded default -- the same
 		// class of gap notes.ts's noteListInput comment documents fixing for Notes.
 		const limit = Math.min(DISCUSSION_LIST_MAX_LIMIT, Math.max(1, Math.floor(filter.limit ?? DISCUSSION_LIST_DEFAULT_LIMIT)));
-		const rows = this.artifacts.query({ kind: "doc", subtype: DISCUSSION_SUBTYPE, limit });
+		const rows = this.artifacts.query({ kind: "task", subtype: DISCUSSION_SUBTYPE, limit });
 		if (!filter.state) return rows;
 		return rows.filter((row) => {
 			try { return this.extra(row).state === filter.state; } catch { return false; }

package/src/domain/discussion.ts

@@ -2,12 +2,15 @@
  * Discuss: a native Papyrus deliberation with a real lifecycle, distinct from a one-shot
  * "ask" (see the design discussion this implements) and from Discourse's forum (kept fully
  * standalone by design -- no dependency here, Discuss reuses none of its storage or wire
- * shape). A Discussion is a `doc` artifact with subtype "discussion": real graph citizenship
- * (edges, show/list) without a fifth enforced artifact kind. Its fine-grained lifecycle
- * lives in extra.discussion rather than the shared doc status vocabulary, since Papyrus
- * enforces status per-kind, not per-subtype -- "deferred" has no equivalent among a plain
- * doc's draft/active/archived. The doc's own status column follows loosely: "active" while
- * extra.discussion.state is active or deferred, "archived" once settled.
+ * shape). A Discussion is a `task` artifact with subtype "discussion": not a passive
+ * record (see the blocking behavior below), so it takes the kind whose lifecycle, focus,
+ * and dependency-graph machinery are already built for unresolved work -- not a fifth
+ * enforced artifact kind. Its fine-grained lifecycle lives in
+ * extra.discussion rather than the shared task status vocabulary, since Papyrus enforces
+ * status per-kind, not per-subtype -- "deferred" has no equivalent among a plain task's
+ * todo/in-progress/review/done/rejected/canceled. The task's own status column follows
+ * loosely: "in-progress" while extra.discussion.state is active or deferred, "done" once
+ * settled.
  *
  * Blocking is the forcing, load-bearing behavior a Discussion adds over a passive record:
  * an "active" Discussion that `blocks` a Task refuses that Task's completion (see
@@ -126,7 +129,7 @@ export function validateSelectedOptions(selected: string[], pendingOptions: stri
 
 /** True for any artifact (already fetched) that is a Discussion, regardless of its current lifecycle state. */
 export function isDiscussionArtifact(artifact: { kind: string; subtype: string }): boolean {
-	return artifact.kind === "doc" && artifact.subtype === DISCUSSION_SUBTYPE;
+	return artifact.kind === "task" && artifact.subtype === DISCUSSION_SUBTYPE;
 }
 
 /** Reads and defensively validates the extra.discussion shape; throws on a corrupt/foreign shape rather than silently treating it as some default state. */

package/src/task-context.ts

@@ -1,4 +1,5 @@
 import type { Artifact } from "./domain/artifact.ts";
+import { DISCUSSION_SUBTYPE, readDiscussionExtra } from "./domain/discussion.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import {
 	TASK_CONTEXT_CURRENT_LIMIT,
@@ -34,22 +35,54 @@ function renderCurrent(task: Artifact): string[] {
 	];
 }
 
+/** Same scoping rule taskContext already applies to ordinary tasks, plus the focused task even if scope excludes it. */
+function inScope(taskId: string, activeTaskId: string | undefined, taskIds: Set<string> | undefined): boolean {
+	return taskIds === undefined || taskIds.has(taskId) || taskId === activeTaskId;
+}
+
+function deferredBlockingDiscussions(artifacts: ArtifactStore, activeTaskId: string | undefined, taskIds: Set<string> | undefined): string[] {
+	const discussions = artifacts.query({ kind: "task", subtype: DISCUSSION_SUBTYPE })
+		.filter((discussion) => {
+			try { return readDiscussionExtra(discussion.extra).state === "deferred"; } catch { return false; }
+		});
+	if (discussions.length === 0) return [];
+
+	const blocks = artifacts.relationships({ artifactIds: discussions.map((discussion) => discussion.id) })
+		.filter((edge) => edge.relation === "blocks");
+	const lines: string[] = [];
+	for (const discussion of discussions) {
+		for (const edge of blocks) {
+			if (edge.from !== discussion.id) continue;
+			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}"`);
+		}
+	}
+	return lines;
+}
+
 export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>): string | null {
-	const tasks = artifacts.query({ kind: "task" })
+	const tasks = artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE })
 		.filter((task) => taskIds === undefined || taskIds.has(task.id))
 		.sort((left, right) => left.updated_at.localeCompare(right.updated_at));
 	const open = tasks.filter((task) => task.status !== "done" && task.status !== "canceled");
-	if (open.length === 0) return null;
+	const deferredDiscussions = deferredBlockingDiscussions(artifacts, activeTaskId, taskIds);
+	if (open.length === 0 && deferredDiscussions.length === 0) return null;
 
 	const done = tasks.length - open.length;
 	const active = activeTaskId ? open.find((task) => task.id === activeTaskId) : undefined;
 	const current = active ? [active] : open.filter((task) => task.status === "in-progress" || task.status === "review").slice(0, TASK_CONTEXT_CURRENT_LIMIT);
 	const next = open.find((task) => task.status === "todo");
 	const rejected = open.filter((task) => task.status === "rejected").slice(0, TASK_CONTEXT_REJECTED_LIMIT);
-	const lines = [`Progress: ${done}/${tasks.length} done`];
+	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 (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}`);
+	}
 	lines.push("", TASK_RECONCILIATION_INSTRUCTION);
 	return lines.join("\n");
 }

package/src/task-service.ts

@@ -11,7 +11,7 @@ import {
 } from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
 import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
-import { isDiscussionArtifact, readDiscussionExtra } from "./domain/discussion.ts";
+import { DISCUSSION_SUBTYPE, isDiscussionArtifact, readDiscussionExtra } from "./domain/discussion.ts";
 import { validateGates, type Gate, type GateResult } from "./domain/gate.ts";
 import type { AppendTaskEvent, TaskEventContext, TaskHistoryPage, TaskHistoryQuery, TaskLifecycleStatus } from "./domain/task-event.ts";
 import { normalizeProjectRoot, taskScopeLabel, type TaskScopeSource, type TaskViewMode, type TaskViewSelection } from "./domain/task-scope.ts";
@@ -225,7 +225,7 @@ export class Tasks {
 			throw new Error(`task list limit must be between 1 and ${TASK_SCOPE_MAX_TASKS + 1}`);
 		}
 		if (selection.mode === "all") {
-			return this.artifacts.query({ kind: "task", status: filter.status, text: filter.text, limit });
+			return this.artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE, status: filter.status, text: filter.text, limit });
 		}
 		const ids = this.scopes.taskIds(selection.projectRoot, TASK_SCOPE_MAX_TASKS + 1);
 		if (ids.length > TASK_SCOPE_MAX_TASKS) throw new Error(`task project scope exceeds ${TASK_SCOPE_MAX_TASKS} tasks`);
@@ -233,7 +233,7 @@ export class Tasks {
 		const text = filter.text?.toLowerCase();
 		return [...selectedIds]
 			.map((id) => this.artifacts.get(id))
-			.filter((task): task is Artifact => task?.kind === "task")
+			.filter((task): task is Artifact => task?.kind === "task" && !isDiscussionArtifact(task))
 			.filter((task) => filter.status === undefined || task.status === filter.status)
 			.filter((task) => text === undefined || task.title.toLowerCase().includes(text) || task.body.toLowerCase().includes(text))
 			.sort((left, right) => right.updated_at.localeCompare(left.updated_at) || left.id.localeCompare(right.id))
@@ -404,8 +404,8 @@ export class Tasks {
 			const transition = TASK_TRANSITIONS[action];
 			if (!transition.from.includes(task.status as TaskStatus)) throw new Error(`cannot ${action} task from ${task.status}`);
 			if (action === "start") {
-				const blocking = this.dependencyIds(id).filter((dependencyId) => this.require(dependencyId).status !== "done");
-				if (blocking.length > 0) throw new Error(`task "${id}" is blocked by dependencies: ${blocking.join(", ")}`);
+				const blocking = this.dependencyIds(id).map((dependencyId) => this.require(dependencyId)).filter((dependency) => dependency.status !== "done");
+				if (blocking.length > 0) throw new Error(`task "${task.title}" is blocked by dependencies: ${blocking.map((dependency) => `"${dependency.title}"`).join(", ")}`);
 				this.focusStore.set(id, context.sessionId);
 			}
 			const updated = this.artifacts.setStatus(id, transition.to)!;
@@ -420,7 +420,7 @@ export class Tasks {
 
 	complete(id: string, context: TaskEventContext = {}, options: TaskCompletionOptions = {}): TaskCompletion {
 		const task = this.requireReview(id);
-		this.requireNotBlocked(id);
+		this.requireNotBlocked(task);
 		const attemptId = crypto.randomUUID();
 		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
 		const checklist = this.reviewChecklist(task);
@@ -430,7 +430,7 @@ export class Tasks {
 
 	async completeAsync(id: string, context: TaskEventContext = {}, options: TaskCompletionOptions = {}): Promise<TaskCompletion> {
 		const task = this.requireReview(id);
-		this.requireNotBlocked(id);
+		this.requireNotBlocked(task);
 		const attemptId = crypto.randomUUID();
 		this.events.atomic(() => this.appendEvent({ taskId: id, type: "completion_attempted", fromStatus: "review", toStatus: "review", attemptId }, context));
 		const checklist = this.reviewChecklist(task);
@@ -712,10 +712,10 @@ export class Tasks {
 			});
 	}
 
-	private requireNotBlocked(id: string): void {
-		const blockers = this.blockingDiscussions(id);
+	private requireNotBlocked(task: Artifact): void {
+		const blockers = this.blockingDiscussions(task.id);
 		if (blockers.length > 0) {
-			throw new Error(`task "${id}" is blocked by ${blockers.length} active Discussion(s): ${blockers.map((discussion) => discussion.id).join(", ")}`);
+			throw new Error(`task "${task.title}" is blocked by ${blockers.length} active Discussion(s): ${blockers.map((discussion) => `"${discussion.title}"`).join(", ")}`);
 		}
 	}
 }