@danypops/papyrus 0.6.0 → 0.8.0

package/README.md

@@ -32,13 +32,14 @@ bun src/cli.ts service install   # install, enable, and start user service
 bun src/cli.ts service status
 bun src/cli.ts service restart
 
-# Authenticated daemon-backed task automation (add --json for machine output)
+# Authenticated daemon-backed Task operations (add --json for machine output)
 papyrus tasks plan
 papyrus tasks depend <task-id> <prerequisite-id>
-papyrus tasks start <task-id>
+papyrus tasks update <task-id> --title "Revised task"
+papyrus tasks focus <task-id>
+papyrus tasks pause
+papyrus tasks unpause
 papyrus tasks complete <task-id>
-papyrus tasks automate <task-id> <on|off>
-papyrus automation status
 ```
 
 For repository work, install the versioned ownership guard once:
@@ -92,7 +93,7 @@ The `papyrus_*` tools are the low-level graph-store API:
 
 Agent-facing domain tools own lifecycle invariants and sit above this store API:
 
-- **`tasks`** — create/list/show/plan, manage the singleton active focus, replace evidence-bearing checklists, hierarchy/dependencies, lifecycle transitions, non-blocking gates, and review completion that focuses one deterministic ready successor without claiming effort
+- **`tasks`** — create/update/list/show/plan, manage the singleton active focus, replace evidence-bearing checklists, hierarchy/dependencies, lifecycle transitions, non-blocking gates, and review completion that focuses one deterministic ready successor without claiming effort
 - **`docs`** — create/list/show, activate/archive/reopen, and document-safe graph links
 - **`rules`** — create/list/show/preview, enable/disable, and attach governance gates to tasks
 - **`skills`** — create/list/show/invoke/run, enable/disable, create compatibility templates, and atomically instantiate parameterized workflow runs
@@ -103,7 +104,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,56 +115,49 @@ 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
-- use **active** only as the independent singleton focus that auto-drive continues; focusing a task never changes its lifecycle
+- use **focus** as the independent singleton Task selection that automatic continuation follows; focusing, pausing, or resuming never changes lifecycle
 - starting nested effort moves todo ancestors to in-progress; submitting enters review; completing review checks both typed checklist proofs and executable gates
 - passing review marks only that task done and focuses one deterministic ready successor while leaving the successor todo until effort starts
 - successors are never auto-completed; fan-in, fan-out, diamonds, and disconnected DAGs remain explicit
 - 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
+papyrus tasks focused --json
+papyrus tasks pause --json
+papyrus tasks unpause --json
+papyrus tasks clear-focus --json
+papyrus tasks update <id> --title "Revised title" --body "Revised body" --json
 papyrus tasks start <id> --json
 papyrus tasks submit <id> --json
 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
+### Focus-driven automatic continuation
 
-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.
+Automatic continuation is a property of the singleton Task focus, not a per-Task automation flag. An active focus continues at Pi's public `agent_settled` boundary when Pi is idle and has no queued messages. `tasks pause` preserves the focused Task while stopping continuation; `tasks unpause` resumes it; `tasks clear-focus` removes it. Replacing focus selects an existing Task rather than creating or canceling one.
 
-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.
+Continuation is single-flight and bounded to 20 automatic turns or 6 unchanged Task snapshots. Reaching either bound persists a paused focus and records the reason in append-only Task history. Human input resumes only these automatically paused focuses; an explicit user pause remains paused.
 
 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:
 
@@ -182,7 +176,7 @@ Proof types are `file`, `symbol`, `code`, `test`, `command`, `artifact`, and `ur
 
 Papyrus also injects an Alef-style reconciliation block on every agent turn while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run review before marking it done. The injection disappears when every task is done or canceled.
 
-In TUI and RPC modes, the extension checks the singleton active focus at Pi’s public `agent_settled` lifecycle boundary. If a focused task remains and no continuation is already pending, it queues one hidden next turn. No manual driving command is required. Driving is single-flight and pauses after 20 automatic turns or 6 unchanged task snapshots; human input and task progress reset the bounded counters automatically.
+Task edits mutate the existing Papyrus-owned Task identity and append an `updated` event; title, body, and labels can be revised without canceling the Task or creating a replacement. Lifecycle, relationships, gates, checklist metadata, scope, and focus remain intact.
 
 ## Why
 
