@danypops/papyrus 0.7.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
@@ -118,7 +119,7 @@ Run `/tasks` for the interactive task panel:
 - `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
@@ -139,36 +140,24 @@ 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:
 
@@ -187,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
 
@@ -202,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 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]`:
+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-scope
+~/.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, 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.",
+		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()))),
@@ -87,6 +86,19 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					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", request);
 					const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
@@ -131,9 +143,9 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					reject: "tasks.reject",
 					retry: "tasks.retry",
 					cancel: "tasks.cancel",
+					update: "tasks.update",
 					set_scope: "tasks.set_scope",
 					assign_project: "tasks.assign_project",
-					set_automation: "tasks.set_automation",
 					depend: "tasks.depend",
 					contain: "tasks.contain",
 				} as const;

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";
 
@@ -41,7 +41,7 @@ export function renderTaskWidgetLines(theme: Theme, projection: TaskWidgetProjec
 		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, "…"));
@@ -149,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.
@@ -361,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); });

package/extension/src/task-widget.ts

@@ -7,6 +7,7 @@ export interface TaskWidgetRow {
 	depth: number;
 	hasOpenChildren: boolean;
 	active: boolean;
+	focusStatus?: "active" | "paused";
 }
 
 export interface TaskWidgetProjection {
@@ -35,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);
 	};

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;
@@ -114,11 +108,12 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		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] ?? []),
 		];
@@ -130,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.7.0",
+  "version": "0.8.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-artifact-store.ts

@@ -9,8 +9,9 @@ import type {
 	ArtifactQuery,
 	CreateArtifactInput,
 	RelationshipQuery,
+	UpdateArtifactInput,
 } from "../domain/artifact.ts";
