@danypops/papyrus 0.6.0 → 0.7.0

package/README.md

@@ -103,7 +103,7 @@ Internally, application services depend on the `ArtifactStore` and `GateRunner`
 
 ## Interactive frontends
 
-- `/tasks` — task lifecycle, append-only history, gates, dependencies, and nested metadata
+- `/tasks` — project/focused-graph scope, task lifecycle, append-only history, gates, dependencies, and nested metadata
 - `/docs` — searchable documents, lifecycle, details, and graph links
 - `/rules` — severity/condition rows, exact injection preview, enable/disable, and task gating
 - `/skills` — trigger/tools rows, invocation into the editor, and artifact templates
@@ -114,7 +114,7 @@ All four use daemon-backed domain operations; none opens SQLite from the Pi proc
 
 Run `/tasks` for the interactive task panel:
 
-- `/` filters; arrow keys navigate; Enter opens task actions
+- `/` filters; arrow keys navigate; Enter opens task actions; `s` switches among the persisted current-project, focused-root graph, and explicit all-projects views
 - `g` opens the programmatic Unicode graph; Tab switches dependency/composition views and arrow keys pan
 - routed graph layouts are bounded to 48 nodes/96 edges; larger graphs use a deterministic, box-drawn line fallback, and renderer failures are contained inside the viewport rather than escaping Pi
 - advance the `todo → in-progress → review → done` lifecycle; failed review becomes `rejected`, retry returns to `in-progress`, and `canceled` is terminal
@@ -125,12 +125,17 @@ Run `/tasks` for the interactive task panel:
 - inspect deterministic execution layers, readiness, a box-drawn nested hierarchy, composition, dependencies, evidence-bearing checklists, and verification gates
 - lifecycle colors are semantic and redundant with text/glyphs: To-Do grey, in-progress yellow, review blue, rejected orange, done green, and canceled red; `▶` marks active focus
 - Show details keeps Checklist and Validation gates separate from incidental Metadata, renders bounded post-migration lifecycle history with actor/source/reason and gate evidence, then renders relationships as a Unicode box-drawing graph footer; `↑/↓` scrolls and `←/→` pans wide graphs
-- the compact persistent widget shows bounded open work in containment order and always retains the active focus
+- the compact persistent widget shows the current scope label plus bounded open work in containment order and always retains active focus when it belongs to that scope
 
 Authenticated CLI parity covers the changed lifecycle and focus operations:
 
 ```bash
 papyrus tasks graph --json
+papyrus tasks scope --json
+papyrus tasks scope project --json
+papyrus tasks scope graph <root-id> --json
+papyrus tasks scope all --json
+papyrus tasks assign-project <task-id> [project-root] --json
 papyrus tasks active --json
 papyrus tasks history <id> --json
 papyrus tasks focus <id> --json
@@ -197,10 +202,10 @@ packed install npm:@danypops/papyrus
 ~/.pi/agent/npm/node_modules/.bin/papyrus service install
 ```
 
-Existing databases are never migrated on daemon boot. After upgrading to append-only task history, run the authenticated CLI migration explicitly. A v1 database receives the lifecycle prerequisite and history schema in one transaction; existing tasks receive no fabricated events:
+Existing databases are never migrated on daemon boot. After upgrading to project-scoped task views, run the authenticated CLI migration explicitly. Older databases receive prerequisite schemas in one transaction. Existing Tasks are deliberately marked **unscoped**: Papyrus does not guess ownership from titles, labels, historical cwd, or repository names. They remain visible in **All projects** until explicitly assigned with `papyrus tasks assign-project <task-id> [project-root]`:
 
 ```bash
-~/.pi/agent/npm/node_modules/.bin/papyrus migrate task-history
+~/.pi/agent/npm/node_modules/.bin/papyrus migrate task-scope
 ```
 
 Until that command succeeds, health reports `migrationRequired` and normal domain operations are rejected with actionable guidance. Migration is not exposed as a Pi tool or MCP action. New empty databases bootstrap directly at the current schema.

package/extension/src/domain-tools.ts

@@ -31,7 +31,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, list, show, history, graph, plan, active, focus, start, submit, complete, reject, retry, cancel, run_gates, set_checklist, set_automation, depend, contain. Lifecycle is todo → in-progress → review → done, with review failure → rejected and retry → in-progress; canceled is terminal. Active focus is independent and identifies the one task auto-drive continues. Completion runs gates and checklist-proof review, then focuses one deterministic ready successor without claiming effort. Dependency cycles are rejected. Prefer this over low-level papyrus_* tools for task work.",
+		description: "Task domain tool. ACTIONS: create, list, show, history, scope, set_scope, assign_project, graph, plan, active, focus, start, submit, complete, reject, retry, cancel, run_gates, set_checklist, set_automation, depend, contain. Lifecycle is todo → in-progress → review → done, with review failure → rejected and retry → in-progress; canceled is terminal. Active focus is independent and identifies the one task auto-drive continues. Completion runs gates and checklist-proof review, then focuses one deterministic ready successor without claiming effort. Dependency cycles are rejected. Prefer this over low-level papyrus_* tools for task work.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -54,17 +54,20 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			child_id: Type.Optional(Type.String()),
 			dependency_id: Type.Optional(Type.String()),
 			depends_on: Type.Optional(Type.Array(Type.String())),
+			project_root: Type.Optional(Type.String()),
+			scope: Type.Optional(Type.Union([Type.Literal("project"), Type.Literal("graph"), Type.Literal("all")])),
+			root_task_id: Type.Optional(Type.String()),
 		}),
