@danypops/pi-papyrus 0.42.0 → 0.43.1

package/README.md

@@ -10,14 +10,13 @@ The `papyrus_*` tools are the low-level graph-store API:
 - **`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. `discuss` is still a single tool with an `action` parameter -- `live:true` needs an interactive UI round-trip a stateless Vehicle operation can't express. `notes`, `docs`, `rules`, `skills`, `playbooks`, and `tasks` are projected from Papyrus's own Vehicle as one real tool per operation (`notes_capture`, `rules_create`, `skills_run`, `playbooks_invoke`, `tasks_complete`, and so on) -- no `action` dispatch, each with its own schema:
+Agent-facing domain tools own lifecycle invariants and sit above this store API. `discuss` is still a single tool with an `action` parameter -- `live:true` needs an interactive UI round-trip a stateless Vehicle operation can't express. `notes`, `docs`, `rules`, `playbooks`, and `tasks` are projected from Papyrus's own Vehicle as one real tool per operation (`notes_capture`, `rules_create`, `playbooks_invoke`, `tasks_complete`, and so on) -- no `action` dispatch, each with its own schema:
 
 - **tasks** (`tasks_create`, `tasks_update`, `tasks_list`, `tasks_show`, `tasks_plan`, `tasks_graph`, `tasks_focus`, `tasks_pause`, `tasks_unpause`, `tasks_clear_focus`, `tasks_start`, `tasks_submit`, `tasks_complete`, `tasks_reject`, `tasks_retry`, `tasks_cancel`, `tasks_cancel_subtree`, `tasks_run_gates`, `tasks_set_checklist`, `tasks_set_gates`, `tasks_depend`, `tasks_undepend`, `tasks_contain`, `tasks_uncontain`, `tasks_claim`, `tasks_heartbeat_lease`, `tasks_release_lease`, `tasks_lease`, `tasks_context`, `tasks_event_feed`, `tasks_scope`, `tasks_set_scope`, `tasks_assign_project`, `tasks_active`, `tasks_focused`, `tasks_history`) — manages the singleton active focus, evidence-bearing checklists, hierarchy/dependencies, lifecycle transitions, non-blocking gates, and review completion that focuses one deterministic ready successor without claiming effort. `project_root` is required wherever a plain `tasks` call would otherwise need one (list/graph/plan/active/focused/scope/context/create) -- there is no ambient Pi cwd server-side. `tasks_focus`/`tasks_pause`/`tasks_unpause`/`tasks_clear_focus` still authorize their write via this session's own cached secret, and still broadcast `papyrus.task-focus.v1` on Pi's own event bus for a sibling extension to observe, exactly as before
-- **notes** (`notes_capture`, `notes_list`, `notes_show`, `notes_consume`, `notes_promote`, `notes_archive`) — 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
+- **notes** (`notes_capture`, `notes_list`, `notes_show`, `notes_consume`, `notes_promote`, `notes_archive`) — capture/list/show deferred human intent, mark it consumed, promote it to an existing Task/Doc/Rule/Playbook, or archive it with an explicit disposition
 - **docs** (`docs_create`, `docs_list`, `docs_show`, `docs_activate`, `docs_archive`, `docs_reopen`, `docs_link`, `docs_assign_project`, `docs_update`) — activate/archive/reopen and document-safe graph links; Note mutations remain behind the Notes facade
 - **rules** (`rules_create`, `rules_list`, `rules_show`, `rules_preview`, `rules_enable`, `rules_disable`, `rules_gate`, `rules_assign_project`, `rules_update`) — enable/disable and attach governance gates to tasks
-- **skills** (`skills_create`, `skills_create_template`, `skills_list`, `skills_show`, `skills_invoke`, `skills_run`, `skills_enable`, `skills_disable`, `skills_instantiate`, `skills_assign_project`, `skills_update`) — `skills_run` atomically instantiates a parameterized workflow run; `skills_instantiate` instantiates a compatibility artifact-template
-- **playbooks** (`playbooks_create`, `playbooks_list`, `playbooks_show`, `playbooks_invoke`, `playbooks_preview`, `playbooks_enable`, `playbooks_disable`, `playbooks_assign_project`, `playbooks_update`, `playbooks_contain`, `playbooks_uncontain`, `playbooks_depend`, `playbooks_undepend`) — a completely different beast from Skills at the authoring level (a trigger and an ordered list of steps, written as prose), but `playbooks_invoke` recycles the same materialization engine workflow Skills use: it compiles the steps and any `contain`/`depend` composition into real Tasks (one per step, plus a container task per playbook in the tree), wires them with `dependsOn` so completing one auto-focuses the next, and focuses the first one. No text dump — one step surfaces at a time, as it becomes the focused task, same as any other Task. `playbooks_contain`/`playbooks_uncontain` nest a child Playbook inside a parent (its steps run after the parent's own, as part of it); `playbooks_depend`/`playbooks_undepend` chain a prerequisite Playbook before another (it must fully complete first). `playbooks_preview` renders the whole tree as text with no side effects, for reading before invoking. A Playbook can declare named arguments (`{name, description?, required?}`, required defaults true; referenced in step text as `{{name}}`); invoking with a required one unsupplied creates nothing and reports exactly which are still missing, directing the agent to ask via `discuss` with `live:true` rather than guess
+- **playbooks** (`playbooks_create`, `playbooks_list`, `playbooks_show`, `playbooks_invoke`, `playbooks_preview`, `playbooks_enable`, `playbooks_disable`, `playbooks_assign_project`, `playbooks_update`, `playbooks_contain`, `playbooks_uncontain`, `playbooks_depend`, `playbooks_undepend`) — a trigger and an ordered list of steps. Each step is a plain prose string (a task), or a structured object: `{kind:'doc',title,body?,subtype?,labels?}` creates a Doc, `{kind:'rule',title,body?,condition?,action?,severity?,labels?}` creates a Rule, `{kind:'call',title,playbookId,arguments?}` nests another Playbook's own run as a pipeline step gated in the same sequence, `{kind:'task',title?,body}` is an explicit task step. `playbooks_invoke` recycles the shared blueprint materialization engine: it compiles the steps and any `contain`/`depend` composition into real artifacts (a Task per plain/task step, a Doc/Rule per doc/rule step, a nested run per call step), wires task-like steps with `dependsOn` so completing one auto-focuses the next, and focuses the first real task. No text dump — one step surfaces at a time, as it becomes the focused task, same as any other Task. `playbooks_contain`/`playbooks_uncontain` nest a child Playbook inside a parent (its steps run after the parent's own, as part of it); `playbooks_depend`/`playbooks_undepend` chain a prerequisite Playbook before another (it must fully complete first) -- both are whole-Playbook composition, distinct from a `call` step's finer-grained, single-step nesting. `playbooks_preview` renders the whole tree as text with no side effects, for reading before invoking. A Playbook can declare named arguments (`{name, description?, required?, type?('string'|'number'|'boolean', default 'string'), enum?, default?}`, required defaults true; referenced in step text/call arguments as `{{name}}`); invoking with a required one unsupplied creates nothing and reports exactly which are still missing, directing the agent to ask via `discuss` with `live:true` rather than guess
 
 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.
 
@@ -28,15 +27,14 @@ Every tool operation is registered in the daemon's `/api/v1/ops` registry; parit
 - `/notes` — searchable project Notes inbox with consume, promote, and disposition-aware archive actions
 - `/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
 - `/playbooks` — trigger/tools rows, edit, invocation into the editor, and graph links
 - `/playbook <name>` — tab-completes active playbook titles and places that one's invocation directly in the editor, one step instead of browse-then-select; no argument falls back to the full `/playbooks` browser
 