-import { createArtifact, getArtifact, linkArtifacts, queryArtifacts, updateExtra, updateStatus } from "../ops.ts";
+import { createArtifact, getArtifact, linkArtifacts, queryArtifacts, updateArtifactContent, updateExtra, updateStatus } from "../ops.ts";
 
 export class SQLiteArtifactStore implements AtomicArtifactStore {
 	constructor(private readonly db: Db) {}
@@ -43,6 +44,10 @@ export class SQLiteArtifactStore implements AtomicArtifactStore {
 		return updateExtra(this.db, id, extra);
 	}
 
+	updateContent(id: string, input: UpdateArtifactInput): Artifact | null {
+		return updateArtifactContent(this.db, id, input);
+	}
+
 	relationships(filter: RelationshipQuery = {}): ArtifactEdge[] {
 		if (filter.artifactIds?.length === 0) return [];
 		const conditions: string[] = [];

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

@@ -1,26 +1,20 @@
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
-import type { TaskFocusStore } from "../ports/task-focus-store.ts";
+import type { TaskFocusState, TaskFocusStatus, TaskFocusStore } from "../ports/task-focus-store.ts";
 
 export class SQLiteTaskFocusStore implements TaskFocusStore {
 	constructor(private readonly db: Db) {}
 
-	get(): string | undefined {
-		const row = this.db.prepare("SELECT task_id FROM task_focus WHERE scope = 'global'").get() as
-			| { task_id: string }
+	get(): TaskFocusState | undefined {
+		const row = this.db.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = 'global'").get() as
+			| { task_id: string; status: TaskFocusStatus; pause_reason: string | null; updated_at: string }
 			| null;
-		return row?.task_id;
+		return row ? { taskId: row.task_id, status: row.status, updatedAt: row.updated_at, ...(row.pause_reason ? { pauseReason: row.pause_reason } : {}) } : undefined;
 	}
 
-	set(taskId: string): void {
-		inTransaction(this.db, () => {
-			this.db.prepare(`
-				INSERT INTO task_focus (scope, task_id, updated_at)
-				VALUES ('global', ?, ?)
-				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, updated_at = excluded.updated_at
-			`).run(taskId, new Date().toISOString());
-		});
-	}
+	set(taskId: string): TaskFocusState { return this.write(taskId, "active"); }
+	pause(taskId: string, reason?: string): TaskFocusState { return this.transition(taskId, "active", "paused", reason); }
+	unpause(taskId: string): TaskFocusState { return this.transition(taskId, "paused", "active"); }
 
 	clear(taskId?: string): void {
 		inTransaction(this.db, () => {
@@ -28,4 +22,23 @@ export class SQLiteTaskFocusStore implements TaskFocusStore {
 			else this.db.prepare("DELETE FROM task_focus WHERE scope = 'global' AND task_id = ?").run(taskId);
 		});
 	}
+
+	private transition(taskId: string, expected: TaskFocusStatus, status: TaskFocusStatus, reason?: string): TaskFocusState {
+		const current = this.get();
+		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		if (current.status !== expected) throw new Error(`focus is ${current.status}, expected ${expected}`);
+		return this.write(taskId, status, reason);
+	}
+
+	private write(taskId: string, status: TaskFocusStatus, pauseReason?: string): TaskFocusState {
+		const updatedAt = new Date().toISOString();
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO task_focus (scope, task_id, status, pause_reason, updated_at)
+				VALUES ('global', ?, ?, ?, ?)
+				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, status = excluded.status, pause_reason = excluded.pause_reason, updated_at = excluded.updated_at
+			`).run(taskId, status, pauseReason ?? null, updatedAt);
+		});
+		return { taskId, status, updatedAt, ...(pauseReason ? { pauseReason } : {}) };
+	}
 }

package/src/cli.ts

@@ -10,7 +10,6 @@ import { serveMain } from "./daemon.ts";
 import type { GateResult } from "./domain/gate.ts";
 import type { TaskExecutionPlan } from "./task-execution.ts";
 import type { TaskBlockage, TaskCompletion } from "./task-service.ts";
-import type { TaskAutomationResult, TaskAutomationSettings } from "./task-automation.ts";
 
 export interface SystemdUnitOptions {
 	bunBin: string;
@@ -57,23 +56,26 @@ function installService(): void {
 const USAGE = `Usage:
   papyrus serve
   papyrus service <install|start|stop|restart|status>
-  papyrus migrate task-scope [--json]
-  papyrus automation <status|run> [--json]
+  papyrus migrate task-focus [--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 focused [--json]
+  papyrus tasks pause [--json]
+  papyrus tasks unpause [--json]
+  papyrus tasks clear-focus [--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 update <id> [--title <title>] [--body <body>] [--labels-json <json>] [--json]
   papyrus tasks complete <id> [--json]
   papyrus tasks start <id> [--json]
   papyrus tasks submit <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 tasks depend <id> <prerequisite-id> [--json]`;
 
 function usage(): never {
@@ -112,8 +114,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-scope") {
-		throw new Error("migrate requires exactly `task-scope`");
+	if (positional.length !== 1 || positional[0] !== "task-focus") {
+		throw new Error("migrate requires exactly `task-focus`");
 	}
 	const result = await client.call<Record<string, never>, MigrationResult>("system.migrate", {});
 	if (json) return JSON.stringify(result);
@@ -121,20 +123,6 @@ export async function runMigrationCli(args: string[], client: TaskCliClient): Pr
 	return `Migrated schema ${result.from} → ${result.to}: ${result.applied.join(", ")}`;
 }
 
-export async function runAutomationCli(args: string[], client: TaskCliClient): Promise<string> {
-	const json = args.includes("--json");
-	const positional = args.filter((argument) => argument !== "--json");
-	if (positional.length !== 1 || (positional[0] !== "status" && positional[0] !== "run")) {
-		throw new Error("automation requires exactly `status` or `run`");
-	}
-	if (positional[0] === "status") {
-		const status = await client.call<Record<string, never>, TaskAutomationSettings & { inFlight: boolean }>("automation.status", {});
-		return json ? JSON.stringify(status) : `Automation: ${status.enabled ? "enabled" : "disabled"} · interval ${status.intervalMs}ms · max ${status.maxTasksPerSweep} tasks · concurrency ${status.gateConcurrency}`;
-	}
-	const result = await client.call<Record<string, never>, TaskAutomationResult>("automation.reconcile", {});
-	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, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional: string[] = [];
@@ -182,7 +170,25 @@ export async function runSkillCli(args: string[], client: TaskCliClient, project
 
 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 positional: string[] = [];
+	const updateInput: { title?: string; body?: string; labels?: string[] } = {};
+	for (let index = 0; index < args.length; index++) {
+		const argument = args[index]!;
+		if (argument === "--json") continue;
+		if (argument === "--title" || argument === "--body" || argument === "--labels-json") {
+			const value = args[++index];
+			if (value === undefined) throw new Error(`${argument} requires a value`);
+			if (argument === "--title") updateInput.title = value;
+			else if (argument === "--body") updateInput.body = value;
+			else {
+				const parsed = JSON.parse(value) as unknown;
+				if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error("--labels-json requires a JSON string array");
+				updateInput.labels = parsed as string[];
+			}
+			continue;
+		}
+		positional.push(argument);
+	}
 	const [action, id, dependencyId] = positional;
 	let result: unknown;
 	let human: string;
@@ -194,6 +200,37 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 			human = active ? `Active: ${artifactLabel(active)}` : "No active task.";
 			break;
 		}
+		case "focused": {
+			if (id) throw new Error("tasks focused accepts no positional arguments");
+			const focus = await client.call<Record<string, string>, { artifact: CliArtifact; status: "active" | "paused"; updatedAt: string } | null>("tasks.focused", { project_root: projectRoot });
+			result = focus;
+			human = focus ? `Focused (${focus.status}): ${artifactLabel(focus.artifact)}` : "No focused task.";
+			break;
+		}
+		case "pause":
+		case "unpause": {
+			if (id) throw new Error(`tasks ${action} accepts no positional arguments`);
+			const operation = action === "pause" ? "tasks.pause" : "tasks.unpause";
+			const focus = await client.call<Record<string, string>, { artifact: CliArtifact; status: string }>(operation, { actor: "user", source: "cli" });
+			result = focus;
+			human = `Focused (${focus.status}): ${artifactLabel(focus.artifact)}`;
+			break;
+		}
+		case "clear-focus": {
+			if (id) throw new Error("tasks clear-focus accepts no positional arguments");
+			const cleared = await client.call<Record<string, string>, { cleared: boolean }>("tasks.clear_focus", { actor: "user", source: "cli" });
+			result = cleared;
+			human = cleared.cleared ? "Task focus cleared." : "No focused task.";
+			break;
+		}
+		case "update": {
+			if (!id || dependencyId) throw new Error("tasks update requires exactly one task id");
+			if (Object.keys(updateInput).length === 0) throw new Error("tasks update requires --title, --body, or --labels-json");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.update", { id, ...updateInput, actor: "user", source: "cli" });
+			result = artifact;
+			human = `Updated: ${artifactLabel(artifact)}`;
+			break;
+		}
 		case "history": {
 			if (!id || dependencyId) throw new Error("tasks history requires exactly one task id");
 			const page = await client.call<{ id: string; direction: "desc" }, import("./domain/task-event.ts").TaskHistoryPage>("tasks.history", { id, direction: "desc" });
@@ -236,7 +273,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 		}
 		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 });
+			const active = await client.call<Record<string, string>, CliArtifact>("tasks.focus", { id, actor: "user", source: "cli" });
 			result = active;
 			human = `Active: ${artifactLabel(active)}`;
 			break;
@@ -291,18 +328,6 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 			human = `${action[0]!.toUpperCase()}${action.slice(1)}: ${artifactLabel(artifact)}`;
 			break;
 		}
-		case "automate": {
-			if (!id || (dependencyId !== "on" && dependencyId !== "off") || positional.length !== 3) throw new Error("tasks automate requires a task id and on or off");
-			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.set_automation", {
-				id,
-				enabled: dependencyId === "on",
-				actor: "user",
-				source: "cli",
-			});
-			result = artifact;
-			human = `Automation ${dependencyId}: ${artifactLabel(artifact)}`;
-			break;
-		}
 		case "depend": {
 			if (!id || !dependencyId || positional.length !== 3) throw new Error("tasks depend requires a task id and prerequisite id");
 			const artifact = await client.call<{ id: string; dependency_id: string }, CliArtifact>("tasks.depend", {
@@ -314,7 +339,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 			break;
 		}
 		default:
-			throw new Error("tasks action must be active, focus, graph, plan, history, scope, assign-project, complete, start, submit, reject, retry, cancel, automate, or depend");
+			throw new Error("tasks action must be active, focused, focus, pause, unpause, clear-focus, update, graph, plan, history, scope, assign-project, complete, start, submit, reject, retry, cancel, or depend");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -327,11 +352,6 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
-	if (command === "automation") {
-		const client = await connectPapyrusClient();
-		console.log(await runAutomationCli(args.slice(1), client));
-		return;
-	}
 	if (command === "skills") {
 		const client = await connectPapyrusClient();
 		console.log(await runSkillCli(args.slice(1), client));

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 = 4;
+export const SQLITE_SCHEMA_VERSION = 5;
 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;
@@ -43,25 +43,17 @@ export const SKILL_RUN_ID_MAX_LENGTH = 64;
 /** Bounded automatic Pi continuations while a focused Papyrus Task remains. */
 export const TASK_DRIVER_MAX_TURNS = 20;
 export const TASK_DRIVER_MAX_UNCHANGED_TURNS = 6;
+/** Mutable Task content bounds. */
+export const TASK_TITLE_MAX_LENGTH = 500;
+export const TASK_BODY_MAX_LENGTH = 100_000;
+export const TASK_LABEL_MAX_COUNT = 64;
+export const TASK_LABEL_MAX_LENGTH = 128;
 /** Append-only Task chronology query and evidence bounds. */
 export const TASK_HISTORY_DEFAULT_LIMIT = 25;
 export const TASK_HISTORY_MAX_LIMIT = 100;
 export const TASK_EVENT_MAX_EVIDENCE_BYTES = 65_536;
 export const TASK_EVENT_ACTOR_MAX_LENGTH = 128;
 export const TASK_EVENT_REASON_MAX_LENGTH = 2_000;
-/** Explicitly opt-in supervised Task graph reconciliation bounds. */
-export const TASK_AUTOMATION_INTERVAL_MS = 60_000;
-export const TASK_AUTOMATION_MIN_INTERVAL_MS = 10_000;
-export const TASK_AUTOMATION_MAX_INTERVAL_MS = 3_600_000;
-export const TASK_AUTOMATION_MAX_TASKS_PER_SWEEP = 10;
-export const TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP = 100;
-export const TASK_AUTOMATION_GATE_CONCURRENCY = 1;
-export const TASK_AUTOMATION_MAX_GATE_CONCURRENCY = 4;
-export const TASK_AUTOMATION_MAX_RUNTIME_MS = 120_000;
-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;