@danypops/papyrus 0.21.6 → 0.22.0

package/README.md

@@ -119,9 +119,9 @@ Agent-facing domain tools own lifecycle invariants and sit above this store API:
 
 - **`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
 - **`notes`** — capture/list/show deferred human intent, mark it consumed, promote it to an existing Task/Doc/Rule/Skill, or archive it with an explicit disposition
-- **`docs`** — create/list/show, activate/archive/reopen, and document-safe graph links; Note mutations remain behind the Notes facade
-- **`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
+- **`docs`** — create/update/list/show, activate/archive/reopen, and document-safe graph links; Note mutations remain behind the Notes facade
+- **`rules`** — create/update/list/show/preview, enable/disable, and attach governance gates to tasks
+- **`skills`** — create/update/list/show/invoke/run, enable/disable, create compatibility templates, and atomically instantiate parameterized workflow runs
 
 Every tool operation is registered in the daemon’s `/api/v1/ops` registry; parity is verified in tests. The task consumer uses the `tasks.graph` operation, which returns task nodes with explicit parent, child, and dependency IDs rather than leaking SQLite rows or asking the UI to reconstruct relationships.
 
@@ -131,14 +131,18 @@ Internally, application services depend on the `ArtifactStore` and `GateRunner`
 
 Every agent domain tool (tasks, docs, rules, skills, notes, discuss) addresses its artifacts by `name` (the exact title) wherever `id` would otherwise be required -- `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` (tasks), `target_name` (docs link, searches every kind since a link target can be any of them), `task_name` (rules gate, discuss block/unblock), `template_name` (skills instantiate), and `blocks_task_names` (discuss open) are the name-based equivalents of their `*_id` counterparts. Resolution is an exact, case-insensitive, trimmed title match scoped like a plain list call; an unmatched or ambiguous name fails with a clear error (ambiguous names list the real ids, since that's the one point disambiguation genuinely needs them). Results returned to the agent likewise lead with name and status, never id, unless two artifacts in the same result share a title -- id is a backend implementation detail, not a conversational handle. `id` itself still works exactly as before for every action, in every tool.
 
+### Mutability
+
+Tasks, Docs, Rules, and Skills all support first-class `update` (title/body/labels, at least one required) alongside creation -- a Doc's body is no longer immutable once created. Every update is bounded the same way creation is (Rules keep their own stricter combined condition+action+body ceiling; Docs/Skills share Tasks' own length bounds) and recorded on the artifact's append-only mutation history, queryable via `graph.history`. An artifact carrying a `source:<system>` label (e.g. `source:web-spider` on an ingested page) is a read-only projection from a system Papyrus doesn't own the source of; updating one is refused with a clear error rather than silently forking it -- capture a correction as a new linked Doc instead until a write-back capability to that system exists. Notes stay behind their own facade for any content change, same as every other Notes mutation.
+
 ## Interactive frontends
 
 - `/tasks` — project/focused-graph scope, task lifecycle, append-only history, gates, dependencies, and nested metadata
 - `/note <request>` — directly capture one project-scoped deferred request without creating a Task
 - `/notes` — searchable project Notes inbox with consume, promote, and disposition-aware archive actions
-- `/docs` — searchable non-Note 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
+- `/docs` — searchable non-Note documents, lifecycle, details, edit, and graph links
+- `/rules` — severity/condition rows, exact injection preview, edit, enable/disable, and task gating
+- `/skills` — trigger/tools rows, edit, invocation into the editor, and artifact templates
 
 All frontends use daemon-backed domain operations; none opens SQLite from the Pi process. **Show details** opens a bounded navigable view across Tasks, Notes, Docs, Rules, legacy Skills, templates, and workflow Skills. User-authored bodies render as width-aware Markdown with headings, emphasis, links, quotes, lists, tables, inline/fenced code, syntax highlighting, and every color/decorative style derived dynamically from the active Pi theme. Generated lifecycle, metadata, checklist, gate, history, and relationship sections keep explicit semantic theme colors. `↑/↓` scrolls, `←/→` pans wide relationships, and Esc returns to the browser; non-interactive clients receive stable source text.
 

package/extension/src/discussion-picker.ts

@@ -6,12 +6,12 @@
  * anywhere in @earendil-works/pi-coding-agent or pi-tui (checked both) -- so this is a small,
  * genuinely domain-specific checkbox-list component, not a generic library replacement.
  */
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import type { DiscussionOptionsMode } from "../../src/domain/discussion.ts";
 
 /** Toggle with space, confirm with enter (refuses an empty confirm -- at least one pick is required), cancel with escape. */