-		async execute(_id, params) {
+		async execute(_id, params, _signal, _onUpdate, ctx) {
 			try {
 				const action = params.action;
-				const request = { ...params, actor: "agent", source: "pi-tool" };
+				const request = { ...params, project_root: params.project_root ?? ctx.cwd, actor: "agent", source: "pi-tool" };
 				if (action === "create") {
 					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", request);
 					return text(`Created task ${artifactLine(artifact)}`, { artifact });
 				}
 				if (action === "list") {
-					const rows = await callService<Record<string, unknown>, Artifact[]>("tasks.list", params);
+					const rows = await callService<Record<string, unknown>, Artifact[]>("tasks.list", request);
 					return text(rows.length ? rows.map(artifactLine).join("\n") : "No tasks found.", { rows });
 				}
 				if (action === "show") {
@@ -76,18 +79,22 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					const lines = page.events.map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`);
 					return text(lines.join("\n") || "No recorded history for this task.", { page });
 				}
+				if (action === "scope") {
+					const selection = await callService<Record<string, unknown>, import("../../src/domain/task-scope.ts").TaskViewSelection>("tasks.scope", request);
+					return text(`Task scope: ${selection.label}`, { selection });
+				}
 				if (action === "active") {
-					const artifact = await callService<Record<string, unknown>, Artifact | null>("tasks.active", params);
+					const artifact = await callService<Record<string, unknown>, Artifact | null>("tasks.active", request);
 					return text(artifact ? `Active: ${artifactLine(artifact)}` : "No active task.", { artifact });
 				}
 				if (action === "graph") {
-					const graph = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", params);
+					const graph = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", request);
 					const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
 					const containment = graph.nodes.reduce((count, node) => count + node.childIds.length, 0);
 					return text(`Task graph: ${graph.nodes.length} nodes, ${graph.rootIds.length} roots, ${dependencies} dependencies, ${containment} containment edges.`, { graph });
 				}
 				if (action === "plan") {
-					const plan = await callService<Record<string, unknown>, TaskExecutionPlan>("tasks.plan", params);
+					const plan = await callService<Record<string, unknown>, TaskExecutionPlan>("tasks.plan", request);
 					const byId = new Map(plan.nodes.map((node) => [node.id, node]));
 					const lines = plan.layers.flatMap((layer, index) => [
 						`Layer ${index + 1}`,
@@ -124,6 +131,8 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					reject: "tasks.reject",
 					retry: "tasks.retry",
 					cancel: "tasks.cancel",
+					set_scope: "tasks.set_scope",
+					assign_project: "tasks.assign_project",
 					set_automation: "tasks.set_automation",
 					depend: "tasks.depend",
 					contain: "tasks.contain",
@@ -234,10 +243,12 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			text: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()), template_id: Type.Optional(Type.String()),
 			target_kind: Type.Optional(Type.String()), defaults: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 			required: Type.Optional(Type.Array(Type.String())), kind: Type.Optional(Type.String()), subtype: Type.Optional(Type.String()),
+			project_root: Type.Optional(Type.String()),
 		}),
-		async execute(_id, params) {
+		async execute(_id, params, _signal, _onUpdate, ctx) {
 			try {
 				const action = params.action;
+				const request = { ...params, project_root: params.project_root ?? ctx.cwd };
 				if (action === "create" || action === "create_template") {
 					const operation = action === "create" ? "skills.create" : "skills.create_template";
 					const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
@@ -252,7 +263,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					return text(invocation, { invocation });
 				}
 				if (action === "run") {
-					const run = await callService<Record<string, unknown>, SkillWorkflowRunResult>("skills.run", params);
+					const run = await callService<Record<string, unknown>, SkillWorkflowRunResult>("skills.run", request);
 					const execution = run.execution.nodes.map((node) => `  [${node.state}] ${node.id} ${node.title}`).join("\n");
 					return text([
 						`Created Skill run ${run.runId}: ${run.created.tasks.length} tasks, ${run.created.rules.length} rules, ${run.created.docs.length} docs.`,
@@ -265,7 +276,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				const operations = { show: "skills.show", enable: "skills.enable", disable: "skills.disable", instantiate: "skills.instantiate" } as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) return text(`Unknown skills action: ${action}`);
-				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
+				const artifact = await callService<Record<string, unknown>, Artifact>(operation, action === "instantiate" ? request : params);
 				return text(`${artifactLine(artifact)}${action === "show" ? `\n\n${artifact.body}` : ""}`, { artifact });
 			} catch (error) {
 				return text(`skills failed: ${error instanceof Error ? error.message : error}`);

package/extension/src/index.ts

@@ -36,7 +36,7 @@ const WIDGET_KEY = "pi-papyrus";
 
 export function renderTaskWidgetLines(theme: Theme, projection: TaskWidgetProjection, width: number): string[] {
 	if (projection.openTotal === 0) return [];
-	const lines: string[] = [];
+	const lines: string[] = [theme.fg("muted", `Tasks · ${projection.scopeLabel}`)];
 	for (let index = 0; index < projection.rows.length; index++) {
 		const row = projection.rows[index]!;
 		const laterSibling = projection.rows.slice(index + 1).some((candidate) => candidate.depth === row.depth);
@@ -54,6 +54,7 @@ class TaskOverlay {
 	private registered = false;
 	private tui: any | undefined;
 	private snapshot: TaskGraph = { nodes: [], rootIds: [] };
+	private projectRoot: string | undefined;
 
 	setUI(ctx: ExtensionUIContext): void {
 		if (ctx !== this.uiCtx) {
@@ -63,9 +64,12 @@ class TaskOverlay {
 		}
 	}
 
+	setProjectRoot(projectRoot: string): void { this.projectRoot = projectRoot; }
+
 	async refresh(): Promise<void> {
+		if (!this.projectRoot) return;
 		try {
-			this.snapshot = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", { limit: 500 });
+			this.snapshot = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", { limit: 500, project_root: this.projectRoot });
 		} catch {
 			this.snapshot = { nodes: [], rootIds: [] };
 		}
@@ -116,6 +120,7 @@ class TaskOverlay {
 		this.registered = false;
 		this.tui = undefined;
 		this.uiCtx = undefined;
+		this.projectRoot = undefined;
 	}
 }
 
@@ -133,7 +138,7 @@ export default async function (pi: ExtensionAPI) {
 	const driveActiveTasks = async (ctx: ExtensionContext): Promise<void> => {
 		if (ctx.mode !== "tui" && ctx.mode !== "rpc") return;
 		try {
-			const active = await callService<Record<string, never>, ActiveTaskMarker | null>("tasks.active", {});
+			const active = await callService<Record<string, unknown>, ActiveTaskMarker | null>("tasks.active", { project_root: ctx.cwd });
 			const decision = taskContinuation.evaluate(active, {
 				idle: ctx.isIdle(),
 				pendingMessages: ctx.hasPendingMessages(),
@@ -174,10 +179,14 @@ export default async function (pi: ExtensionAPI) {
 			labels: Type.Optional(Type.Array(Type.String())),
 			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 			template_id: Type.Optional(Type.String({ description: "skill/artifact-template id whose defaults and requirements apply" })),
+			project_root: Type.Optional(Type.String({ description: "required for Tasks; defaults to Pi cwd" })),
 		}),
-		async execute(_id, params, _signal, _onUpdate, _ctx) {
+		async execute(_id, params, _signal, _onUpdate, ctx) {
 			try {
-				const a = await callService<Record<string, unknown>, Artifact>("artifact.create", params);
+				const a = await callService<Record<string, unknown>, Artifact>("artifact.create", {
+					...params,
+					...(params.kind === "task" ? { project_root: params.project_root ?? ctx.cwd } : {}),
+				});
 				return text(`Created ${a.id} [${a.kind}|${a.status}] ${a.title}`, { id: a.id });
 			} catch (e) {
 				return text(`papyrus_create failed: ${e instanceof Error ? e.message : e}`);
@@ -309,6 +318,7 @@ export default async function (pi: ExtensionAPI) {
 	pi.registerCommand("tasks", {
 		description: "Browse and manage Papyrus tasks (interactive)",
 		handler: async (_args, ctx) => {
+			overlay?.setProjectRoot(ctx.cwd);
 			await tasksModule.showTasks(ctx);
 			await overlay?.refresh();
 		},
@@ -332,6 +342,7 @@ export default async function (pi: ExtensionAPI) {
 		if (!ctx.hasUI) return;
 		overlay ??= new TaskOverlay();
 		overlay.setUI(ctx.ui);
+		overlay.setProjectRoot(ctx.cwd);
 		await overlay.refresh();
 	});
 
@@ -360,11 +371,11 @@ export default async function (pi: ExtensionAPI) {
 	// The agent sees its open work items every turn. If there are rejected
 	// tasks, they're explicitly called out — the agent should address them.
 
-	pi.on("before_agent_start", async (event, _ctx) => {
+	pi.on("before_agent_start", async (event, ctx) => {
 		try {
 			const [rules, summary] = await Promise.all([
-				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "body" | "extra">>>("rules.injectable", {}),
-				callService<Record<string, unknown>, string | null>("tasks.context", {}),
+				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd }),
+				callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd }),
 			]);
 			let prompt = event.systemPrompt ?? "";
 			if (rules.length > 0) {

package/extension/src/skills.ts

@@ -93,6 +93,7 @@ export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
 					const run = await callService<Record<string, unknown>, SkillWorkflowRunResult>("skills.run", {
 						id: skill.id,
 						arguments: arguments_ as Record<string, unknown>,
+						project_root: commandCtx.cwd,
 					});
 					commandCtx.ui.notify([
 						`Created ${run.runId} · ${run.created.tasks.length} tasks · ${run.rootTaskIds.length} ready roots`,

package/extension/src/task-widget.ts

@@ -13,6 +13,7 @@ export interface TaskWidgetProjection {
 	rows: TaskWidgetRow[];
 	openTotal: number;
 	total: number;
+	scopeLabel: string;
 }
 
 function isOpen(task: Artifact): boolean {
@@ -52,5 +53,5 @@ export function buildTaskWidgetProjection(
 		rows = [...rows.slice(0, Math.max(0, limit - 1)), active]
 			.sort((left, right) => ordered.indexOf(left) - ordered.indexOf(right));
 	}
-	return { rows, openTotal: ordered.length, total: graph.nodes.length };
+	return { rows, openTotal: ordered.length, total: graph.nodes.length, scopeLabel: graph.scope?.label ?? "All projects" };
 }

package/extension/src/tasks.ts

@@ -62,8 +62,13 @@ export function buildTaskHierarchy(graph: TaskGraph): TaskHierarchyRow[] {
 	return result;
 }
 
-async function loadTaskGraph(): Promise<TaskGraph> {
-	return callService<Record<string, unknown>, TaskGraph>("tasks.graph", { limit: 200 });
+async function loadTaskGraph(projectRoot: string, scope?: "project" | "graph" | "all", rootTaskId?: string): Promise<TaskGraph> {
+	return callService<Record<string, unknown>, TaskGraph>("tasks.graph", {
+		limit: 200,
+		project_root: projectRoot,
+		...(scope ? { scope } : {}),
+		...(rootTaskId ? { root_task_id: rootTaskId } : {}),
+	});
 }
 
 export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
@@ -71,14 +76,14 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		ctx.ui.notify("/tasks requires interactive mode", "warning");
 		return;
 	}
-	let graph = await loadTaskGraph();
+	let graph = await loadTaskGraph(ctx.cwd);
 	if (graph.nodes.length === 0) {
 		const create = await ctx.ui.select("No tasks yet", ["Create a task", "Cancel"]);
 		if (create === "Create a task") {
 			const title = await ctx.ui.input("Task title:", "");
 			if (title) {
-				await callService("tasks.create", { title, actor: "user", source: "tasks-tui" });
-				graph = await loadTaskGraph();
+				await callService("tasks.create", { title, project_root: ctx.cwd, actor: "user", source: "tasks-tui" });
+				graph = await loadTaskGraph(ctx.cwd);
 			}
 		}
 		if (graph.nodes.length === 0) return;
@@ -87,7 +92,24 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 	for (;;) {
 		const action = await renderPanel(ctx, graph);
 		if (!action) return;
-		if (action.type === "refresh") { graph = await loadTaskGraph(); continue; }
+		if (action.type === "refresh") { graph = await loadTaskGraph(ctx.cwd); continue; }
+		if (action.type === "scope") {
+			const choice = await ctx.ui.select("Task scope", ["Current project", "Focused graph", "All projects"]);
+			if (!choice) continue;
+			const scope: "project" | "graph" | "all" = choice === "Current project" ? "project" : choice === "All projects" ? "all" : "graph";
+			let rootTaskId: string | undefined;
+			if (scope === "graph") {
+				const projectGraph = await loadTaskGraph(ctx.cwd, "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}`));
+				if (!selected) continue;
+				rootTaskId = roots.find((task) => `${task.title} · ${task.id}` === selected)?.id;
+				if (!rootTaskId) continue;
+			}
+			await callService("tasks.set_scope", { project_root: ctx.cwd, scope, ...(rootTaskId ? { root_task_id: rootTaskId } : {}) });
+			graph = await loadTaskGraph(ctx.cwd);
+			continue;
+		}
 		if (action.type === "graph") { await showTaskGraph(ctx, graph); continue; }
 		if (action.type !== "action" || !action.row) continue;
 