-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; relationships render as a small Unicode graph via `beautiful-mermaid` when the neighbor set is real and within the routed-rendering bound, falling back to a plain, still name-resolved arrow list otherwise. `↑/↓` scrolls, `←/→` pans wide relationships, and Esc returns to the browser; non-interactive clients receive stable source text.
+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, and Playbooks. 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; relationships render as a small Unicode graph via `beautiful-mermaid` when the neighbor set is real and within the routed-rendering bound, falling back to a plain, still name-resolved arrow list otherwise. `↑/↓` scrolls, `←/→` pans wide relationships, and Esc returns to the browser; non-interactive clients receive stable source text.
 
 ## Notes
 
-Notes are project-scoped `doc/note` artifacts for human requests that should be considered later. Capturing a Note does not create work, inject the entire inbox into prompts, or imply acceptance. The agent can use the `notes` domain tool to list and consume open Notes, decide whether to create a Task, Doc, Rule, or Skill through its owning domain tool, then promote the Note by linking that artifact. Archive requires one of `completed`, `duplicate`, `declined`, or `superseded`; promote archives with a `promoted` disposition and target ID. Capture, consumption, and disposition provenance remain in bounded Note history.
+Notes are project-scoped `doc/note` artifacts for human requests that should be considered later. Capturing a Note does not create work, inject the entire inbox into prompts, or imply acceptance. The agent can use the `notes` domain tool to list and consume open Notes, decide whether to create a Task, Doc, Rule, or Playbook through its owning domain tool, then promote the Note by linking that artifact. Archive requires one of `completed`, `duplicate`, `declined`, or `superseded`; promote archives with a `promoted` disposition and target ID. Capture, consumption, and disposition provenance remain in bounded Note history.
 
 The default inbox contains draft and consumed/active Notes, is bounded to 50 rows, and has a hard limit of 200. Bodies are capped at 10,000 characters. Generic document and graph lifecycle operations reject Note mutations so they cannot bypass disposition provenance.
 
