@danypops/papyrus 0.32.1 → 0.33.0

package/README.md

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

package/extension/src/domain-tools.ts

@@ -238,7 +238,7 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "tasks",
 		label: "Tasks",
-		description: "Task domain tool. ACTIONS: create, update, list, show, history, scope, set_scope, assign_project, graph, plan, active, focused, focus, pause, unpause, clear_focus, start, submit, complete, reject, retry, cancel, run_gates, set_checklist, depend, undepend, contain, uncontain, remove, restore, claim, heartbeat_lease, release_lease, lease, event_feed. Lifecycle is todo → in-progress → review → done, with review failure → rejected and retry → in-progress; canceled is terminal. update can recover a Task accidentally created terminal by setting status=todo with a reason, but cannot rewrite legitimate lifecycle history. Active focus is independent and identifies the one task auto-drive continues. Completion runs gates and checklist-proof review, then focuses one deterministic ready successor without claiming effort. Dependency cycles are rejected. undepend/uncontain are idempotent for an already-absent relationship and never start, complete, or focus work merely because an edge disappeared; uncontain removes both contains and part_of edges atomically. remove moves a Task to a time-gated trash (restorable via restore until the purge deadline; refuses if it is the live Task Focus). claim/heartbeat_lease/release_lease/lease manage a bounded work-reservation lease -- independent of both lifecycle status and Focus, so multiple sessions can Focus the same task while only one owner holds its lease at a time; claim throws if a DIFFERENT owner already holds a live lease, release/heartbeat require the exact token claim returned. `owner` defaults to this session's own id when omitted. PREFER addressing a task by `name` (its exact title) over `id` for every action -- id is a backend implementation detail, resolved from name automatically, and only needs to appear explicitly when a name is genuinely ambiguous (two tasks share a title; the error will say so and list the real ids to disambiguate with). Task results likewise show name and status, not id, unless two shown tasks share a title. `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` are the name-based equivalents of `dependency_id`/`parent_id`/`child_id`/`root_task_id`/`depends_on`. Prefer this over low-level papyrus_* tools for task work.",
+		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, run_gates, set_checklist, depend, undepend, contain, uncontain, remove, restore, claim, heartbeat_lease, release_lease, lease, event_feed. context returns the full current/desired/verify reconciliation plan for the active task(s) -- the system prompt is injected with only a one-line pointer to save tokens on turns that don't need it; call this explicitly when you actually need the full plan (e.g. after a compaction, or before reconciling). Lifecycle is todo → in-progress → review → done, with review failure → rejected and retry → in-progress; canceled is terminal. update can recover a Task accidentally created terminal by setting status=todo with a reason, but cannot rewrite legitimate lifecycle history. Active focus is independent and identifies the one task auto-drive continues. Completion runs gates and checklist-proof review, then focuses one deterministic ready successor without claiming effort. Dependency cycles are rejected. undepend/uncontain are idempotent for an already-absent relationship and never start, complete, or focus work merely because an edge disappeared; uncontain removes both contains and part_of edges atomically. remove moves a Task to a time-gated trash (restorable via restore until the purge deadline; refuses if it is the live Task Focus). claim/heartbeat_lease/release_lease/lease manage a bounded work-reservation lease -- independent of both lifecycle status and Focus, so multiple sessions can Focus the same task while only one owner holds its lease at a time; claim throws if a DIFFERENT owner already holds a live lease, release/heartbeat require the exact token claim returned. `owner` defaults to this session's own id when omitted. PREFER addressing a task by `name` (its exact title) over `id` for every action -- id is a backend implementation detail, resolved from name automatically, and only needs to appear explicitly when a name is genuinely ambiguous (two tasks share a title; the error will say so and list the real ids to disambiguate with). Task results likewise show name and status, not id, unless two shown tasks share a title. `dependency_name`/`parent_name`/`child_name`/`root_task_name`/`depends_on_names` are the name-based equivalents of `dependency_id`/`parent_id`/`child_id`/`root_task_id`/`depends_on`. Prefer this over low-level papyrus_* tools for task work.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -390,6 +390,11 @@ export function registerTasksTool(pi: ExtensionAPI): void {
 					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));

package/extension/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * pi-papyrus — native Pi extension for the Papyrus graph store.
  *
- * Tools: papyrus_create/query/graph/show.
+ * Tools: papyrus_query/graph/show (low-level), plus one native tool per domain (docs/rules/skills/playbooks/tasks/discuss/notes).
  * Command: /tasks (interactive task panel).
  * Widget: persistent task status above editor (rpiv-todo pattern).
  * Injection: active rules + open tasks appended to system prompt every turn.