@@ -173,12 +195,12 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 				ctx.ui.notify(`Task action failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
 		}
-		graph = await loadTaskGraph();
+		graph = await loadTaskGraph(ctx.cwd);
 	}
 }
 
 interface PanelAction {
-	type: "action" | "refresh" | "graph";
+	type: "action" | "refresh" | "graph" | "scope";
 	row?: TaskRow;
 }
 
@@ -218,7 +240,7 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 		const header = {
 			invalidate() {},
 			render(width: number): string[] {
-				const title = theme.bold("Tasks");
+				const title = theme.bold(`Tasks · ${graph.scope?.label ?? "scope unavailable"}`);
 				const hint = searchActive
 					? rawKeyHint("esc", "clear")
 					: rawKeyHint("↑/↓", "navigate") +
@@ -229,6 +251,8 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 						theme.fg("muted", " · ") +
 						rawKeyHint("g", "graph") +
 						theme.fg("muted", " · ") +
+						rawKeyHint("s", "scope") +
+						theme.fg("muted", " · ") +
 						rawKeyHint("r", "refresh") +
 						theme.fg("muted", " · ") +
 						rawKeyHint("esc", "close");
@@ -322,6 +346,7 @@ function renderPanel(ctx: ExtensionCommandContext, graph: TaskGraph): Promise<Pa
 				else if (matchesKey(data, "down")) selectedIndex = (selectedIndex + 1) % Math.max(filtered.length, 1);
 				else if (data === "/") searchActive = true;
 				else if (data === "g") { done({ type: "graph" }); return; }
+				else if (data === "s") { done({ type: "scope" }); return; }
 				else if (data === "r") { done({ type: "refresh" }); return; }
 				else if (matchesKey(data, "enter")) {
 					const entry = filtered[selectedIndex];

package/package.json

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

package/src/adapters/sqlite-task-scope-store.ts

@@ -0,0 +1,59 @@
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { TaskProjectScope, TaskScopeSource, TaskViewMode, TaskViewPreference } from "../domain/task-scope.ts";
+import type { TaskScopeStore } from "../ports/task-scope-store.ts";
+
+export class SQLiteTaskScopeStore implements TaskScopeStore {
+	constructor(private readonly db: Db) {}
+
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_scopes (task_id, project_root, source, assigned_at)
+				VALUES (?, ?, ?, ?)
+				ON CONFLICT(task_id) DO UPDATE SET
+					project_root = excluded.project_root,
+					source = excluded.source,
+					assigned_at = excluded.assigned_at
+			`).run(taskId, projectRoot ?? null, source, new Date().toISOString());
+		});
+		return { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
+	}
+
+	get(taskId: string): TaskProjectScope | undefined {
+		const row = this.db.prepare("SELECT task_id, project_root, source FROM task_scopes WHERE task_id = ?").get(taskId) as
+			| { task_id: string; project_root: string | null; source: TaskScopeSource }
+			| null;
+		return row ? { taskId: row.task_id, ...(row.project_root === null ? {} : { projectRoot: row.project_root }), source: row.source } : undefined;
+	}
+
+	taskIds(projectRoot: string | undefined, limit: number): string[] {
+		const rows = projectRoot === undefined
+			? this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root IS NULL ORDER BY task_id LIMIT ?").all(limit)
+			: this.db.prepare("SELECT task_id FROM task_scopes WHERE project_root = ? ORDER BY task_id LIMIT ?").all(projectRoot, limit);
+		return (rows as Array<{ task_id: string }>).map((row) => row.task_id);
+	}
+
+	view(projectRoot: string): TaskViewPreference {
+		const row = this.db.prepare("SELECT project_root, mode, root_task_id FROM task_views WHERE project_root = ?").get(projectRoot) as
+			| { project_root: string; mode: TaskViewMode; root_task_id: string | null }
+			| null;
+		return row
+			? { projectRoot: row.project_root, mode: row.mode, ...(row.root_task_id === null ? {} : { rootTaskId: row.root_task_id }) }
+			: { projectRoot, mode: "project" };
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_views (project_root, mode, root_task_id, updated_at)
+				VALUES (?, ?, ?, ?)
+				ON CONFLICT(project_root) DO UPDATE SET
+					mode = excluded.mode,
+					root_task_id = excluded.root_task_id,
+					updated_at = excluded.updated_at
+			`).run(projectRoot, mode, rootTaskId ?? null, new Date().toISOString());
+		});
+		return { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
+	}
+}

package/src/cli.ts

@@ -57,13 +57,15 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
-  papyrus migrate task-history [--json]
+  papyrus migrate task-scope [--json]
   papyrus automation <status|run> [--json]
   papyrus skills run <id> [--arguments-json <json>] [--run-id <id>] [--json]
   papyrus tasks plan [--json]
   papyrus tasks graph [--json]
   papyrus tasks active [--json]
   papyrus tasks history <id> [--json]
+  papyrus tasks scope [project|all|graph <root-id>] [--json]
+  papyrus tasks assign-project <id> [project-root] [--json]
   papyrus tasks focus <id> [--json]
   papyrus tasks complete <id> [--json]
   papyrus tasks start <id> [--json]
@@ -110,8 +112,8 @@ function planText(plan: TaskExecutionPlan): string {
 export async function runMigrationCli(args: string[], client: TaskCliClient): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
-	if (positional.length !== 1 || positional[0] !== "task-history") {
-		throw new Error("migrate requires exactly `task-history`");
+	if (positional.length !== 1 || positional[0] !== "task-scope") {
+		throw new Error("migrate requires exactly `task-scope`");
 	}
 	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
 	if (json) return JSON.stringify(result);
@@ -133,7 +135,7 @@ export async function runAutomationCli(args: string[], client: TaskCliClient): P
 	return json ? JSON.stringify(result) : `Automation sweep: ${result.examined} examined · ${result.completed} completed · ${result.rejected} rejected · ${result.started} started · ${result.errors.length} errors${result.skipped ? ` · skipped ${result.skipped}` : ""}`;
 }
 
-export async function runSkillCli(args: string[], client: TaskCliClient): Promise<string> {
+export async function runSkillCli(args: string[], client: TaskCliClient, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional: string[] = [];
 	let runId: string | undefined;
@@ -160,7 +162,7 @@ export async function runSkillCli(args: string[], client: TaskCliClient): Promis
 		positional.push(argument);
 	}
 	if (positional.length !== 2 || positional[0] !== "run") throw new Error("skills requires `run <id>`");
-	const input: Record<string, unknown> = { id: positional[1], arguments: arguments_ };
+	const input: Record<string, unknown> = { id: positional[1], arguments: arguments_, project_root: projectRoot };
 	if (runId) input["run_id"] = runId;
 	const result = await client.call<Record<string, unknown>, {
 		runId: string;
@@ -178,7 +180,7 @@ export async function runSkillCli(args: string[], client: TaskCliClient): Promis
 	].join("\n");
 }
 
-export async function runTaskCli(args: string[], client: TaskCliClient): Promise<string> {
+export async function runTaskCli(args: string[], client: TaskCliClient, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional = args.filter((arg) => arg !== "--json");
 	const [action, id, dependencyId] = positional;
@@ -187,7 +189,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 	switch (action) {
 		case "active": {
 			if (id) throw new Error("tasks active accepts no positional arguments");
-			const active = await client.call<Record<string, never>, CliArtifact | null>("tasks.active", {});
+			const active = await client.call<Record<string, string>, CliArtifact | null>("tasks.active", { project_root: projectRoot });
 			result = active;
 			human = active ? `Active: ${artifactLabel(active)}` : "No active task.";
 			break;
@@ -201,6 +203,37 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 				: [...page.events].reverse().map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`).join("\n");
 			break;
 		}
