@danypops/pi-papyrus 0.41.0 → 0.43.0

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. `tasks` and `discuss` are still single tools with an `action` parameter; `notes`, `docs`, `rules`, `skills`, and `playbooks` are projected from Papyrus's own Vehicle as one real tool per operation (`notes_capture`, `rules_create`, `skills_run`, `playbooks_invoke`, 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`** — 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** (`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
+- **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/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

@@ -1,31 +1,18 @@
 import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import {
-	PROOF_TYPES,
 	readDiscussionExtra,
 	type Artifact,
 	type DiscussionAndRounds,
 	type DiscussionRound,
-	type GateResult,
 	type OperationName,
-	type TaskCompletion,
-	type TaskExecutionPlan,
-	type TaskGraph,
-	type TaskHistoryPage,
-	type TaskLease,
-	type TaskViewSelection,
 } from "@danypops/papyrus";
 import { askQuestion } from "./discuss-ask-view.ts";
-import { emitTaskFocusEvent } from "./task-focus-events.ts";
-import { sessionSecretField } from "./session-identity.ts";
 import { callService } from "./service-client.ts";
 import { renderPapyrusToolCall, renderPapyrusToolResult } from "./tool-rendering/index.ts";
 import {
 	createArtifactDetails,
 	createArtifactListDetails,
-	createGateRunDetails,
-	createGraphDetails,
-	createInvocationDetails,
 	createModelContent,
 	createPreviewDetails,
 } from "./tool-rendering/render-model.ts";
@@ -112,15 +99,6 @@ export function artifactLines(artifacts: Artifact[]): string[] {
 	return artifacts.map((artifact) => (titleCounts.get(artifact.title)! > 1 ? `${artifactLine(artifact)} (${artifact.id})` : artifactLine(artifact)));
 }
 
-/** Resolves internal ids for model text; ids resurface only when equal titles need disambiguation. */
-async function artifactLabelsById(ids: readonly string[]): Promise<Map<string, string>> {
-	const uniqueIds = [...new Set(ids)];
-	const artifacts = (await Promise.all(uniqueIds.map((id) => callService<Record<string, unknown>, Artifact | null>("artifact.show", { id })))).filter((artifact): artifact is Artifact => artifact !== null);
-	const titleCounts = new Map<string, number>();
-	for (const artifact of artifacts) titleCounts.set(artifact.title, (titleCounts.get(artifact.title) ?? 0) + 1);
-	return new Map(artifacts.map((artifact) => [artifact.id, titleCounts.get(artifact.title)! > 1 ? `${artifact.title} (${artifact.id})` : artifact.title]));
-}
-
 /**
  * Exact, case-insensitive, trimmed title match against an already-fetched candidate set. Throws
  * a clear "not found" or "ambiguous -- use id" error rather than guessing at a fuzzy match -- id
@@ -140,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.
  */
@@ -155,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.
@@ -217,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.
@@ -256,271 +234,7 @@ async function handleArtifactRemoveRestore(action: unknown, params: Record<strin
 	return null;
 }
 