-async function pickMultiple(ctx: ExtensionCommandContext, title: string, options: string[]): Promise<string[] | undefined> {
+async function pickMultiple(ctx: ExtensionContext, title: string, options: string[]): Promise<string[] | undefined> {
 	return ctx.ui.custom<string[] | undefined>((tui, theme, _keybindings, done) => {
 		const checked = new Set<number>();
 		let selectedIndex = 0;
@@ -49,8 +49,13 @@ async function pickMultiple(ctx: ExtensionCommandContext, title: string, options
 	});
 }
 
-/** Picks one (single) or several (multi) of the given options, or undefined if the user cancels. */
-export async function pickDiscussionOptions(ctx: ExtensionCommandContext, mode: DiscussionOptionsMode, options: string[]): Promise<string[] | undefined> {
+/**
+ * Picks one (single) or several (multi) of the given options, or undefined if the user cancels.
+ * Takes the base ExtensionContext (just .ui) rather than the wider ExtensionCommandContext, since
+ * a tool's execute() only ever receives the former -- the discuss tool's own live mode reuses
+ * this same picker, not just the /discuss TUI panel.
+ */
+export async function pickDiscussionOptions(ctx: ExtensionContext, mode: DiscussionOptionsMode, options: string[]): Promise<string[] | undefined> {
 	if (mode === "single") {
 		const pick = await ctx.ui.select("Pick one:", options);
 		return pick ? [pick] : undefined;

package/extension/src/docs.ts

@@ -24,12 +24,21 @@ export async function showDocs(ctx: ExtensionCommandContext): Promise<void> {
 		statusOrder: ["draft", "active", "archived"],
 		presentation: DOC_STATUS_PRESENTATION,
 		rowMeta: documentRowMeta,
-		actions: (document) => ["Show details", "Link artifact", ...(DOC_ACTIONS[document.status] ?? [])],
+		actions: (document) => ["Show details", "Edit", "Link artifact", ...(DOC_ACTIONS[document.status] ?? [])],
 		handleAction: async (choice, document, commandCtx) => {
 			if (choice === "Show details") {
 				await showArtifactDetails(commandCtx, document.id, "docs.show");
 				return;
 			}
+			if (choice === "Edit") {
+				const title = await commandCtx.ui.input("Title:", document.title);
+				if (title === undefined) return; // canceled
+				const body = await commandCtx.ui.input("Body:", document.body);
+				if (body === undefined) return; // canceled
+				const updated = await callService<Record<string, unknown>, Artifact>("docs.update", { id: document.id, title, body });
+				commandCtx.ui.notify(`Updated "${updated.title}"`, "info");
+				return;
+			}
 			if (choice === "Link artifact") {
 				const targetId = await commandCtx.ui.input("Target artifact id:", "");
 				if (!targetId) return;

package/extension/src/domain-tools.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import { PROOF_TYPES } from "../../src/domain/checklist.ts";
@@ -8,7 +8,8 @@ import type { TaskHistoryPage } from "../../src/domain/task-event.ts";
 import type { TaskCompletion, TaskGraph } from "../../src/task-service.ts";
 import type { SkillWorkflowRunResult } from "../../src/skill-execution.ts";
 import type { DiscussionAndRounds } from "../../src/discussion-service.ts";
-import type { DiscussionRound } from "../../src/domain/discussion.ts";
+import { readDiscussionExtra, type DiscussionRound } from "../../src/domain/discussion.ts";
+import { pickDiscussionOptions } from "./discussion-picker.ts";
 import type { OperationName } from "../../src/service.ts";
 import { emitTaskFocusEvent } from "./task-focus-events.ts";
 import { sessionSecretField } from "./session-identity.ts";
@@ -30,6 +31,24 @@ function text(message: string, details: unknown = {}) {
 	return { content: [{ type: "text" as const, text: modelContent.text }], details };
 }
 
+/**
+ * live:true's synchronous half: renders the same picker /discuss's own "Reply" action uses when
+ * the just-created round posed a structured choice, or a plain freeform prompt otherwise -- so
+ * "ask" covers both a completely open question and a choice tied to this specific Discussion.
+ * Returns undefined on cancel or when no interactive UI is available, never throws -- an
+ * unanswered live prompt still leaves the round it already recorded intact.
+ */
+async function liveAnswer(ctx: ExtensionContext, discussion: Artifact): Promise<{ content: string; selected?: string[] } | undefined> {
+	if (!ctx.hasUI) return undefined;
+	const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
+	if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
+		const selected = await pickDiscussionOptions(ctx, pending.pendingOptionsMode, pending.pendingOptions);
+		return selected ? { content: selected.join(", "), selected } : undefined;
+	}
+	const content = await ctx.ui.input(`Reply to "${discussion.title}":`, "");
+	return content ? { content } : undefined;
+}
+
 /**
  * Every domain tool's primary interfacing point is an artifact's NAME, not its id -- id is a
  * backend implementation detail (a stable key other operations need, and titles aren't
@@ -397,7 +416,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "docs",
 		label: "Documents",
-		description: "Document domain tool. ACTIONS: create, list, show, activate, archive, reopen, link, assign_project, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. remove moves a Doc to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the doc's exact title) over `id`, and `target_name` over `target_id` for link -- both are backend implementation details, resolved from name automatically (target_name searches across every kind, since a link target can be a doc, task, rule, or skill). Prefer this over low-level papyrus_* tools for document work.",
+		description: "Document domain tool. ACTIONS: create, list, show, activate, archive, reopen, link, assign_project, update, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. update changes title/body/labels (at least one required) and is refused for a read-only external projection (e.g. web-spider-ingested Docs) -- capture a correction as a new linked Doc instead. remove moves a Doc to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the doc's exact title) over `id`, and `target_name` over `target_id` for link -- both are backend implementation details, resolved from name automatically (target_name searches across every kind, since a link target can be a doc, task, rule, or skill). Prefer this over low-level papyrus_* tools for document work.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -443,7 +462,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				}
 				const trashResult = await handleArtifactRemoveRestore(action, params);
 				if (trashResult) return trashResult;
-				const operations = { activate: "docs.activate", archive: "docs.archive", reopen: "docs.reopen", link: "docs.link", assign_project: "docs.assign_project" } as const;
+				const operations = { activate: "docs.activate", archive: "docs.archive", reopen: "docs.reopen", link: "docs.link", assign_project: "docs.assign_project", update: "docs.update" } as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) throw new Error(`unknown docs action: ${action}`);
 				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
@@ -457,7 +476,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "rules",
 		label: "Rules",
-		description: "Rule domain tool. ACTIONS: create, list, show, preview, enable, disable, gate, assign_project, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. Active rules inject into the agent system prompt. remove moves a Rule to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the rule's exact title) over `id`, and `task_name` over `task_id` for gate -- both are backend implementation details, resolved from name automatically.",
+		description: "Rule domain tool. ACTIONS: create, list, show, preview, enable, disable, gate, assign_project, update, remove, restore. project_root is optional at creation (omitted = unscoped); assign_project reassigns it later, or unscopes when project_root is omitted. Active rules inject into the agent system prompt. update changes title/body/labels (at least one required); body updates still enforce the same combined condition+action+body context-tax bound as creation, and are refused for a read-only external projection. remove moves a Rule to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the rule's exact title) over `id`, and `task_name` over `task_id` for gate -- both are backend implementation details, resolved from name automatically.",
 		parameters: Type.Object({
 			action: Type.String(), id: Type.Optional(Type.String()), name: Type.Optional(Type.String()), title: Type.Optional(Type.String()),
 			body: Type.Optional(Type.String()), condition: Type.Optional(Type.String()), rule_action: Type.Optional(Type.String()),
@@ -491,7 +510,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				}
 				const trashResult = await handleArtifactRemoveRestore(action, params);
 				if (trashResult) return trashResult;
-				const operations = { show: "rules.show", enable: "rules.enable", disable: "rules.disable", gate: "rules.gate", assign_project: "rules.assign_project" } as const;
+				const operations = { show: "rules.show", enable: "rules.enable", disable: "rules.disable", gate: "rules.gate", assign_project: "rules.assign_project", update: "rules.update" } as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) throw new Error(`unknown rules action: ${action}`);
 				const artifact = await callService<Record<string, unknown>, Artifact>(operation, params);
@@ -505,7 +524,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "skills",
 		label: "Skills",
-		description: "Papyrus Skill workflow and compatibility-template domain tool. Papyrus Skills are parameterized Task/Rule/Doc bundles, distinct from prompt-only skills. ACTIONS: create, create_template, list, show, invoke, run, enable, disable, instantiate, assign_project, remove, restore. run validates arguments and atomically creates one scoped workflow run. project_root is optional at creation (omitted = unscoped) for create/create_template; assign_project reassigns it later, or unscopes when project_root is omitted. remove moves a Skill to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the skill's exact title) over `id`, and `template_name` over `template_id` for instantiate -- both are backend implementation details, resolved from name automatically.",
+		description: "Papyrus Skill workflow and compatibility-template domain tool. Papyrus Skills are parameterized Task/Rule/Doc bundles, distinct from prompt-only skills. ACTIONS: create, create_template, list, show, invoke, run, enable, disable, instantiate, assign_project, update, remove, restore. run validates arguments and atomically creates one scoped workflow run. project_root is optional at creation (omitted = unscoped) for create/create_template; assign_project reassigns it later, or unscopes when project_root is omitted. update changes title/body/labels (at least one required) and is refused for a read-only external projection. remove moves a Skill to a time-gated trash, excluded from list/query but still directly showable, restorable via restore until the purge deadline. PREFER `name` (the skill's exact title) over `id`, and `template_name` over `template_id` for instantiate -- both are backend implementation details, resolved from name automatically.",
 		parameters: Type.Object({
 			action: Type.String(), id: Type.Optional(Type.String()), name: Type.Optional(Type.String()), title: Type.Optional(Type.String()),
 			body: Type.Optional(Type.String()), trigger: Type.Optional(Type.String()), steps: Type.Optional(Type.Array(Type.String())),
@@ -570,7 +589,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 				}
 				const trashResult = await handleArtifactRemoveRestore(action, params);
 				if (trashResult) return trashResult;
-				const operations = { show: "skills.show", enable: "skills.enable", disable: "skills.disable", instantiate: "skills.instantiate", assign_project: "skills.assign_project" } as const;
+				const operations = { show: "skills.show", enable: "skills.enable", disable: "skills.disable", instantiate: "skills.instantiate", assign_project: "skills.assign_project", update: "skills.update" } as const;
 				const operation = operations[action as keyof typeof operations];
 				if (!operation) throw new Error(`unknown skills action: ${action}`);
 				const artifact = await callService<Record<string, unknown>, Artifact>(operation, action === "instantiate" ? request : params);
@@ -584,7 +603,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "discuss",
 		label: "Discuss",
-		description: "Native Papyrus deliberation with a real lifecycle -- distinct from a one-shot ask: a Discussion persists, takes multiple rounds, and can genuinely block a Task's completion until settled or deferred. ACTIONS: open, reply, defer, resume, settle, block, unblock, show, rounds, list. open starts round 1 and optionally blocks_task_ids immediately. reply is refused once deferred or settled -- resume first. defer is explicitly non-blocking (paused, resumable); settle is terminal and archives the discussion. block/unblock manage the blocking relationship to a task independently of open. A task's completion is refused while any active Discussion blocks it. open/reply can pose a structured choice via options (2-10 entries) + options_mode ('single' mutually exclusive, 'multi' allows several); reply answers a currently pending choice via selected, validated against it. PREFER `name` (the discussion's exact title) over `id`, `task_name`/`blocks_task_names` over `task_id`/`blocks_task_ids` -- all are backend implementation details, resolved from name automatically.",
+		description: "Native Papyrus deliberation with a real lifecycle -- distinct from a one-shot ask: a Discussion persists, takes multiple rounds, and can genuinely block a Task's completion until settled or deferred. ACTIONS: open, reply, defer, resume, settle, block, unblock, show, rounds, list. open starts round 1 and optionally blocks_task_ids immediately. reply is refused once deferred or settled -- resume first. defer is explicitly non-blocking (paused, resumable); settle is terminal and archives the discussion. block/unblock manage the blocking relationship to a task independently of open. A task's completion is refused while any active Discussion blocks it. open/reply can pose a structured choice via options (2-10 entries) + options_mode ('single' mutually exclusive, 'multi' allows several); reply answers a currently pending choice via selected, validated against it. Pass live:true on open or reply to get the human's answer synchronously in this same call, via an interactive prompt (the pending choice's picker if one was posed, otherwise a freeform question) -- covers a completely open question with no artifact (open with no prior discussion) and a question tied to a specific existing artifact (reply, addressed by name) alike. Only takes effect with an interactive UI available; otherwise degrades silently to the normal async round. PREFER `name` (the discussion's exact title) over `id`, `task_name`/`blocks_task_names` over `task_id`/`blocks_task_ids` -- all are backend implementation details, resolved from name automatically.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -606,6 +625,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			options: Type.Optional(Type.Array(Type.String())),
 			options_mode: Type.Optional(Type.String()),
 			selected: Type.Optional(Type.Array(Type.String())),
+			live: Type.Optional(Type.Boolean()),
 		}),
 		renderCall(args, theme) { return renderPapyrusToolCall("Discuss", args, theme); },
 		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
@@ -619,13 +639,19 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 					{ nameKey: "task_name", idKey: "task_id", listOperation: "tasks.list", baseRequest: taskScope },
 				]);
 				await resolveNameArrayField(params, "blocks_task_names", "blocks_task_ids", "tasks.list", taskScope);
-				if (action === "open") {
-					const result = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.open", params);
-					return text(`Opened discussion ${artifactLine(result.discussion)}`, createArtifactDetails("discuss.open", result.discussion));
-				}
-				if (action === "reply") {
-					const result = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.reply", params);
-					return text(`Round ${result.rounds[0]?.roundNumber} added to "${result.discussion.title}"`, createArtifactDetails("discuss.reply", result.discussion));
+				if (action === "open" || action === "reply") {
+					const operation = action === "open" ? "discuss.open" : "discuss.reply";
+					const result = await callService<Record<string, unknown>, DiscussionAndRounds>(operation, params);
+					const fallback = action === "open"
+						? text(`Opened discussion ${artifactLine(result.discussion)}`, createArtifactDetails("discuss.open", result.discussion))
+						: text(`Round ${result.rounds[0]?.roundNumber} added to "${result.discussion.title}"`, createArtifactDetails("discuss.reply", result.discussion));
+					if (params.live !== true) return fallback;
+					const answer = await liveAnswer(ctx, result.discussion);
+					if (!answer) return fallback;
+					const answered = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.reply", {
+						id: result.discussion.id, actor: "human", content: answer.content, ...(answer.selected ? { selected: answer.selected } : {}), source: "discuss-live",
+					});
+					return text(`"${answered.discussion.title}": ${answer.content}`, createArtifactDetails("discuss.reply", answered.discussion));
 				}
 				if (action === "block" || action === "unblock") {
 					const operation = action === "block" ? "discuss.block" : "discuss.unblock";

package/extension/src/rules.ts

@@ -25,10 +25,17 @@ export async function showRules(ctx: ExtensionCommandContext): Promise<void> {
 		statusOrder: ["active", "deprecated"],
 		presentation: RULE_STATUS_PRESENTATION,
 		rowMeta: ruleRowMeta,
-		actions: (rule) => ["Show details", "Preview injection", "Link gated task", rule.status === "active" ? "Disable" : "Enable"],
+		actions: (rule) => ["Show details", "Edit", "Preview injection", "Link gated task", rule.status === "active" ? "Disable" : "Enable"],
 		handleAction: async (choice, rule, commandCtx) => {
 			if (choice === "Show details") await showArtifactDetails(commandCtx, rule.id, "rules.show");
-			else if (choice === "Preview injection") {
+			else if (choice === "Edit") {
+				const title = await commandCtx.ui.input("Title:", rule.title);
+				if (title === undefined) return; // canceled
+				const body = await commandCtx.ui.input("Body:", rule.body);
+				if (body === undefined) return; // canceled
+				const updated = await callService<Record<string, unknown>, Artifact>("rules.update", { id: rule.id, title, body });
+				commandCtx.ui.notify(`Updated "${updated.title}"`, "info");
+			} else if (choice === "Preview injection") {
 				const preview = await callService<Record<string, unknown>, string>("rules.preview", { id: rule.id });
 				commandCtx.ui.notify(preview, "info");
 			} else if (choice === "Link gated task") {

package/extension/src/skills.ts

@@ -76,12 +76,20 @@ export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
 		rowMeta: skillRowMeta,
 		actions: (skill) => [
 			"Show details",
+			"Edit",
 			skill.subtype === "artifact-template" ? "Use template" : skill.subtype === "workflow" ? "Run workflow" : "Invoke skill",
 			skill.status === "active" ? "Disable" : "Enable",
 		],
 		handleAction: async (choice, skill, commandCtx) => {
 			if (choice === "Show details") await showArtifactDetails(commandCtx, skill.id, "skills.show");
-			else if (choice === "Run workflow") {
+			else if (choice === "Edit") {
+				const title = await commandCtx.ui.input("Title:", skill.title);
+				if (title === undefined) return; // canceled
+				const body = await commandCtx.ui.input("Body:", skill.body);
+				if (body === undefined) return; // canceled
+				const updated = await callService<Record<string, unknown>, Artifact>("skills.update", { id: skill.id, title, body });
+				commandCtx.ui.notify(`Updated "${updated.title}"`, "info");
+			} else if (choice === "Run workflow") {
 				const source = await commandCtx.ui.input("Workflow arguments JSON:", "{}");
 				if (source === undefined) return;
 				try {

package/package.json

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

package/src/authority-registry.ts

@@ -22,7 +22,7 @@ import type { ArtifactEventContext } from "./domain/artifact-event.ts";
 import type { Artifact, ArtifactLink } from "./domain/artifact.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 
-export type ArtifactAction = "create" | "link" | "status";
+export type ArtifactAction = "create" | "link" | "status" | "update";
 
 export interface AuthorityClaim {
 	/** Module id that owns this kind/subtype/relation, e.g. "notes", "tasks". */

package/src/cli.ts

@@ -92,6 +92,7 @@ const USAGE = `Usage:
   papyrus docs activate|archive|reopen <id> [--json]
   papyrus docs link <id> <relation> <target-id> [--json]
   papyrus docs assign-project <id> [project-root] [--json]
+  papyrus docs update <id> [--title <title>] [--body <body>] [--labels-json <json>] [--json]
   papyrus rules create --title <title> [--body <body>] [--condition <text>] [--rule-action <text>] [--severity block|warn|info] [--labels-json <json>] [--extra-json <json>] [--project-root <path>] [--json]
   papyrus rules list [--status <status>] [--text <query>] [--limit <count>] [--project-root <path>] [--json]
   papyrus rules show <id> [--json]
@@ -100,6 +101,7 @@ const USAGE = `Usage:
   papyrus rules gate <rule-id> <task-id> [--json]
   papyrus rules injectable [--json]
   papyrus rules assign-project <id> [project-root] [--json]
+  papyrus rules update <id> [--title <title>] [--body <body>] [--labels-json <json>] [--json]
   papyrus skills run <id> [--arguments-json <json>] [--run-id <id>] [--json]
   papyrus skills create --title <title> [--body <body>] [--trigger <text>] [--steps-json <json>] [--tools-json <json>] [--definition-json <json>] [--labels-json <json>] [--extra-json <json>] [--project-root <path>] [--json]
   papyrus skills create-template --title <title> --target-kind <kind> [--defaults-json <json>] [--required-json <json>] [--body <body>] [--labels-json <json>] [--project-root <path>] [--json]
@@ -109,6 +111,7 @@ const USAGE = `Usage:
   papyrus skills enable|disable <id> [--json]
   papyrus skills instantiate <template-id> [--title <title>] [--body <body>] [--status <status>] [--labels-json <json>] [--extra-json <json>] [--json]
   papyrus skills assign-project <id> [project-root] [--json]
+  papyrus skills update <id> [--title <title>] [--body <body>] [--labels-json <json>] [--json]
   papyrus notes capture <request> [--title <title>] [--json]
   papyrus notes list [--status <draft|active|archived>] [--text <query>] [--limit <count>] [--json]
   papyrus notes show <id> [--json]
@@ -466,8 +469,16 @@ export async function runSkillCli(args: string[], client: TaskCliClient, project
 			human = `Created: ${artifactLabel(artifact)}`;
 			break;
 		}
+		case "update": {
+			if (!id || second) throw new Error("skills update requires exactly one skill id");
+			if (title === undefined && body === undefined && labels === undefined) throw new Error("skills update requires --title, --body, or --labels-json");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("skills.update", { id, title, body, labels });
+			result = artifact;
+			human = `${artifactLabel(artifact)}`;
+			break;
+		}
 		default:
-			throw new Error("skills action must be run, create, create-template, list, show, invoke, enable, disable, instantiate, or assign-project");
+			throw new Error("skills action must be run, create, create-template, list, show, invoke, enable, disable, instantiate, assign-project, or update");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -632,8 +643,16 @@ export async function runDocsCli(args: string[], client: TaskCliClient): Promise
 			human = `Linked ${id} --${second}--> ${third}`;
 			break;
 		}
+		case "update": {
+			if (!id || second) throw new Error("docs update requires exactly one document id");
+			if (title === undefined && body === undefined && labels === undefined) throw new Error("docs update requires --title, --body, or --labels-json");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("docs.update", { id, title, body, labels });
+			result = artifact;
+			human = `${artifactLabel(artifact)}`;
+			break;
+		}
 		default:
-			throw new Error("docs action must be create, list, show, activate, archive, reopen, link, or assign-project");
+			throw new Error("docs action must be create, list, show, activate, archive, reopen, link, assign-project, or update");
 	}
 	return json ? JSON.stringify(result) : human;
 }
@@ -736,8 +755,16 @@ export async function runRulesCli(args: string[], client: TaskCliClient, project
 			human = rows.length === 0 ? "No injectable rules." : rows.map((row) => row.title).join("\n");
 			break;
 		}
+		case "update": {
+			if (!id || second) throw new Error("rules update requires exactly one rule id");
+			if (title === undefined && body === undefined && labels === undefined) throw new Error("rules update requires --title, --body, or --labels-json");
+			const artifact = await client.call<Record<string, unknown>, CliArtifact>("rules.update", { id, title, body, labels });
+			result = artifact;
+			human = `${artifactLabel(artifact)}`;
+			break;
+		}
 		default:
-			throw new Error("rules action must be create, list, show, preview, enable, disable, gate, injectable, or assign-project");
+			throw new Error("rules action must be create, list, show, preview, enable, disable, gate, injectable, assign-project, or update");
 	}
 	return json ? JSON.stringify(result) : human;
 }

package/src/constants.ts

@@ -119,6 +119,11 @@ 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;
+/** Mutable Doc/Rule/Skill content bounds -- same numbers as Task's, since these are the same kind of freeform content at the same scale. Rules also enforce their own stricter RULE_TEXT_HARD_LIMIT_CHARACTERS on top of this. */
+export const ARTIFACT_TITLE_MAX_LENGTH = 500;
+export const ARTIFACT_BODY_MAX_LENGTH = 100_000;
+export const ARTIFACT_LABEL_MAX_COUNT = 64;
+export const ARTIFACT_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;

package/src/domain/artifact.ts

@@ -67,3 +67,27 @@ export interface RelationshipQuery {
 	artifactIds?: string[];
 	limit?: number;
 }
+
+/**
+ * A label of the form "source:<system>" marks an artifact as ingested/projected from an
+ * external, non-Papyrus system (e.g. web-spider's own "source:web-spider" convention on the
+ * Docs it creates) -- content Papyrus does not own and cannot safely rewrite without silently
+ * diverging from the true source. Editing one directly would look like a correction but really
+ * just be a local fork nobody re-syncs.
+ */
+export const EXTERNAL_SOURCE_LABEL_PREFIX = "source:";
+
+/** The external system name from a "source:<system>" label, or undefined if this artifact has no such label (i.e. it's Papyrus-native content). */
+export function externalSourceOf(artifact: Pick<Artifact, "labels">): string | undefined {
+	const label = artifact.labels.find((entry) => entry.startsWith(EXTERNAL_SOURCE_LABEL_PREFIX));
+	return label === undefined ? undefined : label.slice(EXTERNAL_SOURCE_LABEL_PREFIX.length) || undefined;
+}
+
+/** Throws if the artifact is a read-only external projection; a caller must never silently rewrite content it doesn't own the source of. */
+export function requireLocallyOwnedContent(artifact: Artifact): Artifact {
+	const system = externalSourceOf(artifact);
+	if (system !== undefined) {
+		throw new Error(`"${artifact.title}" is a read-only projection from ${system}; edit it there, or capture a correction as a new linked Doc, until a write-back capability is integrated`);
+	}
+	return artifact;
+}

package/src/domain-services.ts

@@ -1,17 +1,51 @@
 import {
+	ARTIFACT_BODY_MAX_LENGTH,
+	ARTIFACT_LABEL_MAX_COUNT,
+	ARTIFACT_LABEL_MAX_LENGTH,
 	ARTIFACT_SCOPE_MAX_ARTIFACTS,
+	ARTIFACT_TITLE_MAX_LENGTH,
 	RULE_TEXT_HARD_LIMIT_CHARACTERS,
 	SKILL_INVOCATION_MAX_CALL_DEPTH,
 	SKILL_INVOCATION_MAX_LINKED_ARTIFACTS,
 } from "./constants.ts";
-import type { Artifact, CreateArtifactInput } from "./domain/artifact.ts";
+import { requireLocallyOwnedContent, type Artifact, type CreateArtifactInput } from "./domain/artifact.ts";
 import type { ArtifactEventContext } from "./domain/artifact-event.ts";
 import { normalizeProjectRoot } from "./domain/task-scope.ts";
 import { validateSkillDefinition } from "./domain/skill-definition.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { ArtifactScopeStore } from "./ports/artifact-scope-store.ts";
 import { NOTE_SUBTYPE } from "./note-service.ts";
-import type { AuthorityRegistry } from "./authority-registry.ts";
+import { type ArtifactAction, type AuthorityRegistry } from "./authority-registry.ts";
+
+export interface UpdateContentInput {
+	title?: string;
+	body?: string;
+	labels?: string[];
+}
+
+function requireContentUpdateFields(input: UpdateContentInput): void {
+	if (input.title === undefined && input.body === undefined && input.labels === undefined) {
+		throw new Error("update requires title, body, or labels");
+	}
+}
+
+function assertTitleBounds(title: string | undefined): void {
+	if (title !== undefined && (title.trim().length === 0 || title.length > ARTIFACT_TITLE_MAX_LENGTH)) {
+		throw new Error(`title must be between 1 and ${ARTIFACT_TITLE_MAX_LENGTH} characters`);
+	}
+}
+
+function assertBodyBounds(body: string | undefined): void {
+	if (body !== undefined && body.length > ARTIFACT_BODY_MAX_LENGTH) throw new Error(`body cannot exceed ${ARTIFACT_BODY_MAX_LENGTH} characters`);
+}
+
+function assertLabelsBounds(labels: string[] | undefined): void {
+	if (labels === undefined) return;
+	if (labels.length > ARTIFACT_LABEL_MAX_COUNT) throw new Error(`labels cannot exceed ${ARTIFACT_LABEL_MAX_COUNT} entries`);
+	if (labels.some((label) => label.length === 0 || label.length > ARTIFACT_LABEL_MAX_LENGTH)) {
+		throw new Error(`each label must be between 1 and ${ARTIFACT_LABEL_MAX_LENGTH} characters`);
+	}
+}
 
 export interface ListFilter {
 	status?: string;
@@ -83,8 +117,8 @@ function templateSubtype(artifacts: ArtifactStore, templateId: string | undefine
 	return typeof subtype === "string" ? subtype : undefined;
 }
 
-function requireMutableDocument(document: Artifact, authority: AuthorityRegistry): Artifact {
-	authority.requireArtifactAllowed(document.kind, document.subtype, "status", "docs");
+function requireMutableDocument(document: Artifact, authority: AuthorityRegistry, action: ArtifactAction = "status"): Artifact {
+	authority.requireArtifactAllowed(document.kind, document.subtype, action, "docs");
 	return document;
 }
 
@@ -99,6 +133,8 @@ export interface CreateDocumentInput {
 	projectRoot?: string;
 }
 
+export type UpdateDocumentInput = UpdateContentInput;
+
 export type DocumentTransition = "activate" | "archive" | "reopen";
 export type DocumentRelation = "references" | "documents" | "supersedes" | "relates_to" | "contains" | "part_of";
 
@@ -157,6 +193,23 @@ export function transitionDocument(artifacts: ArtifactStore, id: string, action:
 	return artifacts.setStatus(id, transition.to, context)!;
 }
 
+/**
+ * Docs are immutable-by-convention only in the sense that no path existed to change them --
+ * this is that path. A read-only external projection (see requireLocallyOwnedContent) still
+ * refuses, on purpose: rewriting it here would silently fork from whatever system actually
+ * owns it (e.g. web-spider's ingested pages), with nothing to ever reconcile the two again.
+ */
+export function updateDocument(artifacts: ArtifactStore, id: string, input: UpdateDocumentInput, authority: AuthorityRegistry, context?: ArtifactEventContext): Artifact {
+	requireContentUpdateFields(input);
+	assertTitleBounds(input.title);
+	assertBodyBounds(input.body);
+	assertLabelsBounds(input.labels);
+	const document = requireLocallyOwnedContent(requireMutableDocument(requireDocument(artifacts, id), authority, "update"));
+	const updated = artifacts.updateContent(id, input, context);
+	if (!updated) throw new Error(`document "${id}" not found`);
+	return updated;
+}
+
 export function linkDocument(artifacts: ArtifactStore, id: string, relation: DocumentRelation, targetId: string, authority: AuthorityRegistry, context?: ArtifactEventContext): Artifact {
 	requireMutableDocument(requireDocument(artifacts, id), authority);
 	const target = artifacts.get(targetId);
@@ -258,6 +311,24 @@ export function transitionRule(artifacts: ArtifactStore, id: string, action: Rul
 	return artifacts.setStatus(id, target, context)!;
 }
 
+export type UpdateRuleInput = UpdateContentInput;
+
+/** A Rule's body update stays under the same combined condition+action+body ceiling as creation -- a permanent per-turn injection cost doesn't get looser just because it's an edit, not a create. */
+export function updateRule(artifacts: ArtifactStore, id: string, input: UpdateRuleInput, context?: ArtifactEventContext): Artifact {
+	requireContentUpdateFields(input);
+	assertTitleBounds(input.title);
+	assertLabelsBounds(input.labels);
+	const rule = requireLocallyOwnedContent(requireKind(artifacts, id, "rule"));
+	if (input.body !== undefined) {
+		const condition = typeof rule.extra["condition"] === "string" ? rule.extra["condition"] : undefined;
+		const action = typeof rule.extra["action"] === "string" ? rule.extra["action"] : undefined;
+		assertRuleTextWithinBounds(condition, action, input.body);
+	}
+	const updated = artifacts.updateContent(id, input, context);
+	if (!updated) throw new Error(`rule "${id}" not found`);
+	return updated;
+}
+
 export function gateTaskWithRule(artifacts: ArtifactStore, ruleId: string, taskId: string, context?: ArtifactEventContext): Artifact {
 	requireKind(artifacts, ruleId, "rule");
 	requireKind(artifacts, taskId, "task");
@@ -353,6 +424,19 @@ export function showSkill(artifacts: ArtifactStore, id: string): Artifact {
 	return artifacts.get(id, { tree: true })!;
 }
 
+export type UpdateSkillInput = UpdateContentInput;
+
+export function updateSkill(artifacts: ArtifactStore, id: string, input: UpdateSkillInput, context?: ArtifactEventContext): Artifact {
+	requireContentUpdateFields(input);
+	assertTitleBounds(input.title);
+	assertBodyBounds(input.body);
+	assertLabelsBounds(input.labels);
+	const skill = requireLocallyOwnedContent(requireKind(artifacts, id, "skill"));
+	const updated = artifacts.updateContent(skill.id, input, context);
+	if (!updated) throw new Error(`skill "${id}" not found`);
+	return updated;
+}
+
 function skillInvocationBody(skill: Artifact): string {
 	if (skill.subtype === "artifact-template") {
 		return `Create an artifact using Papyrus template "${skill.title}".\ntemplate_id: ${skill.id}\nAsk for or infer all required template fields, then call the skills domain tool instantiate action.`;

package/src/modules/docs.ts

@@ -7,7 +7,7 @@
  * ArtifactStore-based with no other module's concrete class dependency.
  */
 import type { AuthorityRegistry } from "../authority-registry.ts";
-import { assignDocumentProject, createDocument, linkDocument, listDocuments, showDocument, transitionDocument, type DocumentRelation } from "../domain-services.ts";
+import { assignDocumentProject, createDocument, linkDocument, listDocuments, showDocument, transitionDocument, updateDocument, type DocumentRelation } from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -52,7 +52,7 @@ const artifactFilter = (input: OperationInput) => ({
 /** Registers every docs.* operation against the shared ArtifactStore port. Behavior is unchanged from the prior inline handlers in src/service.ts. */
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const DOCS_OPERATION_NAMES = [
-	"docs.create", "docs.list", "docs.show", "docs.activate", "docs.archive", "docs.reopen", "docs.link", "docs.assign_project",
+	"docs.create", "docs.list", "docs.show", "docs.activate", "docs.archive", "docs.reopen", "docs.link", "docs.assign_project", "docs.update",
 ] as const;
 
 export function docsOperations(artifacts: ArtifactStore, scopes: ArtifactScopeStore, authority: AuthorityRegistry): OperationDefinition[] {
@@ -73,5 +73,8 @@ export function docsOperations(artifacts: ArtifactStore, scopes: ArtifactScopeSt
 		define("docs.reopen", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "reopen", authority, eventContext(input))),
 		define("docs.link", (input: OperationInput) => linkDocument(artifacts, string(input, "id"), string(input, "relation") as DocumentRelation, string(input, "target_id"), authority, eventContext(input))),
 		define("docs.assign_project", (input: OperationInput) => assignDocumentProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),
+		define("docs.update", (input: OperationInput) => updateDocument(artifacts, string(input, "id"), {
+			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
+		}, authority, eventContext(input))),
 	];
 }

package/src/modules/rules.ts

@@ -10,7 +10,7 @@
  * into this module or introducing a premature "modules call each other through the
  * registry" convention.
  */
-import { assignRuleProject, createRule, gateTaskWithRule, listRules, previewRule, showRule, transitionRule } from "../domain-services.ts";
+import { assignRuleProject, createRule, gateTaskWithRule, listRules, previewRule, showRule, transitionRule, updateRule } from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -55,7 +55,7 @@ const artifactFilter = (input: OperationInput) => ({
 /** Registers every rules.* operation except rules.injectable (see module comment). Behavior is unchanged from the prior inline handlers in src/service.ts. */
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. rules.injectable is deliberately absent -- see the module comment above. */
 export const RULES_OPERATION_NAMES = [
-	"rules.create", "rules.list", "rules.show", "rules.preview", "rules.enable", "rules.disable", "rules.gate", "rules.assign_project",
+	"rules.create", "rules.list", "rules.show", "rules.preview", "rules.enable", "rules.disable", "rules.gate", "rules.assign_project", "rules.update",
 ] as const;
 
 export function rulesOperations(artifacts: ArtifactStore, scopes: ArtifactScopeStore): OperationDefinition[] {
@@ -77,5 +77,8 @@ export function rulesOperations(artifacts: ArtifactStore, scopes: ArtifactScopeS
 		define("rules.disable", (input: OperationInput) => transitionRule(artifacts, string(input, "id"), "disable", eventContext(input))),
 		define("rules.gate", (input: OperationInput) => gateTaskWithRule(artifacts, string(input, "id"), string(input, "task_id"), eventContext(input))),
 		define("rules.assign_project", (input: OperationInput) => assignRuleProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),
+		define("rules.update", (input: OperationInput) => updateRule(artifacts, string(input, "id"), {
+			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
+		}, eventContext(input))),
 	];
 }

package/src/modules/skills.ts

@@ -17,7 +17,7 @@
  * extraction.
  */
 import type { AuthorityRegistry } from "../authority-registry.ts";
-import { assignSkillProject, createArtifactTemplate, createSkill, listSkills, showSkill, skillInvocation, transitionSkill } from "../domain-services.ts";
+import { assignSkillProject, createArtifactTemplate, createSkill, listSkills, showSkill, skillInvocation, transitionSkill, updateSkill } from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -79,7 +79,7 @@ export interface SkillsModuleDeps {
 /** Registers every skills.* operation except skills.instantiate (see module comment). Behavior is unchanged from the prior inline handlers in src/service.ts. */
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. skills.instantiate is deliberately absent -- see the module comment above. */
 export const SKILLS_OPERATION_NAMES = [
-	"skills.create", "skills.create_template", "skills.list", "skills.show", "skills.invoke", "skills.run", "skills.enable", "skills.disable", "skills.assign_project",
+	"skills.create", "skills.create_template", "skills.list", "skills.show", "skills.invoke", "skills.run", "skills.enable", "skills.disable", "skills.assign_project", "skills.update",
 ] as const;
 
 export function skillsOperations({ artifacts, events, scopes, artifactScopes, authority }: SkillsModuleDeps): OperationDefinition[] {
@@ -109,5 +109,8 @@ export function skillsOperations({ artifacts, events, scopes, artifactScopes, au
 		define("skills.enable", (input: OperationInput) => transitionSkill(artifacts, string(input, "id"), "enable", eventContext(input))),
 		define("skills.disable", (input: OperationInput) => transitionSkill(artifacts, string(input, "id"), "disable", eventContext(input))),
 		define("skills.assign_project", (input: OperationInput) => assignSkillProject(artifacts, artifactScopes, string(input, "id"), optionalString(input, "project_root"))),
+		define("skills.update", (input: OperationInput) => updateSkill(artifacts, string(input, "id"), {
+			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
+		}, eventContext(input))),
 	];
 }

package/src/service.ts

@@ -144,6 +144,7 @@ const notesAuthorityClaim: AuthorityClaim = {
 	denyMessage: (action) => {
 		if (action === "link") return "note relationships require a notes.* operation so disposition provenance is preserved";
 		if (action === "status") return "note lifecycle changes require a notes.* operation so disposition provenance is preserved";
+		if (action === "update") return "note content changes require a notes.* operation so disposition provenance is preserved";
 		return "note creation requires notes.capture";
 	},
 };
@@ -341,6 +342,7 @@ function handlers(
 		"docs.reopen": forwardToModule("docs.reopen"),
 		"docs.link": forwardToModule("docs.link"),
 		"docs.assign_project": forwardToModule("docs.assign_project"),
+		"docs.update": forwardToModule("docs.update"),
 		"notes.capture": forwardToModule("notes.capture"),
 		"notes.list": forwardToModule("notes.list"),
 		"notes.show": forwardToModule("notes.show"),
@@ -355,6 +357,7 @@ function handlers(
 		"rules.disable": forwardToModule("rules.disable"),
 		"rules.gate": forwardToModule("rules.gate"),
 		"rules.assign_project": forwardToModule("rules.assign_project"),
+		"rules.update": forwardToModule("rules.update"),
 		"skills.create": forwardToModule("skills.create"),
 		"skills.create_template": forwardToModule("skills.create_template"),
 		"skills.list": forwardToModule("skills.list"),
@@ -364,6 +367,7 @@ function handlers(
 		"skills.enable": forwardToModule("skills.enable"),
 		"skills.disable": forwardToModule("skills.disable"),
 		"skills.assign_project": forwardToModule("skills.assign_project"),
+		"skills.update": forwardToModule("skills.update"),
 		"skills.instantiate": (input) => {
 			const templateId = string(input, "template_id");
 			const template = artifacts.get(templateId);