+		case "scope": {
+			if (!id) {
+				const selection = await client.call<Record<string, string>, import("./domain/task-scope.ts").TaskViewSelection>("tasks.scope", { project_root: projectRoot });
+				result = selection;
+				human = `Task scope: ${selection.label}`;
+				break;
+			}
+			if (id !== "project" && id !== "all" && id !== "graph") throw new Error("tasks scope mode must be project, all, or graph");
+			if (id === "graph" && !dependencyId) throw new Error("tasks scope graph requires a root task id");
+			if (id !== "graph" && dependencyId) throw new Error(`tasks scope ${id} accepts no root task id`);
+			const selection = await client.call<Record<string, unknown>, import("./domain/task-scope.ts").TaskViewSelection>("tasks.set_scope", {
+				project_root: projectRoot,
+				scope: id,
+				...(dependencyId ? { root_task_id: dependencyId } : {}),
+			});
+			result = selection;
+			human = `Task scope: ${selection.label}`;
+			break;
+		}
+		case "assign-project": {
+			if (!id || positional.length > 3) throw new Error("tasks assign-project requires a task id and optional project root");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.assign_project", {
+				id,
+				project_root: dependencyId ?? projectRoot,
+				actor: "user",
+				source: "cli",
+			});
+			result = artifact;
+			human = `Project assigned: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "focus": {
 			if (!id || dependencyId) throw new Error("tasks focus requires exactly one task id");
 			const active = await client.call<{ id: string }, CliArtifact>("tasks.focus", { id });
@@ -210,10 +243,10 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "graph": {
 			if (id) throw new Error("tasks graph accepts no positional arguments");
-			const graph = await client.call<{ limit: number }, {
+			const graph = await client.call<{ limit: number; project_root: string }, {
 				nodes: Array<{ dependencyIds: string[]; childIds: string[] }>;
 				rootIds: string[];
-			}>("tasks.graph", { limit: TASK_EXECUTION_MAX_NODES + 1 });
+			}>("tasks.graph", { limit: TASK_EXECUTION_MAX_NODES + 1, project_root: projectRoot });
 			result = graph;
 			const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
 			const children = graph.nodes.reduce((count, node) => count + node.childIds.length, 0);
@@ -222,7 +255,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 		}
 		case "plan": {
 			if (id) throw new Error("tasks plan accepts no positional arguments");
-			const plan = await client.call<Record<string, never>, TaskExecutionPlan>("tasks.plan", {});
+			const plan = await client.call<Record<string, string>, TaskExecutionPlan>("tasks.plan", { project_root: projectRoot });
 			result = plan;
 			human = planText(plan);
 			break;
@@ -281,7 +314,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient): Promise
 			break;
 		}
 		default:
-			throw new Error("tasks action must be active, focus, graph, plan, history, complete, start, submit, reject, retry, cancel, automate, or depend");
+			throw new Error("tasks action must be active, focus, graph, plan, history, scope, assign-project, complete, start, submit, reject, retry, cancel, automate, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }

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 = 3;
+export const SQLITE_SCHEMA_VERSION = 4;
 export const SERVICE_MAX_BODY_BYTES = 1_048_576;
 export const WAL_CHECKPOINT_INTERVAL_MS = 60_000;
 export const DB_OPTIMIZE_INTERVAL_MS = 24 * 60 * 60_000;
@@ -62,6 +62,9 @@ export const TASK_AUTOMATION_HARD_MAX_RUNTIME_MS = 600_000;
 export const TASK_AUTOMATION_MAX_CANDIDATE_SCAN = 1_000;
 export const TASK_AUTOMATION_ERROR_ID_MAX_LENGTH = 128;
 export const TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH = 500;
+/** Persisted project and focused-graph Task view bounds. */
+export const TASK_SCOPE_MAX_TASKS = 1_000;
+export const TASK_PROJECT_ROOT_MAX_LENGTH = 4_096;
 export const GRAPH_RENDER_PADDING_X = 2;
 export const GRAPH_RENDER_PADDING_Y = 1;
 export const GRAPH_RENDER_BOX_PADDING = 0;

package/src/db.ts

@@ -122,6 +122,20 @@ CREATE TRIGGER IF NOT EXISTS task_events_no_update BEFORE UPDATE ON task_events
 BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
 CREATE TRIGGER IF NOT EXISTS task_events_no_delete BEFORE DELETE ON task_events
 BEGIN SELECT RAISE(ABORT, 'task_events are append-only'); END;
+CREATE TABLE IF NOT EXISTS task_scopes (
+	task_id       TEXT PRIMARY KEY REFERENCES artifacts(id),
+	project_root  TEXT,
+	source        TEXT NOT NULL CHECK (source IN ('cwd', 'explicit', 'unscoped')),
+	assigned_at   TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS task_scopes_project_idx ON task_scopes(project_root, task_id);
+CREATE TABLE IF NOT EXISTS task_views (
+	project_root  TEXT PRIMARY KEY,
+	mode          TEXT NOT NULL CHECK (mode IN ('project', 'graph', 'all')),
+	root_task_id  TEXT REFERENCES artifacts(id),
+	updated_at    TEXT NOT NULL,
+	CHECK ((mode = 'graph' AND root_task_id IS NOT NULL) OR (mode != 'graph' AND root_task_id IS NULL))
+);
 `;
 
 const SEED_SQL = `
@@ -185,7 +199,7 @@ export function migrateDb(db: Db): MigrationResult {
 		throw new Error(`database schema ${from} is newer than supported ${SQLITE_SCHEMA_VERSION}`);
 	}
 	if (from === SQLITE_SCHEMA_VERSION) return { from, to: from, applied: [] };
-	if (from !== 1 && from !== 2) throw new Error(`no explicit migration path from database schema ${from}`);
+	if (from !== 1 && from !== 2 && from !== 3) throw new Error(`no explicit migration path from database schema ${from}`);
 	const applied: string[] = [];
 
 	inTransaction(db, () => {
@@ -243,6 +257,29 @@ export function migrateDb(db: Db): MigrationResult {
 			`);
 			applied.push("task-history");
 		}