-const proofReferenceSchema = Type.Object({
-	type: Type.Union(PROOF_TYPES.map((type) => Type.Literal(type))),
-	target: Type.String(),
-	expect: Type.Optional(Type.String()),
-});
-
-const checklistCriterionSchema = Type.Object({
-	proof: Type.Array(proofReferenceSchema, { minItems: 1 }),
-});
-
-export function registerTasksTool(pi: ExtensionAPI): void {
-	pi.registerTool({
-		name: "tasks",
-		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, update, list, show, history, context, scope, set_scope, assign_project, graph, plan, active, focused, focus, pause, unpause, clear_focus, start, submit, complete, reject, retry, cancel, cancel_subtree, run_gates, set_checklist, set_gates, depend, undepend, contain, uncontain, remove, remove_subtree, restore, claim, heartbeat_lease, release_lease, lease, event_feed. Lifecycle: todo → in-progress → review → done; review failure → rejected → retry → in-progress; canceled is terminal. Focus and lease are independent of lifecycle and of each other -- multiple sessions can focus the same task while only one holds its lease (claim throws if a different owner already holds one; release/heartbeat need the exact token claim returned; owner defaults to this session's id). context returns the full plan (the system prompt itself only carries a one-line pointer) -- call it explicitly after a compaction or before reconciling. complete runs gates + checklist-proof review, then focuses one ready successor. cancel_subtree cancels a task and its whole containment subtree in one call, skipping tasks already done/canceled. remove/restore use a time-gated trash (refuses the live Focus); remove_subtree trashes a whole `contains` subtree in one call; undepend/uncontain are idempotent no-ops when the edge is already absent. update recovers an accidentally-terminal task via status=todo + reason, without rewriting real history; update never touches gates (title/body/labels/status only) -- use set_gates to replace a task's gate commands after creation. Prefer `name` (exact title) over `id` -- id is a backend detail, resolved automatically, needed only to disambiguate a shared title; `parent_name`/`child_name`/`root_task_name` are the same pattern for their `_id` counterparts. For a prerequisite, use `dependency_name` (singular, resolved to `dependency_id`) with the `depend`/`undepend` actions; `depends_on_names` (plural array, resolved to `depends_on`) is only for `create`'s initial dependency set -- passing the wrong one of the two to `depend` leaves `dependency_id` unset and fails with a `dependency_id is required` error. A name resolved outside this call's own project scope (e.g. depending on a task in a different project) is retried once against every project before failing, and the response notes when that happened.",
-		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()),
-			status: Type.Optional(Type.String()),
-			text: Type.Optional(Type.String()),
-			limit: Type.Optional(Type.Number()),
-			cursor: Type.Optional(Type.Number()),
-			direction: Type.Optional(Type.Union([Type.Literal("asc"), Type.Literal("desc")])),
-			reason: Type.Optional(Type.String()),
-			session_id: Type.Optional(Type.String()),
-			labels: Type.Optional(Type.Array(Type.String())),
-			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-			gates: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()))),
-			checklist: Type.Optional(Type.Record(Type.String(), checklistCriterionSchema)),
-			template_id: Type.Optional(Type.String()),
-			parent_id: Type.Optional(Type.String()),
-			parent_name: Type.Optional(Type.String()),
-			child_id: Type.Optional(Type.String()),
-			child_name: Type.Optional(Type.String()),
-			dependency_id: Type.Optional(Type.String()),
-			dependency_name: Type.Optional(Type.String()),
-			depends_on: Type.Optional(Type.Array(Type.String())),
-			depends_on_names: Type.Optional(Type.Array(Type.String())),
-			project_root: Type.Optional(Type.String()),
-			scope: Type.Optional(Type.Union([Type.Literal("project"), Type.Literal("graph"), Type.Literal("all")])),
-			root_task_id: Type.Optional(Type.String()),
-			root_task_name: Type.Optional(Type.String()),
-			owner: Type.Optional(Type.String()),
-			token: Type.Optional(Type.String()),
-			ttl_ms: Type.Optional(Type.Number()),
-			note: Type.Optional(Type.String()),
-			event_types: Type.Optional(Type.Array(Type.String())),
-		}),
-		renderCall(args, theme) { return renderPapyrusToolCall("Tasks", args, theme); },
-		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
-		async execute(_id, rawParams, _signal, _onUpdate, ctx) {
-			try {
-				const params: Record<string, unknown> = { ...rawParams };
-				const action = params.action;
-				// Defaults to this Pi session's own id so Focus reads/writes are isolated per agent
-				// without depending on the model to know or supply its own session identity.
-				// session_secret is looked up by the resolved session_id itself (not blindly the
-				// current session's), so a model that explicitly overrides session_id to a DIFFERENT
-				// session never gets this session's secret smuggled in on its behalf -- the cache only
-				// ever holds this extension's own registered session anyway (see session-identity.ts).
-				const resolvedSessionId = params.session_id ?? ctx.sessionManager.getSessionId();
-				const baseRequest = { project_root: params.project_root ?? ctx.cwd, actor: "agent", source: "pi-tool", session_id: resolvedSessionId, ...sessionSecretField(resolvedSessionId as string) };
-				// Collects a note whenever a name field below only resolved by widening past this call's
-				// own project scope (see resolveArtifactIdByName) -- surfaced at the end of this action's
-				// own response text rather than resolved silently, since a cross-project depend/contain
-				// is exactly the case a shared per-call scope can't otherwise express.
-				const notes: string[] = [];
-				// Resolve the graph root first: every other name lookup must use the caller's final
-				// project/scope/root selection, otherwise `scope: all|graph` silently collapses back
-				// to the current project and forces callers to reach for an id.
-				await resolveNameFields(params, [
-					{ nameKey: "root_task_name", idKey: "root_task_id", listOperation: "tasks.list", baseRequest: { ...baseRequest, scope: "project" } },
-				], notes);
-				const resolutionRequest = {
-					...baseRequest,
-					...(params.scope === undefined ? {} : { scope: params.scope }),
-					...(params.root_task_id === undefined ? {} : { root_task_id: params.root_task_id }),
-				};
-				// The daemon remains keyed by stable ids; the agent facade resolves names against the
-				// exact requested view before dispatching those internal ids.
-				await resolveNameFields(params, [
-					{ nameKey: "name", idKey: "id", listOperation: "tasks.list", baseRequest: resolutionRequest },
-					{ nameKey: "dependency_name", idKey: "dependency_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
-					{ nameKey: "parent_name", idKey: "parent_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
-					{ nameKey: "child_name", idKey: "child_id", listOperation: "tasks.list", baseRequest: resolutionRequest },
-				], notes);
-				await resolveNameArrayField(params, "depends_on_names", "depends_on", "tasks.list", resolutionRequest, notes);
-				const request = { ...params, ...baseRequest };
-				const result = await (async (): Promise<ReturnType<typeof text>> => {
-				if (action === "create") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.create", request);
-					return text(`Created task ${artifactLine(artifact)}`, createArtifactDetails("tasks.create", artifact));
-				}
-				if (action === "list") {
-					const rows = await callService<Record<string, unknown>, Artifact[]>("tasks.list", request);
-					return text(rows.length ? artifactLines(rows).join("\n") : "No tasks found.", createArtifactListDetails("tasks.list", rows));
-				}
-				if (action === "show") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.show", params);
-					return text(`${artifactLine(artifact)}\n\n${artifact.body}`, createArtifactDetails("tasks.show", artifact));
-				}
-				if (action === "history") {
-					const page = await callService<Record<string, unknown>, TaskHistoryPage>("tasks.history", request);
-					const lines = page.events.map((event) => `${event.occurredAt} ${event.type} ${event.fromStatus ?? "∅"} → ${event.toStatus ?? "∅"} · ${event.actor}/${event.source}${event.reason ? ` · ${event.reason}` : ""}`);
-					const output = lines.join("\n") || "No recorded history for this task.";
-					return text(output, createPreviewDetails("tasks.history", "Task history", output));
-				}
-				if (action === "scope") {
-					const selection = await callService<Record<string, unknown>, TaskViewSelection>("tasks.scope", request);
-					return text(`Task scope: ${selection.label}`, createPreviewDetails("tasks.scope", "Task scope", selection.label));
-				}
-				if (action === "active") {
-					const artifact = await callService<Record<string, unknown>, Artifact | null>("tasks.active", request);
-					return artifact
-						? text(`Active: ${artifactLine(artifact)}`, createArtifactDetails("tasks.active", artifact))
-						: text("No active task.", createPreviewDetails("tasks.active", "Active task", "No active task."));
-				}
-				if (action === "focused") {
-					const focus = await callService<Record<string, unknown>, { artifact: Artifact; status: string } | null>("tasks.focused", request);
-					return focus
-						? text(`Focused (${focus.status}): ${artifactLine(focus.artifact)}`, createArtifactDetails("tasks.focused", focus.artifact))
-						: text("No focused task.", createPreviewDetails("tasks.focused", "Focused task", "No focused task."));
-				}
-				if (action === "pause" || action === "unpause") {
-					const operation = action === "pause" ? "tasks.pause" : "tasks.unpause";
-					const focus = await callService<Record<string, unknown>, { artifact: Artifact; status: string }>(operation, request);
-					emitTaskFocusEvent({ taskId: focus.artifact.id, sessionId: request.session_id as string, status: action === "pause" ? "paused" : "unpaused" });
-					return text(`Focused (${focus.status}): ${artifactLine(focus.artifact)}`, createArtifactDetails(operation, focus.artifact));
-				}
-				if (action === "clear_focus") {
-					const result = await callService<Record<string, unknown>, { cleared: boolean }>("tasks.clear_focus", request);
-					if (result.cleared) emitTaskFocusEvent({ taskId: null, sessionId: request.session_id as string, status: "cleared" });
-					const output = result.cleared ? "Task focus cleared." : "No focused task.";
-					return text(output, createPreviewDetails("tasks.clear_focus", "Task focus", output));
-				}
-				if (action === "graph") {
-					const graph = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", request);
-					const dependencies = graph.nodes.reduce((count, node) => count + node.dependencyIds.length, 0);
-					const containment = graph.nodes.reduce((count, node) => count + node.childIds.length, 0);
-					const edges = graph.nodes.flatMap((node) => [
-						...node.dependencyIds.map((dependencyId) => ({ from: node.task.id, relation: "depends_on", to: dependencyId })),
-						...node.childIds.map((childId) => ({ from: node.task.id, relation: "contains", to: childId })),
-					]);
-					return text(
-						`Task graph: ${graph.nodes.length} nodes, ${graph.rootIds.length} roots, ${dependencies} dependencies, ${containment} containment edges.`,
-						createGraphDetails("tasks.graph", graph.nodes.map((node) => node.task), edges),
-					);
-				}
-				if (action === "plan") {
-					const plan = await callService<Record<string, unknown>, TaskExecutionPlan>("tasks.plan", request);
-					const byId = new Map(plan.nodes.map((node) => [node.id, node]));
-					const titleCounts = new Map<string, number>();
-					for (const node of plan.nodes) titleCounts.set(node.title, (titleCounts.get(node.title) ?? 0) + 1);
-					const nodeLabel = (id: string): string => {
-						const node = byId.get(id);
-						if (!node) return "unknown task";
-						return (titleCounts.get(node.title) ?? 0) > 1 ? `${node.title} (${node.id})` : node.title;
-					};
-					const lines = plan.layers.flatMap((layer, index) => [
-						`Layer ${index + 1}`,
-						...layer.map((id) => {
-							const node = byId.get(id);
-							return `  [${node?.state ?? "unknown"}] ${nodeLabel(id)}`;
-						}),
-					]);
-					if (plan.cycleIds.length > 0) lines.push(`Invalid cycle: ${plan.cycleIds.map(nodeLabel).join(", ")}`);
-					const output = lines.join("\n") || "No tasks in execution plan.";
-					return text(output, createPreviewDetails("tasks.plan", "Task execution plan", output));
-				}
-				if (action === "context") {
-					const summary = await callService<Record<string, unknown>, string | null>("tasks.context", { ...request, verbosity: "full" });
-					const output = summary ?? "No open tasks.";
-					return text(output, createPreviewDetails("tasks.context", "Task reconciliation context", output));
-				}
-				if (action === "set_checklist") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.set_checklist", params);
-					return text(`Updated checklist: ${artifactLine(artifact)}`, createArtifactDetails("tasks.set_checklist", artifact));
-				}
-				if (action === "set_gates") {
-					const artifact = await callService<Record<string, unknown>, Artifact>("tasks.set_gates", params);
-					return text(`Updated gates: ${artifactLine(artifact)}`, createArtifactDetails("tasks.set_gates", artifact));
-				}
-				if (action === "complete") {
-					const result = await callService<Record<string, unknown>, TaskCompletion>("tasks.complete", request);
-					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n");
-					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}${item.reason ? ` — ${item.reason}` : ""}`).join("\n");
-					const focused = result.focused ? `\nActive: ${artifactLine(result.focused)}` : "";
-					const blockedLines = artifactLines(result.blocked.map((entry) => entry.artifact));
-					const dependencyLabels = await artifactLabelsById(result.blocked.flatMap((entry) => entry.dependencyIds));
-					const blocked = result.blocked.length > 0
-						? `\nBlocked: ${result.blocked.map((entry, index) => `${blockedLines[index]} waits for ${entry.dependencyIds.map((id) => dependencyLabels.get(id) ?? "unknown task").join(", ")}`).join("; ")}`
-						: "";
-					const output = `${result.completed ? "Completed" : "Rejected"}: ${artifactLine(result.artifact)}${focused}${blocked}${checklist ? `\n${checklist}` : ""}${gates ? `\n${gates}` : ""}`;
-					return text(output, createPreviewDetails("tasks.complete", "Task completion", output));
-				}
-				if (action === "run_gates") {
-					const [gates, task] = await Promise.all([
-						callService<Record<string, unknown>, GateResult[]>("tasks.run_gates", request),
-						callService<Record<string, unknown>, Artifact>("tasks.show", { id: params.id }),
-					]);
-					return text(
-						gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target} — ${gate.output}`).join("\n") || "No gates configured.",
-						createGateRunDetails("tasks.run_gates", (params.id as string | undefined) ?? "", task.title, gates.map((gate) => ({
-							passed: gate.passed, type: gate.gate.type, target: gate.gate.target, output: gate.output,
-						}))),
-					);
-				}
-				if (action === "event_feed") {
-					const page = await callService<Record<string, unknown>, { events: Array<{ id: number; occurredAt: string; taskId: string; type: string }>; nextCursor?: number }>("tasks.event_feed", { cursor: params.cursor, limit: params.limit, event_types: params.event_types });
-					const output = page.events.length === 0 ? "No events." : page.events.map((event) => `${event.id} ${event.occurredAt} ${event.taskId} ${event.type}`).join("\n");
-					return text(page.nextCursor !== undefined ? `${output}\n\n(more available -- resume with cursor: ${page.nextCursor})` : output, createPreviewDetails("tasks.event_feed", "Task event feed", output));
-				}
-				if (action === "claim" || action === "heartbeat_lease" || action === "release_lease" || action === "lease") {
-					const leaseRequest = { ...request, owner: (params.owner as string | undefined) ?? resolvedSessionId };
-					if (action === "release_lease") {
-						const released = await callService<Record<string, unknown>, { released: boolean }>("tasks.release_lease", leaseRequest);
-						const output = released.released ? "Lease released." : "No live lease to release.";
-						return text(output, createPreviewDetails("tasks.release_lease", "Task lease", output));
-					}
-					const operation = action === "claim" ? "tasks.claim" : action === "heartbeat_lease" ? "tasks.heartbeat_lease" : "tasks.lease";
-					const lease = await callService<Record<string, unknown>, TaskLease | null>(operation, leaseRequest);
-					const output = lease ? `Leased by "${lease.owner}" until ${lease.leaseExpiresAt} (token ${lease.token}).` : "No live lease.";
-					return text(output, createPreviewDetails(operation, "Task lease", output));
-				}
-				if (action === "cancel_subtree") {
-					const outcome = await callService<Record<string, unknown>, { canceled: string[]; skipped: string[] }>("tasks.cancel_subtree", request);
-					const output = `Canceled ${outcome.canceled.length} task(s)${outcome.skipped.length > 0 ? `, skipped ${outcome.skipped.length} already-terminal` : ""}.`;
-					return text(output, createPreviewDetails("tasks.cancel_subtree", "Cancel task subtree", JSON.stringify(outcome, null, 2)));
-				}
-				const trashResult = await handleArtifactRemoveRestore(action, params);
-				if (trashResult) return trashResult;
-				const operations = {
-					focus: "tasks.focus",
-					start: "tasks.start",
-					submit: "tasks.submit",
-					reject: "tasks.reject",
-					retry: "tasks.retry",
-					cancel: "tasks.cancel",
-					update: "tasks.update",
-					set_scope: "tasks.set_scope",
-					assign_project: "tasks.assign_project",
-					depend: "tasks.depend",
-					undepend: "tasks.undepend",
-					contain: "tasks.contain",
-					uncontain: "tasks.uncontain",
-				} as const;
-				const operation = operations[action as keyof typeof operations];
-				if (!operation) throw new Error(`unknown tasks action: ${action}`);
-				const artifact = await callService<Record<string, unknown>, Artifact>(operation, request);
-				if (operation === "tasks.focus") emitTaskFocusEvent({ taskId: artifact.id, sessionId: request.session_id as string, status: "focused" });
-				return text(artifactLine(artifact), createArtifactDetails(operation, artifact));
-				})();
-				if (notes.length > 0 && result.content[0]?.type === "text") result.content[0].text += `\n\n${notes.join("\n")}`;
-				return result;
-			} catch (error) {
-				throw new Error(`tasks failed: ${error instanceof Error ? error.message : error}`);
-			}
-		},
-	});
-}
-
-// notes.*, rules.*, docs.*, skills.*, playbooks.*, 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.
 