@@ -45,7 +43,7 @@ papyrus notes capture "Investigate the retry policy" --json
 papyrus notes list --limit 25 --json
 papyrus notes show <note-id> --json
 papyrus notes consume <note-id> --json
-# Create the resulting artifact with tasks/docs/rules/skills first, then:
+# Create the resulting artifact with tasks/docs/rules/playbooks first, then:
 papyrus notes promote <note-id> <target-id> --reason "Converted to tracked work" --json
 papyrus notes archive <note-id> declined --reason "No longer relevant" --json
 ```
@@ -62,7 +60,7 @@ Blocking is real: `tasks.complete` is refused while any `active` Discussion has
 
 `open`/`reply` can also pose a structured choice instead of (or alongside) free text: `options` (2-10 entries) plus `options_mode` -- `single` is mutually exclusive (exactly one pick), `multi` allows several. The Discussion remembers the pending choice (`extra.discussion.pendingOptions`/`pendingOptionsMode`) until a `reply` answers it with `selected`, validated against exactly what was offered and the mode's cardinality; a reply can also pose the *next* round's choice in the same call.
 
-Run `/discuss` for the interactive panel: browse every Discussion (the real `active`/`deferred`/`settled` state shown per row, alongside any choice awaiting an answer), open a scrollable transcript showing what was posed and picked in each round, and reply/defer/resume/settle or block/unblock a task without leaving the TUI. Replying to a pending choice shows a real picker -- the native single-select list for `single`, or a checkbox multi-select for `multi`, since no built-in multi-select exists in the Pi extension UI. Both modes append a numbered "type your own answer" row -- a genuinely open answer is exactly as valid as any posed option. The multi-select picker supports a number key as a direct quick-select (jump straight to that row instead of scrolling), and steadily highlights checked rows while dimming the rest so the eye reads "what's chosen" independent of cursor position; its cursor row blinks to mark focus. It also auto-cancels after 30s of zero input -- the very first keystroke of any kind stops that countdown permanently for that prompt. Opening a *new* Discussion is left to the agent (same as Docs/Rules/Skills) -- `/discuss` browses and drives existing ones.
+Run `/discuss` for the interactive panel: browse every Discussion (the real `active`/`deferred`/`settled` state shown per row, alongside any choice awaiting an answer), open a scrollable transcript showing what was posed and picked in each round, and reply/defer/resume/settle or block/unblock a task without leaving the TUI. Replying to a pending choice shows a real picker -- the native single-select list for `single`, or a checkbox multi-select for `multi`, since no built-in multi-select exists in the Pi extension UI. Both modes append a numbered "type your own answer" row -- a genuinely open answer is exactly as valid as any posed option. The multi-select picker supports a number key as a direct quick-select (jump straight to that row instead of scrolling), and steadily highlights checked rows while dimming the rest so the eye reads "what's chosen" independent of cursor position; its cursor row blinks to mark focus. It also auto-cancels after 30s of zero input -- the very first keystroke of any kind stops that countdown permanently for that prompt. Opening a *new* Discussion is left to the agent (same as Docs/Rules/Playbooks) -- `/discuss` browses and drives existing ones.
 
 ```bash
 papyrus discuss open --title "Naming" --actor alice --content "Should we rename this?" --blocks-json '["task-id"]' --json