+		if (schemaVersion(db) === 3) {
+			db.exec(`
+				CREATE TABLE task_scopes (
+					task_id TEXT PRIMARY KEY REFERENCES artifacts(id),
+					project_root TEXT,
+					source TEXT NOT NULL CHECK (source IN ('cwd', 'explicit', 'unscoped')),
+					assigned_at TEXT NOT NULL
+				);
+				CREATE INDEX task_scopes_project_idx ON task_scopes(project_root, task_id);
+				CREATE TABLE task_views (
+					project_root TEXT PRIMARY KEY,
+					mode TEXT NOT NULL CHECK (mode IN ('project', 'graph', 'all')),
+					root_task_id TEXT REFERENCES artifacts(id),
+					updated_at TEXT NOT NULL,
+					CHECK ((mode = 'graph' AND root_task_id IS NOT NULL) OR (mode != 'graph' AND root_task_id IS NULL))
+				);
+				INSERT INTO task_scopes (task_id, project_root, source, assigned_at)
+				SELECT id, NULL, 'unscoped', strftime('%Y-%m-%dT%H:%M:%fZ','now')
+				FROM artifacts WHERE kind = 'task';
+				PRAGMA user_version = 4;
+			`);
+			applied.push("task-project-scope");
+		}
 	});
 	return { from, to: schemaVersion(db), applied };
 }

package/src/domain/task-event.ts