@@ -627,11 +341,11 @@ 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, and playbooks 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.
+// 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
+// interactive UI round-trip a stateless Vehicle operation can't express.
 export function registerDomainTools(pi: ExtensionAPI): void {
-	registerTasksTool(pi);
 	registerDiscussTool(pi);
 }

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.*, 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
@@ -16,12 +16,17 @@ import { RemoteVehicleClient } from "@danypops/vehicle-client/http";
 import { registerVehicleTools } from "@danypops/vehicle-client-pi";
 import { currentVehicleClientTarget } from "./service-client.ts";
 import { sessionSecretField } from "./session-identity.ts";
+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", "artifact:read", "artifact:write",
+	"playbooks:read", "playbooks:write", "tasks:read", "tasks:write",
+	"artifact:read", "artifact:write",
 ];
 
+/** Task Focus's own internal write needs a real, per-session secret -- see below. Every other tasks.* operation reads session_id purely for read-scoping and needs no secret. */
+const FOCUS_MUTATION_OPERATIONS = new Set(["tasks.focus", "tasks.pause", "tasks.unpause", "tasks.clear_focus"]);
+
 export async function registerNotesVehicle(pi: ExtensionAPI): Promise<void> {
 	const target = currentVehicleClientTarget();
 	if (!target) return;
@@ -30,17 +35,24 @@ export async function registerNotesVehicle(pi: ExtensionAPI): Promise<void> {
 		await registerVehicleTools(pi, client, {
 			permissions: REGISTERED_PERMISSIONS,
 			principal: { id: "pi-papyrus" },
-			// playbooks.invoke's own module handler authorizes an internal Task Focus write via
+			// playbooks.invoke's own module handler, and tasks.focus/pause/unpause/clear_focus's
+			// own module handlers, authorize an internal Task Focus write via
 			// sessionIdentity.assertAuthorized(session_id, session_secret) -- see
-			// @danypops/papyrus's src/vehicle/playbooks-vehicle.ts. That secret must never be a
-			// model-visible input field (the model has no business knowing or supplying it), so
-			// it travels here instead, in principal.claims, from this extension's own already-
-			// cached secret (registered at session_start -- see index.ts) -- the same value
-			// sessionSecretField() used to thread through as a raw RPC input field before this
-			// operation moved onto Vehicle.
-			resolveInvocation: ({ descriptor, context }) => {
-				if (descriptor.name !== "playbooks.invoke") return {};
-				const sessionId = context.sessionManager.getSessionId();
+			// @danypops/papyrus's src/vehicle/playbooks-vehicle.ts and tasks-vehicle.ts. That
+			// secret must never be a model-visible input field (the model has no business
+			// knowing or supplying it), so it travels here instead, in principal.claims, from
+			// this extension's own already-cached secret (registered at session_start -- see
+			// index.ts) -- the same value sessionSecretField() used to thread through as a raw
+			// RPC input field before these operations moved onto Vehicle.
+			resolveInvocation: ({ descriptor, input, context }) => {
+				if (descriptor.name !== "playbooks.invoke" && !FOCUS_MUTATION_OPERATIONS.has(descriptor.name)) return {};
+				// tasks.* defaults session_id to this Pi session's own id, same as the removed
+				// hand-rolled tool -- but the secret cache is keyed by whichever session_id is
+				// actually being authorized, not blindly this session's, so a model that
+				// explicitly overrides session_id to a DIFFERENT session never gets this
+				// session's secret smuggled in on its behalf.
+				const requestedSessionId = (input as { session_id?: unknown } | undefined)?.session_id;
+				const sessionId = typeof requestedSessionId === "string" && requestedSessionId.length > 0 ? requestedSessionId : context.sessionManager.getSessionId();
 				const { session_secret: sessionSecret } = sessionSecretField(sessionId);
 				// Omit sessionSecret entirely when nothing is cached (unregistered session) --
 				// {sessionSecret: null} would fail the module's own optionalString(input,
@@ -49,6 +61,26 @@ export async function registerNotesVehicle(pi: ExtensionAPI): Promise<void> {
 				const claims: Record<string, string> = sessionSecret ? { sessionId, sessionSecret } : { sessionId };
 				return { principal: { id: "pi-papyrus", claims } };
 			},
+			// papyrus.task-focus.v1 is a same-process Pi extension event bus broadcast (e.g. a
+			// token-cost router correlating its own telemetry with the currently focused task)
+			// -- has no Vehicle-transport equivalent, so it's emitted here, client-side, rather
+			// than from the operation's own output.
+			onInvoked: ({ descriptor }, output) => {
+				if (descriptor.name === "tasks.focus") {
+					const artifact = output as { id: string } | undefined;
+					if (artifact?.id) emitTaskFocusEvent({ taskId: artifact.id, status: "focused" });
+					return;
+				}
+				if (descriptor.name === "tasks.pause" || descriptor.name === "tasks.unpause") {
+					const focus = output as { artifact: { id: string } } | undefined;
+					if (focus?.artifact?.id) emitTaskFocusEvent({ taskId: focus.artifact.id, status: descriptor.name === "tasks.pause" ? "paused" : "unpaused" });
+					return;
+				}
+				if (descriptor.name === "tasks.clear_focus") {
+					const result = output as { cleared: boolean } | undefined;
+					if (result?.cleared) emitTaskFocusEvent({ taskId: null, status: "cleared" });
+				}
+			},
 		});
 	} catch {
 		// Daemon state is stale/unreachable -- degrade silently, matching

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-papyrus",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "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.40.0",
+    "@danypops/papyrus": "^0.42.0",
     "@danypops/vehicle-core": "^0.2.0",
     "@danypops/vehicle-server": "^0.1.1",
     "@danypops/vehicle-client": "^0.1.1",
-    "@danypops/vehicle-client-pi": "^0.2.0",
+    "@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");
-			}
-		},
-	});
-}