@@ -279,43 +279,6 @@ export default async function (pi: ExtensionAPI) {
 
 	// ── Low-level graph-store tools ────────────────────────────────────
 
-	pi.registerTool({
-		name: "papyrus_create",
-		label: "Papyrus Create",
-		description:
-			"Create a graph artifact. KINDS: doc (knowledge — specs, decisions, research), " +
-			"task (work — with gates/checklists in extra), rule (governance — when doing X, follow Y; " +
-			"active rules inject into the system prompt), skill (parameterized workflow bundle — validated inputs render connected Tasks, Rules, and Docs). " +
-			"RULE extra: {condition, action, severity: 'block'|'warn'|'info'}. " +
-			"TASK extra: {gates: [{type:'file-exists'|'contains'|'command'|'test', target, expect}], checklist: {'criterion': {proof: [{type:'file'|'symbol'|'code'|'test'|'command'|'artifact'|'url', target, expect}]}}}. " +
-			"Legacy SKILL extra: {trigger, steps: [...], tools: [...]}. Workflow Skill schemas are versioned separately. " +
-			"Templates are skills with subtype='artifact-template' and extra {targetKind, defaults, required}; pass template_id to instantiate.",
-		parameters: Type.Object({
-			kind: Type.Optional(Type.String({ description: "doc | task | rule | skill; optional when template_id supplies targetKind" })),
-			title: Type.Optional(Type.String({ description: "required unless supplied by template defaults" })),
-			status: Type.Optional(Type.String({ description: "default: first registered for kind" })),
-			subtype: Type.Optional(Type.String()),
-			body: Type.Optional(Type.String()),
-			labels: Type.Optional(Type.Array(Type.String())),
-			extra: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-			template_id: Type.Optional(Type.String({ description: "skill/artifact-template id whose defaults and requirements apply" })),
-			project_root: Type.Optional(Type.String({ description: "required for Tasks; defaults to Pi cwd" })),
-		}),
-		renderCall(args, theme) { return renderPapyrusToolCall("Create artifact", args, theme); },
-		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },
-		async execute(_id, params, _signal, _onUpdate, ctx) {
-			try {
-				const a = await callService<Record<string, unknown>, Artifact>("artifact.create", {
-					...params,
-					...(params.kind === "task" ? { project_root: params.project_root ?? ctx.cwd } : {}),
-				});
-				return text(`Created ${artifactTextLabel(a)}`, createArtifactDetails("artifact.create", a));
-			} catch (e) {
-				throw new Error(`papyrus_create failed: ${e instanceof Error ? e.message : e}`);
-			}
-		},
-	});
-
 	pi.registerTool({
 		name: "papyrus_query",
 		label: "Papyrus Query",
@@ -644,7 +607,7 @@ export default async function (pi: ExtensionAPI) {
 			const [rules, playbooks, summary] = await Promise.all([
 				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd, session_id: sessionId }),
 				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "extra">>>("playbooks.list", { status: "active", limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS }),
-				callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd, session_id: sessionId }),
+				callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd, session_id: sessionId, verbosity: "summary" }),
 			]);
 			const injection = buildContextInjection({
 				basePrompt: event.systemPrompt ?? "",

package/package.json

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

package/src/modules/tasks.ts

@@ -164,6 +164,7 @@ export function tasksOperations(tasks: Tasks, artifacts: ArtifactStore, sessionI
 			artifacts,
 			tasks.active(taskFilter(input))?.id,
 			new Set(tasks.list(taskFilter(input)).map((task) => task.id)),
+			optionalString(input, "verbosity") === "summary" ? "summary" : "full",
 		)),
 		define("tasks.reject", (input: OperationInput) => tasks.transition(string(input, "id"), "reject", eventContext(input))),
 		define("tasks.retry", (input: OperationInput) => tasks.transition(string(input, "id"), "retry", eventContext(input))),

package/src/task-context.ts

@@ -35,6 +35,11 @@ function renderCurrent(task: Artifact): string[] {
 	];
 }
 
+/** The unconditional-injection form: enough to know the current task and that fuller detail exists, without repeating its full Desired/Verify prose every turn. */
+function renderCurrentSummary(task: Artifact): string[] {
+	return [`Current: ${task.title} [${task.status}] -- call tasks(action="context") for the full current/desired/verify plan`];
+}
+
 /** Same scoping rule taskContext already applies to ordinary tasks, plus the focused task even if scope excludes it. */
 function inScope(taskId: string, activeTaskId: string | undefined, taskIds: Set<string> | undefined): boolean {
 	return taskIds === undefined || taskIds.has(taskId) || taskId === activeTaskId;
@@ -62,7 +67,16 @@ function deferredBlockingDiscussions(artifacts: ArtifactStore, activeTaskId: str
 	return lines;
 }
 
-export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>): string | null {
+export type TaskContextVerbosity = "summary" | "full";
+
+/**
+ * verbosity="full" (the default, matching tasks(action="context") called on demand) renders the
+ * current task's complete Desired/Verify plan. verbosity="summary" (used for the unconditional
+ * system-prompt injection every turn) renders only enough for the agent to know a current task
+ * exists and that the full plan is one explicit call away -- avoiding repeating the same
+ * unchanged prose every single turn for a task that can persist across dozens of turns.
+ */
+export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>, verbosity: TaskContextVerbosity = "full"): string | null {
 	const tasks = artifacts.query({ kind: "task", excludeSubtype: DISCUSSION_SUBTYPE })
 		.filter((task) => taskIds === undefined || taskIds.has(task.id))
 		.sort((left, right) => left.updated_at.localeCompare(right.updated_at));
@@ -76,7 +90,8 @@ export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, tas
 	const next = open.find((task) => task.status === "todo");
 	const rejected = open.filter((task) => task.status === "rejected").slice(0, TASK_CONTEXT_REJECTED_LIMIT);
 	const lines = tasks.length > 0 ? [`Progress: ${done}/${tasks.length} done`] : [];
-	for (const task of current) lines.push(...renderCurrent(task));
+	const renderTask = verbosity === "summary" ? renderCurrentSummary : renderCurrent;
+	for (const task of current) lines.push(...renderTask(task));
 	if (next) lines.push(`Next: ${next.title}`);
 	if (rejected.length > 0) lines.push(`Rejected: ${rejected.map((task) => task.title).join(", ")}`);
 	if (deferredDiscussions.length > 0) {