@danypops/papyrus 0.5.0 → 0.7.0

package/README.md

@@ -37,6 +37,8 @@ papyrus tasks plan
 papyrus tasks depend <task-id> <prerequisite-id>
 papyrus tasks start <task-id>
 papyrus tasks complete <task-id>
+papyrus tasks automate <task-id> <on|off>
+papyrus automation status
 ```
 
 For repository work, install the versioned ownership guard once:
@@ -101,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
@@ -112,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
@@ -123,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
@@ -138,8 +145,31 @@ papyrus tasks complete <id> --json
 papyrus tasks reject <id> --json
 papyrus tasks retry <id> --json
 papyrus tasks cancel <id> --json
+papyrus tasks automate <id> <on|off> --json
+papyrus automation status --json
+papyrus automation run --json
 ```
 
+### Opt-in supervised automation
+
+Background graph reconciliation is off by default and requires two independent opt-ins: daemon configuration and `automation.enabled` on each Task. Only opted-in Tasks already in `review` are eligible for automatic gate/checklist review; Papyrus never skips the review lifecycle. When one completes, directly dependent opted-in successors that become ready may move from `todo` to `in-progress`. Every completion, rejection, and start is written to append-only history with actor `daemon`, source `automation-reconciler`, reason, and bounded gate evidence.
+
+Enable the daemon with a systemd user-service override and restart it:
+
+```ini
+[Service]
+Environment=PAPYRUS_AUTOMATION_ENABLED=1
+```
+
+```bash
+systemctl --user edit papyrus.service
+systemctl --user restart papyrus.service
+papyrus tasks automate <task-id> on
+papyrus automation status
+```
+
+Secure defaults are a 60-second interval, 10 Task transitions per sweep, gate concurrency 1, and a 120-second sweep deadline. Optional environment settings are `PAPYRUS_AUTOMATION_INTERVAL_MS` (10 seconds–1 hour), `PAPYRUS_AUTOMATION_MAX_TASKS` (1–100), `PAPYRUS_AUTOMATION_GATE_CONCURRENCY` (1–4), and `PAPYRUS_AUTOMATION_MAX_RUNTIME_MS` (1 ms–10 minutes). Candidate scans are capped at 1,000 review Tasks, sweeps are single-flight, subprocess gates inherit the sweep deadline, result arrays are bounded by the Task limit, and logs contain counts rather than gate output. `papyrus automation run` uses the same policy and refuses to reconcile while global automation is disabled.
+
 Checklist criteria are an item-to-proof map. Every new item requires one or more typed references to inspectable evidence; proof presence does not imply that the evidence passed an executable gate:
 
 ```ts
@@ -172,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, 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()),
@@ -44,6 +44,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			direction: Type.Optional(Type.Union([Type.Literal("asc"), Type.Literal("desc")])),
 			reason: Type.Optional(Type.String()),
 			session_id: Type.Optional(Type.String()),
+			enabled: Type.Optional(Type.Boolean()),
 			labels: Type.Optional(Type.Array(Type.String())),
 			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 			gates: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
@@ -53,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") {
@@ -75,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}`,
@@ -123,6 +131,9 @@ 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",
 				} as const;
@@ -232,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);
@@ -250,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.`,
@@ -263,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

@@ -30,6 +30,12 @@ const STATUS_ACTIONS: Record<string, string[]> = {
 
 type TaskRow = Artifact;
 
+function taskAutomationEnabled(task: Artifact): boolean {
+	const automation = task.extra["automation"];
+	return typeof automation === "object" && automation !== null && !Array.isArray(automation)
+		&& (automation as Record<string, unknown>)["enabled"] === true;
+}
+
 export interface TaskHierarchyRow {
 	task: TaskRow;
 	depth: number;
@@ -56,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> {
@@ -65,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;
@@ -81,14 +92,33 @@ 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;
 
 		const active = graph.nodes.find((node) => node.task.id === action.row!.id)?.active === true;
+		const automationEnabled = taskAutomationEnabled(action.row);
 		const choices = [
 			"Show details",
 			...(!active && action.row.status !== "done" && action.row.status !== "canceled" ? ["Make active"] : []),
+			...(action.row.status !== "done" && action.row.status !== "canceled" ? [automationEnabled ? "Disable automation" : "Enable automation"] : []),
 			...(action.row.status === "review" ? ["Run gates"] : []),
 			...(STATUS_ACTIONS[action.row.status] ?? []),
 		];
@@ -107,6 +137,20 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			} catch (error) {
 				ctx.ui.notify(`Focus failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
+		} else if (choice === "Enable automation" || choice === "Disable automation") {
+			try {
+				const enabled = choice === "Enable automation";
+				const updated = await callService<Record<string, unknown>, Artifact>("tasks.set_automation", {
+					id: action.row.id,
+					enabled,
+					actor: "user",
+					source: "tasks-tui",
+				});
+				action.row.extra = updated.extra;
+				ctx.ui.notify(`Automation ${enabled ? "enabled" : "disabled"}: ${action.row.title}`, enabled ? "warning" : "info");
+			} catch (error) {
+				ctx.ui.notify(`Automation setting failed: ${error instanceof Error ? error.message : error}`, "error");
+			}
 		} else if (choice === "Run gates") {
 			try {
 				const results = await callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", { id: action.row.id, actor: "user", source: "tasks-tui" });
@@ -151,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;
 }
 
@@ -196,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") +
@@ -207,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");
@@ -300,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.5.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-gate-runner.ts

@@ -1,5 +1,5 @@
 import type { Db } from "../db.ts";
-import type { GateResult } from "../domain/gate.ts";
+import type { GateResult, GateRunOptions } from "../domain/gate.ts";
 import type { GateRunner } from "../ports/gate-runner.ts";
 import { runGates, runGatesAsync } from "../ops.ts";
 
@@ -10,7 +10,7 @@ export class SQLiteGateRunner implements GateRunner {
 		return runGates(this.db, artifactId);
 	}
 
-	runAsync(artifactId: string): Promise<GateResult[]> {
-		return runGatesAsync(this.db, artifactId);
+	runAsync(artifactId: string, options?: GateRunOptions): Promise<GateResult[]> {
+		return runGatesAsync(this.db, artifactId, options);
 	}
 }

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 }) };
+	}
+}