@danypops/papyrus 0.32.0 → 0.32.2

package/README.md

@@ -98,7 +98,7 @@ papyrus skills run <skill-id> \
   --json
 ```
 
-The existing `artifact-template` skill subtype remains a compatibility mechanism for one-artifact templates with metadata `{targetKind, defaults, required}`. Instantiate it through `papyrus_create` with `template_id`; defaults merge recursively, explicit arrays replace defaults, required paths such as `extra.owner` are validated, and target-kind mismatches are rejected.
+The existing `artifact-template` skill subtype remains a compatibility mechanism for one-artifact templates with metadata `{targetKind, defaults, required}`. Instantiate it through the `skills` tool's `instantiate` action with `template_id`; defaults merge recursively, explicit arrays replace defaults, required paths such as `extra.owner` are validated, and target-kind mismatches are rejected.
 
 ### Removing an artifact
 
@@ -110,9 +110,8 @@ Once the deadline passes, the daemon's periodic sweep performs a real, cascading
 
 The `papyrus_*` tools are the low-level graph-store API:
 
-- **`papyrus_create`** — create directly or instantiate via `template_id`
 - **`papyrus_query`** — filter by kind/status or search title and body
-- **`papyrus_graph`** — link artifacts, perform bounded traversal, or update status
+- **`papyrus_graph`** — link artifacts, perform bounded traversal, or read the mutation event log
 - **`papyrus_show`** — read nested metadata and bounded edges, optionally running gates
 
 Agent-facing domain tools own lifecycle invariants and sit above this store API:

package/extension/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-papyrus — native Pi extension for the Papyrus graph store.
  *
- * Tools: papyrus_create/query/graph/show.
+ * Tools: papyrus_query/graph/show (low-level), plus one native tool per domain (docs/rules/skills/playbooks/tasks/discuss/notes).
  * Command: /tasks (interactive task panel).
  * Widget: persistent task status above editor (rpiv-todo pattern).
  * Injection: active rules + open tasks appended to system prompt every turn.
@@ -279,43 +279,6 @@ export default async function (pi: ExtensionAPI) {
 
 	// ── Low-level graph-store tools ────────────────────────────────────
 
-	pi.registerTool({
-		name: "papyrus_create",
-		label: "Papyrus Create",
-		description:
-			"Create a graph artifact. KINDS: doc (knowledge — specs, decisions, research), " +
-			"task (work — with gates/checklists in extra), rule (governance — when doing X, follow Y; " +
-			"active rules inject into the system prompt), skill (parameterized workflow bundle — validated inputs render connected Tasks, Rules, and Docs). " +
-			"RULE extra: {condition, action, severity: 'block'|'warn'|'info'}. " +
-			"TASK extra: {gates: [{type:'file-exists'|'contains'|'command'|'test', target, expect}], checklist: {'criterion': {proof: [{type:'file'|'symbol'|'code'|'test'|'command'|'artifact'|'url', target, expect}]}}}. " +
-			"Legacy SKILL extra: {trigger, steps: [...], tools: [...]}. Workflow Skill schemas are versioned separately. " +
-			"Templates are skills with subtype='artifact-template' and extra {targetKind, defaults, required}; pass template_id to instantiate.",
-		parameters: Type.Object({
-			kind: Type.Optional(Type.String({ description: "doc | task | rule | skill; optional when template_id supplies targetKind" })),
-			title: Type.Optional(Type.String({ description: "required unless supplied by template defaults" })),
-			status: Type.Optional(Type.String({ description: "default: first registered for kind" })),
-			subtype: Type.Optional(Type.String()),
-			body: Type.Optional(Type.String()),
-			labels: Type.Optional(Type.Array(Type.String())),
-			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-			template_id: Type.Optional(Type.String({ description: "skill/artifact-template id whose defaults and requirements apply" })),
-			project_root: Type.Optional(Type.String({ description: "required for Tasks; defaults to Pi cwd" })),
-		}),
-		renderCall(args, theme) { return renderPapyrusToolCall("Create artifact", args, theme); },
-		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
-		async execute(_id, params, _signal, _onUpdate, ctx) {
-			try {
-				const a = await callService<Record<string, unknown>, Artifact>("artifact.create", {
-					...params,
-					...(params.kind === "task" ? { project_root: params.project_root ?? ctx.cwd } : {}),
-				});
-				return text(`Created ${artifactTextLabel(a)}`, createArtifactDetails("artifact.create", a));
-			} catch (e) {
-				throw new Error(`papyrus_create failed: ${e instanceof Error ? e.message : e}`);
-			}
-		},
-	});
-
 	pi.registerTool({
 		name: "papyrus_query",
 		label: "Papyrus Query",
@@ -344,11 +307,12 @@ export default async function (pi: ExtensionAPI) {
 		name: "papyrus_graph",
 		label: "Papyrus Graph",
 		description:
-			"Link artifacts with typed edges (any kind → any kind), view subgraph, update status, or read the mutation event log. " +
+			"Link artifacts with typed edges (any kind → any kind), view subgraph, or read the mutation event log. " +
 			"RELATIONS: references, implements, follows, depends_on, documents, blocks, supersedes, relates_to, gates, triggers, contains, part_of. " +
 			"ACTIONS: link (from+relation+to), unlink (from+relation+to — idempotent, no error if already absent; for Task depends_on/contains prefer the tasks tool's undepend/uncontain), " +
-			"tree (id → bounded BFS subgraph), status (id+status → lifecycle), " +
-			"history (who did what, when — requires id, actor, or session_id).",
+			"tree (id → bounded BFS subgraph), " +
+			"history (who did what, when — requires id, actor, or session_id). " +
+			"status (id+status) exists at the protocol level but is refused for every kind with its own lifecycle (Doc/Rule/Skill/Playbook/Task/Note all reject it) -- use that kind's own domain tool for status changes (docs.activate, rules.enable, tasks.start, etc), never this.",
 		parameters: Type.Object({
 			action: Type.String({ description: "link | unlink | tree | status | history" }),
 			from: Type.Optional(Type.String()),

package/package.json

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

package/src/service.ts

@@ -164,9 +164,31 @@ const tasksAuthorityClaim: AuthorityClaim = {
 	denyMessage: () => "task lifecycle changes require a tasks.* operation so history and review invariants are preserved",
 };
 
+/**
+ * The same status-bypass protection Tasks and Notes already have, extended to every other kind
+ * with its own validated transition set (Doc's draft/active/archived, Rule/Skill/Playbook's
+ * active/deprecated) -- graph.status previously let a caller jump straight to any status string,
+ * skipping e.g. Doc's draft-must-go-through-active-before-archived rule entirely.
+ */
+function lifecycleAuthorityClaim(owner: "docs" | "rules" | "skills" | "playbooks", kind: string): AuthorityClaim {
+	return {
+		owner,
+		matchesArtifact: (candidateKind, subtype) => candidateKind === kind && !(kind === "doc" && subtype === NOTE_SUBTYPE),
+		appliesToAction: (action) => action === "status",
+		denyMessage: () => `${kind} lifecycle changes require a ${owner}.* operation so transition validation is preserved`,
+	};
+}
+
 function createAuthorityRegistry(): AuthorityRegistry {
 	const authority = new AuthorityRegistry();
-	authority.claimAll([notesAuthorityClaim, tasksAuthorityClaim]);
+	authority.claimAll([
+		notesAuthorityClaim,
+		tasksAuthorityClaim,
+		lifecycleAuthorityClaim("docs", "doc"),
+		lifecycleAuthorityClaim("rules", "rule"),
+		lifecycleAuthorityClaim("skills", "skill"),
+		lifecycleAuthorityClaim("playbooks", "playbook"),
+	]);
 	return authority;
 }