@@ -15,6 +15,7 @@ export const TASK_EVENT_TYPES = [
 	"gates_evaluated",
 	"automation_enabled",
 	"automation_disabled",
+	"project_assigned",
 	"review_rejected",
 	"retried",
 	"completed",

package/src/domain/task-scope.ts

@@ -0,0 +1,39 @@
+import { basename, isAbsolute, normalize } from "node:path";
+import { TASK_PROJECT_ROOT_MAX_LENGTH } from "../constants.ts";
+
+export type TaskViewMode = "project" | "graph" | "all";
+export type TaskScopeSource = "cwd" | "explicit" | "unscoped";
+
+export interface TaskProjectScope {
+	taskId: string;
+	projectRoot?: string;
+	source: TaskScopeSource;
+}
+
+export interface TaskViewPreference {
+	projectRoot: string;
+	mode: TaskViewMode;
+	rootTaskId?: string;
+}
+
+export interface TaskViewSelection {
+	mode: TaskViewMode;
+	label: string;
+	projectRoot?: string;
+	rootTaskId?: string;
+}
+
+export function normalizeProjectRoot(value: string): string {
+	if (!isAbsolute(value)) throw new Error("project_root must be an absolute path");
+	const normalized = normalize(value);
+	if (normalized.length > TASK_PROJECT_ROOT_MAX_LENGTH) {
+		throw new Error(`project_root cannot exceed ${TASK_PROJECT_ROOT_MAX_LENGTH} characters`);
+	}
+	return normalized;
+}
+
+export function taskScopeLabel(mode: TaskViewMode, projectRoot?: string, rootTitle?: string): string {
+	if (mode === "all") return "All projects";
+	const project = projectRoot ? basename(projectRoot) || projectRoot : "Unscoped";
+	return mode === "graph" ? `${project} · ${rootTitle ?? "focused graph"}` : project;
+}

package/src/ports/task-scope-store.ts

@@ -0,0 +1,40 @@
+import type { TaskProjectScope, TaskScopeSource, TaskViewMode, TaskViewPreference } from "../domain/task-scope.ts";
+
+export interface TaskScopeStore {
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope;
+	get(taskId: string): TaskProjectScope | undefined;
+	taskIds(projectRoot: string | undefined, limit: number): string[];
+	view(projectRoot: string): TaskViewPreference;
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference;
+}
+
+export class InMemoryTaskScopeStore implements TaskScopeStore {
+	private readonly scopes = new Map<string, TaskProjectScope>();
+	private readonly views = new Map<string, TaskViewPreference>();
+
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
+		const scope = { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
+		this.scopes.set(taskId, scope);
+		return scope;
+	}
+
+	get(taskId: string): TaskProjectScope | undefined { return this.scopes.get(taskId); }
+
+	taskIds(projectRoot: string | undefined, limit: number): string[] {
+		return [...this.scopes.values()]
+			.filter((scope) => scope.projectRoot === projectRoot)
+			.map((scope) => scope.taskId)
+			.sort()
+			.slice(0, limit);
+	}
+
+	view(projectRoot: string): TaskViewPreference {
+		return this.views.get(projectRoot) ?? { projectRoot, mode: "project" };
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
+		const view = { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
+		this.views.set(projectRoot, view);
+		return view;
+	}
+}

package/src/service.ts

@@ -5,12 +5,15 @@ import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
 import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
 import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
+import { SQLiteTaskScopeStore } from "./adapters/sqlite-task-scope-store.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
 import type { Checklist } from "./domain/checklist.ts";
 import type { TaskEventContext, TaskEventDirection } from "./domain/task-event.ts";
+import type { TaskViewMode } from "./domain/task-scope.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
 import type { TaskEventStore } from "./ports/task-event-store.ts";
+import type { TaskScopeStore } from "./ports/task-scope-store.ts";
 import { projectTaskExecution } from "./task-execution.ts";
 import { Tasks, type TaskStatus } from "./task-service.ts";
 import { TaskAutomationReconciler, taskAutomationSettings, type TaskAutomationSettings } from "./task-automation.ts";
@@ -57,6 +60,9 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.plan",
 	"tasks.show",
 	"tasks.history",
+	"tasks.scope",
+	"tasks.set_scope",
+	"tasks.assign_project",
 	"tasks.active",
 	"tasks.focus",
 	"tasks.start",
@@ -150,6 +156,7 @@ function handlers(
 	tasks: Tasks,
 	automation: TaskAutomationReconciler,
 	events: TaskEventStore,
+	scopes: TaskScopeStore,
 	migrate: () => unknown,
 ): Record<OperationName, OperationHandler> {
 	const eventContext = (input: OperationInput): TaskEventContext => ({
@@ -166,6 +173,9 @@ function handlers(
 		status: optionalString(input, "status"),
 		text: optionalString(input, "text"),
 		limit: optionalNumber(input, "limit"),
+		projectRoot: string(input, "project_root"),
+		scope: optionalString(input, "scope") as TaskViewMode | undefined,
+		rootTaskId: optionalString(input, "root_task_id"),
 	});
 	return {
 		"system.migrate": () => migrate(),
@@ -183,6 +193,8 @@ function handlers(
 				labels: normalized.labels,
 				extra: normalized.extra,
 				templateId: normalized.templateId,
+				projectRoot: string(input, "project_root"),
+				projectSource: "cwd",
 			}, eventContextFor(input, "artifact-api"));
 		},
 		"artifact.query": (input) => artifacts.query(input),
@@ -218,7 +230,7 @@ function handlers(
 				? tasks.runGates(id, eventContextFor(input, "gates-api"))
 				: gates.runAsync(id);
 		},
-		"rules.injectable": () => listInjectableRules(artifacts, tasks.active()?.id)
+		"rules.injectable": (input) => listInjectableRules(artifacts, tasks.active(taskFilter(input))?.id)
 			.map(({ id, title, body, extra }) => ({ id, title, body, extra })),
 		"tasks.create": (input) => tasks.create({
 			title: string(input, "title"),
@@ -231,6 +243,8 @@ function handlers(
 			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
 			parentId: optionalString(input, "parent_id") ?? optionalString(input, "parentId"),
 			dependsOn: (input["depends_on"] ?? input["dependsOn"]) as string[] | undefined,
+			projectRoot: string(input, "project_root"),
+			projectSource: "cwd",
 		}, eventContext(input)),
 		"tasks.list": (input) => tasks.list(taskFilter(input)),
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
@@ -241,7 +255,18 @@ function handlers(
 			cursor: optionalNumber(input, "cursor"),
 			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
 		}),
-		"tasks.active": () => tasks.active(),
+		"tasks.scope": (input) => tasks.scopeSelection(string(input, "project_root")),
+		"tasks.set_scope": (input) => tasks.setView(
+			string(input, "project_root"),
+			string(input, "scope") as TaskViewMode,
+			optionalString(input, "root_task_id"),
+		),
+		"tasks.assign_project": (input) => tasks.assignProject(
+			string(input, "id"),
+			string(input, "project_root"),
+			eventContext(input),
+		),
+		"tasks.active": (input) => tasks.active(taskFilter(input)),
 		"tasks.focus": (input) => tasks.focus(string(input, "id")),
 		"tasks.start": (input) => tasks.transition(string(input, "id"), "start", eventContext(input)),
 		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit", eventContext(input)),
@@ -252,7 +277,7 @@ function handlers(
 			if (typeof input["enabled"] !== "boolean") throw new Error("enabled must be a boolean");
 			return tasks.setAutomation(string(input, "id"), input["enabled"], eventContext(input));
 		},
-		"tasks.context": () => taskContext(artifacts, tasks.active()?.id),
+		"tasks.context": (input) => taskContext(artifacts, tasks.active()?.id, new Set(tasks.list(taskFilter(input)).map((task) => task.id))),
 		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject", eventContext(input)),
 		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry", eventContext(input)),
 		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel", eventContext(input)),
@@ -297,10 +322,24 @@ function handlers(
 		"skills.run": (input) => instantiateSkillWorkflow(artifacts, string(input, "id"), {
 			runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
 			arguments: input["arguments"] as Record<string, unknown> | undefined,
-		}, { events, context: eventContextFor(input, "skill-run") }),
+		}, { events, scopes, projectRoot: string(input, "project_root"), context: eventContextFor(input, "skill-run") }),
 		"skills.enable": (input) => transitionSkill(artifacts, string(input, "id"), "enable"),
 		"skills.disable": (input) => transitionSkill(artifacts, string(input, "id"), "disable"),
-		"skills.instantiate": (input) => instantiateTemplate(artifacts, string(input, "template_id"), normalizeCreateInput(input)),
+		"skills.instantiate": (input) => {
+			const templateId = string(input, "template_id");
+			const template = artifacts.get(templateId);
+			if (template?.extra["targetKind"] !== "task") return instantiateTemplate(artifacts, templateId, normalizeCreateInput(input));
+			return tasks.create({
+				title: optionalString(input, "title") as string,
+				body: optionalString(input, "body"),
+				status: optionalString(input, "status") as TaskStatus | undefined,
+				labels: input["labels"] as string[] | undefined,
+				extra: input["extra"] as Record<string, unknown> | undefined,
+				templateId,
+				projectRoot: string(input, "project_root"),
+				projectSource: "cwd",
+			}, eventContextFor(input, "template-instantiation"));
+		},
 	};
 }
 
