@danypops/papyrus 0.7.0 → 0.9.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:
 
@@ -185,9 +174,11 @@ checklist: {
 
 Proof types are `file`, `symbol`, `code`, `test`, `command`, `artifact`, and `url`. Existing array checklists remain readable as legacy items with `proof: missing`; Papyrus does not invent evidence.
 
-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.
+Papyrus also injects an Alef-style reconciliation block at `before_agent_start` 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.
+
+After assembling each system-prompt addition, Papyrus emits a versioned `papyrus.context-injection.v1` observation on Pi's shared extension event bus. It contains only exact byte/character sizes, Rule count, a labeled token estimate, prompt share, sequence, and a SHA-256 payload fingerprint; Rule/Task text, prompts, project paths, and credentials are never included. Jittor can persist and assess these observations without Papyrus maintaining a second telemetry store.
 
-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 +193,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/context-injection-telemetry.ts

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import {
+	CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN,
+	PAPYRUS_CONTEXT_INJECTION_SCHEMA,
+} from "../../src/constants.ts";
+import type { Artifact } from "../../src/domain/artifact.ts";
+import { ruleInjectionPreview } from "./rules.ts";
+
+export interface ContextPayloadSize {
+	characters: number;
+	bytes: number;
+}
+
+export interface PapyrusContextInjectionObservation {
+	schema: typeof PAPYRUS_CONTEXT_INJECTION_SCHEMA;
+	observedAt: number;
+	sequence: number;
+	producerId: string;
+	before: ContextPayloadSize;
+	rules: ContextPayloadSize & { count: number };
+	tasks: ContextPayloadSize;
+	injected: ContextPayloadSize;
+	after: ContextPayloadSize;
+	estimatedTokens: number;
+	share: number;
+	fingerprint: string;
+	unchanged: boolean;
+}
+
+export interface BuildContextInjectionInput {
+	basePrompt: string;
+	rules: Array<Pick<Artifact, "title" | "body" | "extra">>;
+	taskSummary: string | null;
+	observedAt: number;
+	sequence: number;
+	producerId: string;
+	previousFingerprint?: string;
+}
+
+const encoder = new TextEncoder();
+
+function size(value: string): ContextPayloadSize {
+	return { characters: value.length, bytes: encoder.encode(value).byteLength };
+}
+
+export function buildContextInjection(input: BuildContextInjectionInput): {
+	prompt: string;
+	ruleBlock: string;
+	taskBlock: string;
+	observation: PapyrusContextInjectionObservation;
+} {
+	const ruleContent = input.rules.map(ruleInjectionPreview).join("\n");
+	const ruleBlock = ruleContent ? `\n\n## Active rules (Papyrus)\n\n${ruleContent}\n` : "";
+	const taskBlock = input.taskSummary ? `\n\n## Open tasks (Papyrus)\n\n${input.taskSummary}\n` : "";
+	const injected = `${ruleBlock}${taskBlock}`;
+	const prompt = `${input.basePrompt}${injected}`;
+	const fingerprint = createHash("sha256").update(injected).digest("hex");
+	const injectedSize = size(injected);
+	const afterSize = size(prompt);
+	return {
+		prompt,
+		ruleBlock,
+		taskBlock,
+		observation: {
+			schema: PAPYRUS_CONTEXT_INJECTION_SCHEMA,
+			observedAt: input.observedAt,
+			sequence: input.sequence,
+			producerId: input.producerId,
+			before: size(input.basePrompt),
+			rules: { ...size(ruleBlock), count: input.rules.length },
+			tasks: size(taskBlock),
+			injected: injectedSize,
+			after: afterSize,
+			estimatedTokens: Math.ceil(injectedSize.characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN),
+			share: afterSize.characters === 0 ? 0 : injectedSize.characters / afterSize.characters,
+			fingerprint,
+			unchanged: input.previousFingerprint === fingerprint,
+		},
+	};
+}

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

@@ -7,12 +7,14 @@
  * Injection: active rules + open tasks appended to system prompt every turn.
  *             "Are we there yet?" — the agent sees its open work items.
  */
+import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext, ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import {
 	TASK_DRIVER_MAX_TURNS,
 	TASK_DRIVER_MAX_UNCHANGED_TURNS,
+	PAPYRUS_CONTEXT_INJECTION_CHANNEL,
 } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { GateResult } from "../../src/domain/gate.ts";
@@ -20,9 +22,10 @@ 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";
+import { buildContextInjection } from "./context-injection-telemetry.ts";
 
 function text(t: string, details: Record<string, unknown> = {}) {
 	return { content: [{ type: "text" as const, text: t }], details };
@@ -41,7 +44,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, "…"));
@@ -130,6 +133,9 @@ class TaskOverlay {
 
 export default async function (pi: ExtensionAPI) {
 	registerDomainTools(pi);
+	let contextInjectionSequence = 0;
+	const contextInjectionProducerId = randomUUID();
+	let previousContextInjectionFingerprint: string | undefined;
 	const taskContinuation = new ActiveTaskContinuation({
 		maxTurns: TASK_DRIVER_MAX_TURNS,
 		maxUnchangedTurns: TASK_DRIVER_MAX_UNCHANGED_TURNS,
@@ -149,8 +155,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 +372,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); });
@@ -377,17 +397,18 @@ export default async function (pi: ExtensionAPI) {
 				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) {
-				const block = rules.map(rulesModule.ruleInjectionPreview).join("\n");
-				prompt += `\n\n## Active rules (Papyrus)\n\n${block}\n`;
-			}
-			if (summary) {
-				prompt += `\n\n## Open tasks (Papyrus)\n\n${summary}\n`;
-			}
-			if (prompt !== (event.systemPrompt ?? "")) {
-				return { systemPrompt: prompt };
-			}
+			const injection = buildContextInjection({
+				basePrompt: event.systemPrompt ?? "",
+				rules,
+				taskSummary: summary,
+				observedAt: Date.now(),
+				sequence: ++contextInjectionSequence,
+				producerId: contextInjectionProducerId,
+				previousFingerprint: previousContextInjectionFingerprint,
+			});
+			previousContextInjectionFingerprint = injection.observation.fingerprint;
+			pi.events.emit(PAPYRUS_CONTEXT_INJECTION_CHANNEL, injection.observation);
+			if (injection.prompt !== (event.systemPrompt ?? "")) return { systemPrompt: injection.prompt };
 		} catch {
 			// DB not ready
 		}

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.9.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 } : {}) };
+	}
 }