@@ -197,10 +191,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 focus-driven Task continuation, 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-focus
 ```
 
 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/active-task-continuation.ts

@@ -23,6 +23,15 @@ export interface ActiveTaskContinuationDecision {
 }
 
 const TITLE_LIMIT = 120;
+const AUTOMATIC_PAUSE_PREFIX = "automatic continuation paused:";
+
+export function automaticPauseReason(reason: string): string {
+	return `${AUTOMATIC_PAUSE_PREFIX} ${reason}`;
+}
+
+export function shouldResumeFocusOnHumanInput(status: string, pauseReason?: string): boolean {
+	return status === "paused" && pauseReason?.startsWith(AUTOMATIC_PAUSE_PREFIX) === true;
+}
 
 function fingerprint(task: ActiveTaskMarker): string {
 	return `${task.id}:${task.updated_at}`;

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, update, list, show, history, scope, set_scope, assign_project, graph, plan, active, focused, focus, pause, unpause, clear_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.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -44,7 +44,6 @@ 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()))),
@@ -54,17 +53,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 +78,35 @@ 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 === "focused") {
+					const focus = await callService<Record<string, unknown>, { artifact: Artifact; status: string } | null>("tasks.focused", request);
+					return text(focus ? `Focused (${focus.status}): ${artifactLine(focus.artifact)}` : "No focused task.", { focus });
+				}
+				if (action === "pause" || action === "unpause") {
+					const operation = action === "pause" ? "tasks.pause" : "tasks.unpause";
+					const focus = await callService<Record<string, unknown>, { artifact: Artifact; status: string }>(operation, request);
+					return text(`Focused (${focus.status}): ${artifactLine(focus.artifact)}`, { focus });
+				}
+				if (action === "clear_focus") {
+					const result = await callService<Record<string, unknown>, { cleared: boolean }>("tasks.clear_focus", request);
+					return text(result.cleared ? "Task focus cleared." : "No focused task.", result);
+				}
 				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,7 +143,9 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					reject: "tasks.reject",
 					retry: "tasks.retry",
 					cancel: "tasks.cancel",
-					set_automation: "tasks.set_automation",
+					update: "tasks.update",
+					set_scope: "tasks.set_scope",
+					assign_project: "tasks.assign_project",
 					depend: "tasks.depend",
 					contain: "tasks.contain",
 				} as const;
@@ -234,10 +255,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 +275,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 +288,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

@@ -20,7 +20,7 @@ import { formatMetadata } from "./artifact-format.ts";
 import { callService } from "./service-client.ts";
 import { registerDomainTools } from "./domain-tools.ts";
 import type { TaskGraph, TaskStatus } from "../../src/task-service.ts";
-import { ActiveTaskContinuation, type ActiveTaskMarker } from "./active-task-continuation.ts";
+import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanInput, type ActiveTaskMarker } from "./active-task-continuation.ts";
 import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
 import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
 
@@ -36,12 +36,12 @@ 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);
 		const hierarchy = taskTreeConnector({ depth: row.depth, hasChildren: row.hasOpenChildren, hasLaterSibling: laterSibling });
-		const focus = row.active ? theme.fg("accent", "▶") : " ";
+		const focus = row.active ? theme.fg("accent", row.focusStatus === "paused" ? "Ⅱ" : "▶") : " ";
 		const presentation = TASK_STATUS_PRESENTATION[row.task.status as TaskStatus];
 		const glyph = presentation ? theme.fg(presentation.color, presentation.glyph) : theme.fg("muted", "?");
 		lines.push(truncateToWidth(`${focus} ${hierarchy} ${glyph} ${row.task.title}`, width, "…"));
@@ -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(),
@@ -144,8 +149,13 @@ export default async function (pi: ExtensionAPI) {
 					content: decision.prompt,
 					display: false,
 				}, { triggerTurn: true, deliverAs: "nextTurn" });
-			} else if (decision.action === "pause" && ctx.hasUI) {
-				ctx.ui.notify(`Papyrus task driving paused: ${decision.reason}. Human input or task progress resumes it automatically.`, "warning");
+			} else if (decision.action === "pause") {
+				await callService("tasks.pause", {
+					actor: "system",
+					source: "task-continuation",
+					reason: automaticPauseReason(decision.reason),
+				});
+				if (ctx.hasUI) ctx.ui.notify(`Papyrus task driving paused: ${decision.reason}. Human input resumes it automatically.`, "warning");
 			}
 		} catch {
 			// The daemon may be unavailable during startup, reload, or shutdown.
@@ -174,10 +184,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 +323,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 +347,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();
 	});
 
@@ -350,8 +366,17 @@ export default async function (pi: ExtensionAPI) {
 	// agent_settled is intentionally later than agent_end: Pi guarantees that
 	// retry, compaction retry, and queued follow-up processing have finished.
 
-	pi.on("input", (event) => {
-		if (event.source !== "extension") taskContinuation.onHumanInput();
+	pi.on("input", async (event) => {
+		if (event.source === "extension") return;
+		taskContinuation.onHumanInput();
+		try {
+			const focus = await callService<Record<string, never>, { status: string; pauseReason?: string } | null>("tasks.focused", {});
+			if (focus && shouldResumeFocusOnHumanInput(focus.status, focus.pauseReason)) {
+				await callService("tasks.unpause", { actor: "system", source: "task-continuation", reason: "human input resumed automatic task continuation" });
+			}
+		} catch {
+			// The daemon may be unavailable during startup, reload, or shutdown.
+		}
 	});
 	pi.on("agent_start", () => { taskContinuation.onAgentStart(); });
 	pi.on("agent_settled", async (_event, ctx) => { await driveActiveTasks(ctx); });
@@ -360,11 +385,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

@@ -7,12 +7,14 @@ export interface TaskWidgetRow {
 	depth: number;
 	hasOpenChildren: boolean;
 	active: boolean;
+	focusStatus?: "active" | "paused";
 }
 
 export interface TaskWidgetProjection {
 	rows: TaskWidgetRow[];
 	openTotal: number;
 	total: number;
+	scopeLabel: string;
 }
 
 function isOpen(task: Artifact): boolean {
@@ -34,7 +36,7 @@ export function buildTaskWidgetProjection(
 		if (!node) return;
 		visited.add(id);
 		const open = isOpen(node.task);
-		if (open) ordered.push({ task: node.task, depth: openDepth, hasOpenChildren: false, active: node.active === true });
+		if (open) ordered.push({ task: node.task, depth: openDepth, hasOpenChildren: false, active: node.active === true, focusStatus: node.focusStatus });
 		const childDepth = open ? openDepth + 1 : openDepth;
 		for (const childId of node.childIds) visit(childId, childDepth);
 	};
@@ -52,5 +54,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,12 +30,6 @@ 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;
@@ -62,8 +56,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 +70,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,16 +86,34 @@ 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 focusStatus = graph.nodes.find((node) => node.task.id === action.row!.id)?.focusStatus;
 		const choices = [
 			"Show details",
+			"Edit task",
 			...(!active && action.row.status !== "done" && action.row.status !== "canceled" ? ["Make active"] : []),
-			...(action.row.status !== "done" && action.row.status !== "canceled" ? [automationEnabled ? "Disable automation" : "Enable automation"] : []),
+			...(active ? [focusStatus === "paused" ? "Resume focus" : "Pause focus", "Clear focus"] : []),
 			...(action.row.status === "review" ? ["Run gates"] : []),
 			...(STATUS_ACTIONS[action.row.status] ?? []),
 		];
@@ -108,26 +125,39 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			if (!art) { ctx.ui.notify("Not found", "error"); continue; }
 			const history = await callService<Record<string, unknown>, TaskHistoryPage>("tasks.history", { id: art.id, direction: "desc" });
 			await showTaskDetails(ctx, art, graph, undefined, [...history.events].reverse());
+		} else if (choice === "Edit task") {
+			const title = await ctx.ui.input("Task title:", action.row.title);
+			if (title === undefined) continue;
+			const body = await ctx.ui.input("Task body:", action.row.body);
+			if (body === undefined) continue;
+			try {
+				const updated = await callService<Record<string, unknown>, Artifact>("tasks.update", {
+					id: action.row.id,
+					title,
+					body,
+					actor: "user",
+					source: "tasks-tui",
+				});
+				action.row.title = updated.title;
+				action.row.body = updated.body;
+				ctx.ui.notify(`Updated: ${updated.title}`, "info");
+			} catch (error) {
+				ctx.ui.notify(`Task update failed: ${error instanceof Error ? error.message : error}`, "error");
+			}
 		} else if (choice === "Make active") {
 			try {
-				await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id });
+				await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id, actor: "user", source: "tasks-tui" });
 				ctx.ui.notify(`Active: ${action.row.title}`, "info");
 			} catch (error) {
 				ctx.ui.notify(`Focus failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
-		} else if (choice === "Enable automation" || choice === "Disable automation") {
+		} else if (choice === "Pause focus" || choice === "Resume focus" || choice === "Clear focus") {
 			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");
+				const operation = choice === "Pause focus" ? "tasks.pause" : choice === "Resume focus" ? "tasks.unpause" : "tasks.clear_focus";
+				await callService(operation, { actor: "user", source: "tasks-tui" });
+				ctx.ui.notify(choice === "Clear focus" ? "Task focus cleared" : choice, "info");
 			} catch (error) {
-				ctx.ui.notify(`Automation setting failed: ${error instanceof Error ? error.message : error}`, "error");
+				ctx.ui.notify(`Focus action failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
 		} else if (choice === "Run gates") {
 			try {
@@ -173,12 +203,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 +248,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 +259,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 +354,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];