@@ -310,9 +349,10 @@ export function createPapyrusService(path: string, options: { automation?: TaskA
 	const gates = new SQLiteGateRunner(db);
 	const focus = new SQLiteTaskFocusStore(db);
 	const events = new SQLiteTaskEventStore(db);
-	const tasks = new Tasks(artifacts, gates, focus, events);
+	const scopes = new SQLiteTaskScopeStore(db);
+	const tasks = new Tasks(artifacts, gates, focus, events, scopes);
 	const automation = new TaskAutomationReconciler(tasks, options.automation ?? taskAutomationSettings({}));
-	const registry = handlers(artifacts, gates, tasks, automation, events, () => migrateDb(db));
+	const registry = handlers(artifacts, gates, tasks, automation, events, scopes, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -324,7 +364,7 @@ export function createPapyrusService(path: string, options: { automation?: TaskA
 			const handler = registry[operation as OperationName];
 			if (!handler) throw new UnknownOperationError(`unknown operation "${operation}"`);
 			if (operation !== "system.migrate" && operation !== "automation.status" && state().migrationRequired) {
-				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-history`");
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-scope`");
 			}
 			return handler(input);
 		},

package/src/skill-execution.ts

@@ -11,6 +11,8 @@ import {
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { TaskEventContext } from "./domain/task-event.ts";
 import type { TaskEventStore } from "./ports/task-event-store.ts";
+import type { TaskScopeStore } from "./ports/task-scope-store.ts";
+import { normalizeProjectRoot } from "./domain/task-scope.ts";
 import { requireAtomicArtifactStore } from "./ports/atomic-artifact-store.ts";
 import { projectTaskExecution, type TaskExecutionPlan } from "./task-execution.ts";
 import type { TaskGraph, TaskNode, TaskStatus } from "./task-service.ts";
@@ -117,9 +119,10 @@ export function instantiateSkillWorkflow(
 	artifacts: ArtifactStore,
 	skillId: string,
 	input: InstantiateSkillWorkflowInput = {},
-	history?: { events: TaskEventStore; context?: TaskEventContext },
+	history?: { events: TaskEventStore; scopes: TaskScopeStore; projectRoot: string; context?: TaskEventContext },
 ): SkillWorkflowRunResult {
 	const { definition } = requireWorkflowSkill(artifacts, skillId);
+	const projectRoot = history ? normalizeProjectRoot(history.projectRoot) : undefined;
 	const arguments_ = resolveSkillArguments(definition, input.arguments);
 	const rendered = renderDefinition(definition, arguments_);
 	const runId = normalizeRunId(skillId, input.runId);
@@ -175,15 +178,18 @@ export function instantiateSkillWorkflow(
 				labels: withRunLabel(blueprint.labels, runId),
 				extra: { ...(blueprint.extra ?? {}), skillRun: { id: runId, skillId, ref: blueprint.ref } },
 			});
-			if (history) history.events.append({
-				taskId: task.id,
-				type: "created",
-				actor: history.context?.actor ?? "system",
-				source: history.context?.source ?? "skill-run",
-				toStatus: task.status as TaskStatus,
-				...(history.context?.sessionId === undefined ? {} : { sessionId: history.context.sessionId }),
-				...(history.context?.reason === undefined ? {} : { reason: history.context.reason }),
-			});
+			if (history) {
+				history.scopes.assign(task.id, projectRoot, "cwd");
+				history.events.append({
+					taskId: task.id,
+					type: "created",
+					actor: history.context?.actor ?? "system",
+					source: history.context?.source ?? "skill-run",
+					toStatus: task.status as TaskStatus,
+					...(history.context?.sessionId === undefined ? {} : { sessionId: history.context.sessionId }),
+					...(history.context?.reason === undefined ? {} : { reason: history.context.reason }),
+				});
+			}
 			return task;
 		});
 

package/src/task-context.ts

@@ -34,8 +34,10 @@ function renderCurrent(task: Artifact): string[] {
 	];
 }
 
-export function taskContext(artifacts: ArtifactStore, activeTaskId?: string): string | null {
-	const tasks = artifacts.query({ kind: "task" }).sort((left, right) => left.updated_at.localeCompare(right.updated_at));
+export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>): string | null {
+	const tasks = artifacts.query({ kind: "task" })
+		.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;
 

package/src/task-service.ts

@@ -1,18 +1,23 @@
-import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES } from "./constants.ts";
+import { TASK_EXECUTION_MAX_DEGREE, TASK_EXECUTION_MAX_EDGES, TASK_EXECUTION_MAX_NODES, TASK_SCOPE_MAX_TASKS } from "./constants.ts";
 import type { Artifact } from "./domain/artifact.ts";
 import { checklistEntries, validateChecklist, type Checklist, type ProofReference } from "./domain/checklist.ts";
 import type { Gate, 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";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
 import { InMemoryTaskFocusStore, type TaskFocusStore } from "./ports/task-focus-store.ts";
 import { InMemoryTaskEventStore, type TaskEventStore } from "./ports/task-event-store.ts";
+import { InMemoryTaskScopeStore, type TaskScopeStore } from "./ports/task-scope-store.ts";
 import { assertDependencyEdgeAllowed } from "./task-execution.ts";
 
 export interface TaskFilter {
 	status?: string;
 	text?: string;
 	limit?: number;
+	projectRoot?: string;
+	scope?: TaskViewMode;
+	rootTaskId?: string;
 }
 
 export type TaskStatus = TaskLifecycleStatus;
@@ -30,6 +35,8 @@ export interface CreateTaskInput {
 	templateId?: string;
 	parentId?: string;
 	dependsOn?: string[];
+	projectRoot?: string;
+	projectSource?: TaskScopeSource;
 }
 
 export type TaskTransition = "start" | "submit" | "reject" | "retry" | "cancel";
@@ -71,6 +78,7 @@ export interface TaskNode {
 export interface TaskGraph {
 	nodes: TaskNode[];
 	rootIds: string[];
+	scope?: TaskViewSelection;
 }
 
 const TASK_TRANSITIONS: Record<TaskTransition, { from: TaskStatus[]; to: TaskStatus }> = {
@@ -87,6 +95,7 @@ export class Tasks {
 		private readonly gates: GateRunner,
 		private readonly focusStore: TaskFocusStore = new InMemoryTaskFocusStore(),
 		private readonly events: TaskEventStore = new InMemoryTaskEventStore(),
+		private readonly scopes: TaskScopeStore = new InMemoryTaskScopeStore(),
 	) {}
 
 	private require(id: string): Artifact {
@@ -106,6 +115,10 @@ export class Tasks {
 			const extra: Record<string, unknown> = { ...(input.extra ?? {}) };
 			if (input.gates !== undefined) extra["gates"] = input.gates;
 			if (input.checklist !== undefined) extra["checklist"] = validateChecklist(input.checklist);
+			const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
+			if (input.parentId && this.scopes.get(input.parentId)?.projectRoot !== projectRoot) {
+				throw new Error(`parent task "${input.parentId}" is outside project scope`);
+			}
 			const task = this.artifacts.create({
 				id: input.id,
 				kind: "task",
@@ -117,6 +130,7 @@ export class Tasks {
 				extra,
 				templateId: input.templateId,
 			});
+			this.scopes.assign(task.id, projectRoot, input.projectSource ?? (projectRoot ? "explicit" : "unscoped"));
 			if (input.parentId) this.contain(input.parentId, task.id);
 			for (const dependency of input.dependsOn ?? []) this.depend(task.id, dependency);
 			this.appendEvent({ taskId: task.id, type: "created", toStatus: task.status as TaskStatus }, context);
@@ -125,10 +139,62 @@ export class Tasks {
 	}
 
 	list(filter: TaskFilter = {}): Artifact[] {
-		return this.artifacts.query({ kind: "task", ...filter });
+		const selection = this.scopeSelection(filter.projectRoot, filter.scope, filter.rootTaskId);
+		const limit = filter.limit ?? TASK_SCOPE_MAX_TASKS;
+		if (!Number.isInteger(limit) || limit < 1 || limit > TASK_SCOPE_MAX_TASKS + 1) {
+			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 });
+		}
+		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`);
+		const selectedIds = selection.mode === "graph" ? this.descendantIds(selection.rootTaskId!, ids) : new Set(ids);
+		const text = filter.text?.toLowerCase();
+		return [...selectedIds]
+			.map((id) => this.artifacts.get(id))
+			.filter((task): task is Artifact => task?.kind === "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))
+			.slice(0, limit);
+	}
+
+	scopeSelection(projectRoot?: string, mode?: TaskViewMode, rootTaskId?: string): TaskViewSelection {
+		if (mode !== undefined && mode !== "project" && mode !== "graph" && mode !== "all") throw new Error("task scope must be project, graph, or all");
+		if (projectRoot === undefined) return { mode: "all", label: taskScopeLabel("all") };
+		const normalized = normalizeProjectRoot(projectRoot);
+		const persisted = this.scopes.view(normalized);
+		const selectedMode = mode ?? persisted.mode;
+		const selectedRoot = rootTaskId ?? (selectedMode === "graph" ? persisted.rootTaskId : undefined);
+		if (selectedMode === "graph" && !selectedRoot) throw new Error("graph scope requires root_task_id");
+		const root = selectedRoot ? this.require(selectedRoot) : undefined;
+		if (root && this.scopes.get(root.id)?.projectRoot !== normalized) throw new Error(`task "${root.id}" is outside project scope`);
+		return {
+			mode: selectedMode,
+			label: taskScopeLabel(selectedMode, normalized, root?.title),
+			projectRoot: normalized,
+			...(selectedRoot === undefined ? {} : { rootTaskId: selectedRoot }),
+		};
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewSelection {
+		const selection = this.scopeSelection(projectRoot, mode, rootTaskId);
+		this.scopes.setView(selection.projectRoot!, selection.mode, selection.rootTaskId);
+		return selection;
+	}
+
+	assignProject(id: string, projectRoot: string, context: TaskEventContext = {}): Artifact {
+		return this.events.atomic(() => {
+			const task = this.require(id);
+			this.scopes.assign(id, normalizeProjectRoot(projectRoot), "explicit");
+			this.appendEvent({ taskId: id, type: "project_assigned", reason: context.reason }, context);
+			return task;
+		});
 	}
 
 	graph(filter: TaskFilter = {}): TaskGraph {
+		const scope = this.scopeSelection(filter.projectRoot, filter.scope, filter.rootTaskId);
 		const requestedLimit = filter.limit ?? TASK_EXECUTION_MAX_NODES + 1;
 		if (!Number.isInteger(requestedLimit) || requestedLimit < 1 || requestedLimit > TASK_EXECUTION_MAX_NODES + 1) {
 			throw new Error(`task graph limit must be between 1 and ${TASK_EXECUTION_MAX_NODES + 1}`);
@@ -172,6 +238,7 @@ export class Tasks {
 		return {
 			nodes: tasks.map((task) => nodes.get(task.id)!),
 			rootIds: tasks.filter((task) => nodes.get(task.id)!.parentIds.length === 0).map((task) => task.id),
+			scope,
 		};
 	}
 
@@ -180,7 +247,7 @@ export class Tasks {
 		return this.artifacts.get(id, { tree: true })!;
 	}
 
-	active(): Artifact | null {
+	active(filter?: TaskFilter): Artifact | null {
 		const id = this.focusStore.get();
 		if (!id) return null;
 		const task = this.artifacts.get(id);
@@ -188,6 +255,7 @@ export class Tasks {
 			this.focusStore.clear(id);
 			return null;
 		}
+		if (filter?.projectRoot && !this.list(filter).some((candidate) => candidate.id === task.id)) return null;
 		return task;
 	}
 
@@ -295,6 +363,36 @@ export class Tasks {
 		return this.show(parentId);
 	}
 
+	private descendantIds(rootTaskId: string, projectTaskIds: string[]): Set<string> {
+		const allowed = new Set(projectTaskIds);
+		if (!allowed.has(rootTaskId)) throw new Error(`task "${rootTaskId}" is outside project scope`);
+		const relationships = this.artifacts.relationships({
+			kind: "task",
+			artifactIds: projectTaskIds,
+			limit: TASK_EXECUTION_MAX_EDGES + 1,
+		});
+		if (relationships.length > TASK_EXECUTION_MAX_EDGES) throw new Error(`task project scope exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
+		const children = new Map<string, string[]>();
+		for (const edge of relationships) {
+			const parentId = edge.relation === "contains" ? edge.from : edge.relation === "part_of" ? edge.to : undefined;
+			const childId = edge.relation === "contains" ? edge.to : edge.relation === "part_of" ? edge.from : undefined;
+			if (!parentId || !childId || !allowed.has(parentId) || !allowed.has(childId)) continue;
+			const values = children.get(parentId) ?? [];
+			if (!values.includes(childId)) values.push(childId);
+			children.set(parentId, values);
+		}
+		const selected = new Set<string>();
+		const pending = [rootTaskId];
+		while (pending.length > 0) {
+			const id = pending.shift()!;
+			if (selected.has(id)) continue;
+			if (selected.size >= TASK_SCOPE_MAX_TASKS) throw new Error(`focused task graph exceeds ${TASK_SCOPE_MAX_TASKS} tasks`);
+			selected.add(id);
+			pending.push(...(children.get(id) ?? []));
+		}
+		return selected;
+	}
+
 	private relationships(id: string) {
 		const relationships = this.artifacts.relationships({
 			kind: "task",