@@ -119,7 +117,7 @@ papyrus tasks cancel <id> --json
 papyrus tasks cancel-subtree <id> --json
 ```
 
-`cancel-subtree` cancels a Task and every Task in its containment (`contains`) subtree in one call -- for tearing down a whole materialized Playbook/Skill run at once instead of canceling each Task id by hand. A Task already `done`/`canceled` is skipped, not treated as an error.
+`cancel-subtree` cancels a Task and every Task in its containment (`contains`) subtree in one call -- for tearing down a whole materialized Playbook run at once instead of canceling each Task id by hand. A Task already `done`/`canceled` is skipped, not treated as an error.
 
 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. The same `update` action provides a narrowly guarded recovery for Tasks accidentally created terminal by a legacy default: `status=todo` requires an audit reason, cannot be combined with content edits, only applies when `created` is the sole lifecycle event, and appends `creation_recovered` rather than rewriting history.
 
@@ -133,10 +131,10 @@ Checklist criteria are an item-to-proof map. Every new item requires one or more
 
 ```ts
 checklist: {
-  "Write failing skill-row tests": {
+  "Write failing playbook-row tests": {
     proof: [
       { type: "file", target: "test/frontends.test.ts" },
-      { type: "symbol", target: "test/frontends.test.ts#skill row test" }
+      { type: "symbol", target: "test/frontends.test.ts#playbook row test" }
     ]
   }
 }

package/extension/src/artifact-status-presentation.ts

@@ -3,8 +3,8 @@ import type { ThemeColor } from "@earendil-works/pi-coding-agent";
 /**
  * Shared {label, glyph, color} shape, mirroring task-presentation.ts's TASK_STATUS_PRESENTATION
  * for every other artifact kind's status. Centralizing this closes a real gap: every artifact
- * browser (Rules, Docs, Notes, Skills) previously rendered status as a bare glyph with no color at
- * all, which is exactly why "hard to understand which rules are active" was a real complaint --
+ * browser (Rules, Docs, Notes, Playbooks) previously rendered status as a bare glyph with no color
+ * at all, which is exactly why "hard to understand which rules are active" was a real complaint --
  * an active rule's "●" and a deprecated rule's "○" differ only by one filled-vs-hollow pixel shape,
  * easy to miss at a glance across a scrolling list.
  */
@@ -31,11 +31,6 @@ export const NOTE_STATUS_PRESENTATION: Record<string, StatusPresentation> = {
 	archived: { label: "archived", glyph: "■", color: "dim" },
 };
 
-export const SKILL_STATUS_PRESENTATION: Record<string, StatusPresentation> = {
-	active: { label: "active", glyph: "●", color: "success" },
-	deprecated: { label: "deprecated", glyph: "○", color: "muted" },
-};
-
 export const PLAYBOOK_STATUS_PRESENTATION: Record<string, StatusPresentation> = {
 	active: { label: "active", glyph: "●", color: "success" },
 	deprecated: { label: "deprecated", glyph: "○", color: "muted" },

package/extension/src/discuss.ts

@@ -9,7 +9,7 @@
  * surfaces severity and notes.ts surfaces history count, both also not the row glyph.
  *
  * Creating a new Discussion is left to the agent (the discuss tool), matching docs.ts/rules.ts/
- * skills.ts precedent -- Notes is the one kind with a human-facing creation command (/note),
+ * playbooks.ts precedent -- Notes is the one kind with a human-facing creation command (/note),
  * because Notes exists specifically as a human-authored inbox.
  */
 import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";

package/extension/src/domain-tools.ts

@@ -118,7 +118,7 @@ export function matchArtifactByName(candidates: Artifact[], name: string): strin
 /**
  * tasks.list is the one list operation that requires `project_root` and separately supports a
  * `scope` ("project" | "graph" | "all") to widen or narrow the search. Every other list operation
- * (docs.list, rules.list, skills.list, playbooks.list, artifact.query, ...) instead treats an
+ * (docs.list, rules.list, playbooks.list, artifact.query, ...) instead treats an
  * omitted `project_root` as an unscoped/global search (domain-services.ts's listScoped) and has
  * no `scope` concept at all -- so "search everywhere" means something different for each.
  */
@@ -133,7 +133,7 @@ function widenedRequest(listOperation: OperationName, baseRequest: Record<string
 
 /**
  * Resolves a name to its id via `listOperation` (whichever kind's list call is the right search
- * scope -- tasks.list, docs.list, rules.list, skills.list, notes.list, discuss.list, or the
+ * scope -- tasks.list, docs.list, rules.list, playbooks.list, notes.list, discuss.list, or the
  * kind-agnostic artifact.query for a cross-kind reference like a link target). `baseRequest`
  * should mirror whatever scoping (project_root, etc.) that operation's own "list" action already
  * uses, so resolution never searches a wider or narrower scope than a plain list call would.
@@ -195,7 +195,7 @@ async function resolveNameArrayField(
 }
 
 /**
- * Shared "remove"/"restore" dispatch for every domain tool (tasks/docs/rules/skills) --
+ * Shared "remove"/"restore" dispatch for every domain tool (tasks/docs/rules/playbooks) --
  * artifact.remove/restore are kind-agnostic composition-root operations (see service.ts),
  * not owned by any one domain module, so every domain tool exposes the same two actions
  * over the same two operations rather than reinventing trash semantics four times.
@@ -234,7 +234,7 @@ async function handleArtifactRemoveRestore(action: unknown, params: Record<strin
 	return null;
 }
 
-// notes.*, rules.*, docs.*, skills.*, playbooks.*, tasks.*, and the shared artifact.* are
+// notes.*, rules.*, docs.*, playbooks.*, tasks.*, and the shared artifact.* are
 // registered as Vehicles (see ../vehicle-notes-client.ts and @danypops/papyrus's
 // src/vehicle/papyrus-vehicle.ts), not pi.registerTool()s in this file.
 
@@ -341,7 +341,7 @@ export function registerDiscussTool(pi: ExtensionAPI): void {
 }
 
 /** Thin orchestrator: each domain's tool is independently navigable/testable via its own registerXTool function. */
-// notes, rules, docs, skills, playbooks, and tasks are no longer registered here -- all migrated
+// notes, rules, docs, playbooks, and tasks are no longer registered here -- all migrated
 // onto Vehicle (registerNotesVehicle in vehicle-notes-client.ts, wired at session_start in
 // index.ts), replacing their own pi.registerTool() mega-tools. See @danypops/papyrus's
 // src/vehicle/papyrus-vehicle.ts for the server side. discuss remains here -- live:true needs an

package/extension/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-papyrus — native Pi extension for the Papyrus graph store.
  *
- * Tools: papyrus_query/graph/show (low-level), plus one native tool per domain (docs/rules/skills/playbooks/tasks/discuss/notes).
+ * Tools: papyrus_query/graph/show (low-level), plus one native tool per domain (docs/rules/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.
@@ -327,7 +327,7 @@ export default async function (pi: ExtensionAPI) {
 	const contextInjectionProducerId = randomUUID();
 	let previousContextInjectionFingerprint: string | undefined;
 	let logTurnSequence = 0;
-	// Papyrus's own Context Hub contribution (rules/tasks/skills, bundled into one segment --
+	// Papyrus's own Context Hub contribution (rules/tasks/Pi's own skill catalog, bundled into one segment --
 	// see context-hub-contribution.ts) re-emits every turn alongside the existing injection
 	// observation, its own independent monotonic sequence, same cadence and shape as
 	// contextInjectionSequence but on a different channel/schema.
@@ -438,7 +438,7 @@ export default async function (pi: ExtensionAPI) {
 			"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), " +
 			"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. " +
+			"status (id+status) exists at the protocol level but is refused for every kind with its own lifecycle (Doc/Rule/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. " +
 			"PREFER `from_name`/`to_name` over `from`/`to` for link/unlink -- both are backend implementation details, resolved from name automatically, searching across every kind since either end of an edge can be any artifact.",
 		parameters: Type.Object({
 			action: Type.String({ description: "link | unlink | tree | status | history" }),
@@ -462,7 +462,7 @@ export default async function (pi: ExtensionAPI) {
 			try {
 				const params: Record<string, unknown> = { ...rawParams };
 				if (params.action === "link" || params.action === "unlink") {
-					// Kind-agnostic: either end of an edge can be a task, doc, rule, skill, or playbook.
+					// Kind-agnostic: either end of an edge can be a task, doc, rule, or playbook.
 					await resolveNameFields(params, [
 						{ nameKey: "from_name", idKey: "from", listOperation: "artifact.query", baseRequest: {} },
 						{ nameKey: "to_name", idKey: "to", listOperation: "artifact.query", baseRequest: {} },
@@ -563,12 +563,11 @@ export default async function (pi: ExtensionAPI) {
 	// ── Interactive artifact browsers ──────────────────────────────────
 
 	// Lazy imports keep TUI components out of non-interactive startup paths.
-	const [tasksModule, docsModule, notesModule, rulesModule, skillsModule, playbooksModule, discussModule] = await Promise.all([
+	const [tasksModule, docsModule, notesModule, rulesModule, playbooksModule, discussModule] = await Promise.all([
 		import("./tasks.ts"),
 		import("./docs.ts"),
 		import("./notes.ts"),
 		import("./rules.ts"),
-		import("./skills.ts"),
 		import("./playbooks.ts"),
 		import("./discuss.ts"),
 	]);
@@ -607,10 +606,6 @@ export default async function (pi: ExtensionAPI) {
 		description: "Browse, preview, and toggle Papyrus rules (interactive)",
 		handler: async (_args, ctx) => { await rulesModule.showRules(ctx); },
 	});
-	pi.registerCommand("skills", {
-		description: "Browse and invoke Papyrus skills and templates (interactive)",
-		handler: async (_args, ctx) => { await skillsModule.showSkills(ctx); },
-	});
 	pi.registerCommand("playbooks", {
 		description: "Browse, edit, and invoke Papyrus playbooks -- trigger/steps guidance an agent reads and follows (interactive)",
 		handler: async (_args, ctx) => { await playbooksModule.showPlaybooks(ctx); },

package/extension/src/vehicle-notes-client.ts

@@ -1,6 +1,6 @@
 /**
- * Registers every Vehicle-projected domain (notes.*, rules.*, docs.*, skills.*,
- * playbooks.*, tasks.*, artifact.*) as real Pi tools -- see @danypops/papyrus's
+ * Registers every Vehicle-projected domain (notes.*, rules.*, docs.*, playbooks.*,
+ * tasks.*, artifact.*) as real Pi tools -- see @danypops/papyrus's
  * src/vehicle/papyrus-vehicle.ts.
  *
  * Fails silently on a stale/unreachable daemon handle instead of aborting extension
@@ -20,7 +20,7 @@ import { emitTaskFocusEvent } from "./task-focus-events.ts";
 
 const REGISTERED_PERMISSIONS = [
 	"notes:read", "notes:write", "rules:read", "rules:write", "docs:read", "docs:write",
-	"skills:read", "skills:write", "playbooks:read", "playbooks:write", "tasks:read", "tasks:write",
+	"playbooks:read", "playbooks:write", "tasks:read", "tasks:write",
 	"artifact:read", "artifact:write",
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-papyrus",
-  "version": "0.42.0",
+  "version": "0.43.1",
   "description": "Pi host extension for Papyrus: native tools, TUI panels, and context injection over the daemon-backed graph store",
   "type": "module",
   "keywords": ["pi-package"],
@@ -18,13 +18,13 @@
   },
   "dependencies": {
     "@danypops/jittor": "^0.14.0",
-    "@danypops/papyrus": "^0.41.0",
+    "@danypops/papyrus": "^0.42.0",
+    "@danypops/vehicle-client": "^0.1.1",
+    "@danypops/vehicle-client-pi": "^0.3.1",
     "@danypops/vehicle-core": "^0.2.0",
     "@danypops/vehicle-server": "^0.1.1",
-    "@danypops/vehicle-client": "^0.1.1",
-    "@danypops/vehicle-client-pi": "^0.3.0",
     "beautiful-mermaid": "1.1.3",
-    "malevich-tui-components": "^0.5.0"
+    "malevich-tui-components": "^0.16.1"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.10",

package/extension/src/skills.ts

@@ -1,125 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { Artifact, WorkflowRunResult, TaskGraph } from "@danypops/papyrus";
-import { showArtifactBrowser, showArtifactDetails } from "./artifact-browser.ts";
-import { SKILL_STATUS_PRESENTATION } from "./artifact-status-presentation.ts";
-import { callService } from "./service-client.ts";
-import { showTaskGraph } from "./task-graph.ts";
-
-function strings(value: unknown): string[] {
-	return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
-}
-
-export function skillRowMeta(skill: Artifact): string {
-	if (skill.subtype === "artifact-template") {
-		const target = typeof skill.extra["targetKind"] === "string" ? skill.extra["targetKind"] : "artifact";
-		return `template → ${target}`;
-	}
-	if (skill.subtype === "workflow") {
-		const definition = skill.extra["definition"] as Record<string, unknown> | undefined;
-		const inputs = definition?.["inputs"] && typeof definition["inputs"] === "object"
-			? Object.keys(definition["inputs"] as Record<string, unknown>).length
-			: 0;
-		const blueprints = definition?.["blueprints"] as Record<string, unknown> | undefined;
-		const tasks = Array.isArray(blueprints?.["tasks"]) ? blueprints["tasks"].length : 0;
-		return `workflow · ${inputs} inputs · ${tasks} tasks`;
-	}
-	const trigger = typeof skill.extra["trigger"] === "string" ? `when ${skill.extra["trigger"]}` : "manual";
-	const tools = strings(skill.extra["tools"]);
-	return [trigger, tools.join(", ")].filter(Boolean).join(" · ");
-}
-
-export function skillInvocationPrompt(skill: Artifact): string {
-	if (skill.subtype === "artifact-template") {
-		return [`Create an artifact using Papyrus template \"${skill.title}\".`, `template_name: ${skill.title}`, "Ask for or infer the title and all required template fields, then call the skills domain tool with action=instantiate."].join("\n");
-	}
-	if (skill.subtype === "workflow") {
-		return [
-			`Run Papyrus workflow Skill \"${skill.title}\".`,
-			"Collect its required arguments, then call the skills domain tool with action=run.",
-		].join("\n");
-	}
-	const trigger = typeof skill.extra["trigger"] === "string" ? skill.extra["trigger"] : "manual invocation";
-	const steps = strings(skill.extra["steps"]);
-	const tools = strings(skill.extra["tools"]);
-	return [
-		`Apply Papyrus skill \"${skill.title}\".`,
-		`Trigger: ${trigger}`,
-		...(skill.body ? [`Context: ${skill.body}`] : []),
-		...(steps.length > 0 ? ["Steps:", ...steps.map((step, index) => `${index + 1}. ${step}`)] : []),
-		...(tools.length > 0 ? [`Tools: ${tools.join(", ")}`] : []),
-	].join("\n");
-}
-
-export function skillRunTaskGraph(run: WorkflowRunResult, taskArtifacts: Artifact[]): TaskGraph {
-	const executionById = new Map(run.execution.nodes.map((node) => [node.id, node]));
-	return {
-		nodes: taskArtifacts.map((task) => ({
-			task,
-			active: executionById.get(task.id)?.active === true,
-			parentIds: [],
-			childIds: [],
-			dependencyIds: executionById.get(task.id)?.prerequisiteIds ?? [],
-		})),
-		rootIds: run.rootTaskIds,
-	};
-}
-
-export async function showSkills(ctx: ExtensionCommandContext): Promise<void> {
-	await showArtifactBrowser(ctx, {
-		kind: "skill",
-		title: "Skills",
-		listOperation: "skills.list",
-		statusOrder: ["active", "deprecated"],
-		presentation: SKILL_STATUS_PRESENTATION,
-		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 === "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 {
-					const arguments_ = JSON.parse(source) as unknown;
-					if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) {
-						throw new Error("arguments must be a JSON object");
-					}
-					const run = await callService<Record<string, unknown>, WorkflowRunResult>("skills.run", {
-						id: skill.id,
-						arguments: arguments_ as Record<string, unknown>,
-						project_root: commandCtx.cwd,
-					});
-					commandCtx.ui.notify([
-						`Created ${run.runId} · ${run.created.tasks.length} tasks · ${run.rootTaskIds.length} ready roots`,
-						`Context docs: ${run.created.docs.join(", ") || "none"}`,
-						`Scoped rules: ${run.created.rules.join(", ") || "none"}`,
-					].join("\n"), "info");
-					const taskArtifacts = await Promise.all(run.execution.nodes.map((node) =>
-						callService<Record<string, unknown>, Artifact>("tasks.show", { id: node.id })));
-					await showTaskGraph(commandCtx, skillRunTaskGraph(run, taskArtifacts));
-				} catch (error) {
-					commandCtx.ui.notify(`Workflow run failed: ${error instanceof Error ? error.message : error}`, "error");
-				}
-			} else if (choice === "Invoke skill" || choice === "Use template") {
-				const invocation = await callService<Record<string, unknown>, string>("skills.invoke", { id: skill.id });
-				commandCtx.ui.setEditorText(invocation);
-				commandCtx.ui.notify("Invocation placed in the editor", "info");
-			} else {
-				const operation = choice === "Disable" ? "skills.disable" : "skills.enable";
-				const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: skill.id });
-				commandCtx.ui.notify(`${updated.title} → [${updated.status}]`, "info");
-			}
-		},
-	});
-}