@danypops/papyrus 0.36.0 → 0.37.0

package/package.json

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

package/src/cli.ts

@@ -169,6 +169,7 @@ const USAGE = `Usage:
   papyrus tasks reject <id> [--session-id <id>] [--json]
   papyrus tasks retry <id> [--session-id <id>] [--json]
   papyrus tasks cancel <id> [--session-id <id>] [--json]
+  papyrus tasks cancel-subtree <id> [--session-id <id>] [--json]
   papyrus tasks depend <id> <prerequisite-id> [--reason <reason>] [--session-id <id>] [--json]
   papyrus tasks undepend <id> <prerequisite-id> [--reason <reason>] [--session-id <id>] [--json]
   papyrus tasks contain <parent-id> <child-id> [--reason <reason>] [--session-id <id>] [--json]
@@ -1740,6 +1741,13 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 			human = `${action[0]!.toUpperCase()}${action.slice(1)}: ${artifactLabel(artifact)}`;
 			break;
 		}
+		case "cancel-subtree": {
+			if (!id || dependencyId) throw new Error("tasks cancel-subtree requires exactly one task id");
+			const outcome = await client.call<Record<string, unknown>, { canceled: string[]; skipped: string[] }>("tasks.cancel_subtree", { id, actor: "user", source: "cli", ...sessionScope });
+			result = outcome;
+			human = `Canceled ${outcome.canceled.length} task(s)${outcome.skipped.length > 0 ? `, skipped ${outcome.skipped.length} already-terminal` : ""}.`;
+			break;
+		}
 		case "depend": {
 			if (!id || !dependencyId || positional.length !== 3) throw new Error("tasks depend requires a task id and prerequisite id");
 			const artifact = await client.call<Record<string, unknown>, CliArtifact>("tasks.depend", {
@@ -1759,7 +1767,7 @@ export async function runTaskCli(args: string[], client: TaskCliClient, projectR
 			break;
 		}
 		default:
-			throw new Error("tasks action must be create, list, show, active, focused, focus, pause, unpause, clear-focus, update, graph, plan, context, history, scope, assign-project, complete, start, submit, reject, retry, cancel, depend, undepend, contain, uncontain, run-gates, set-checklist, or set-gates");
+			throw new Error("tasks action must be create, list, show, active, focused, focus, pause, unpause, clear-focus, update, graph, plan, context, history, scope, assign-project, complete, start, submit, reject, retry, cancel, cancel-subtree, depend, undepend, contain, uncontain, run-gates, set-checklist, or set-gates");
 	}
 	return json ? JSON.stringify(result) : human;
 }

package/src/constants.ts

@@ -121,6 +121,9 @@ export const PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH = 500;
  */
 export const PLAYBOOK_INVOCATION_MAX_CREATED_TASKS = 200;
 
+/** Tasks.cancelSubtree walks `contains` edges transitively (a whole materialized playbook run can be torn down in one call instead of enumerating every task id by hand) -- bounded the same way PLAYBOOK_INVOCATION_MAX_CREATED_TASKS bounds the forward direction. */
+export const TASK_CANCEL_SUBTREE_MAX_NODES = 500;
+
 /**
  * At the core, a workflow Skill creates Tasks and begins a pipeline -- an Ansible playbook or
  * a Jenkins job, not just a text prompt. A pipeline step can itself trigger another workflow

package/src/modules/playbooks.ts

@@ -28,6 +28,7 @@ import type { ArtifactStore } from "../ports/artifact-store.ts";
 import type { TaskEventStore } from "../ports/task-event-store.ts";
 import type { TaskScopeStore } from "../ports/task-scope-store.ts";
 import { invokePlaybook } from "../playbook-execution.ts";
+import type { SessionIdentity } from "../session-identity-service.ts";
 import type { Tasks } from "../task-service.ts";
 
 const MODULE_ID = "playbooks";
@@ -86,9 +87,11 @@ export interface PlaybooksModuleDeps {
 	artifactScopes: ArtifactScopeStore;
 	/** Used for exactly one thing: focusing the entry task after a successful invoke -- the one safety-checked Tasks operation this module needs, not bulk graph construction (that goes straight through artifacts/events/scopes in playbook-execution.ts, mirroring workflow-execution.ts). */
 	tasks: Tasks;
+	/** Guards the same session_secret check tasks.focus's own operation enforces (guardFocusMutation in modules/tasks.ts) -- invoke's internal tasks.focus() call goes straight through the Tasks class, bypassing that operation wrapper entirely, so the check must be applied here instead of silently skipped. */
+	sessionIdentity: SessionIdentity;
 }
 
-export function playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks }: PlaybooksModuleDeps): OperationDefinition[] {
+export function playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity }: PlaybooksModuleDeps): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
 		name, moduleId: MODULE_ID, execute,
 	});
@@ -109,7 +112,9 @@ export function playbooksOperations({ artifacts, events, scopes, artifactScopes,
 				arguments: input["arguments"] as Record<string, unknown> | undefined,
 			}, { events, scopes, projectRoot: optionalString(input, "project_root"), context: eventContextFor(input, "playbook-run") });
 			if ("missingArguments" in result) return result;
-			tasks.focus(result.entryTaskId, eventContextFor(input, "playbook-run"));
+			const focusContext = eventContextFor(input, "playbook-run");
+			sessionIdentity.assertAuthorized(focusContext.sessionId, optionalString(input, "session_secret"));
+			tasks.focus(result.entryTaskId, focusContext);
 			return result;
 		}),
 		define("playbooks.enable", (input: OperationInput) => transitionPlaybook(artifacts, string(input, "id"), "enable", eventContext(input))),

package/src/modules/tasks.ts

@@ -90,7 +90,7 @@ export const TASKS_OPERATION_NAMES = [
 	"tasks.create", "tasks.update", "tasks.list", "tasks.graph", "tasks.plan", "tasks.show", "tasks.history",
 	"tasks.scope", "tasks.set_scope", "tasks.assign_project", "tasks.active", "tasks.focused", "tasks.focus",
 	"tasks.pause", "tasks.unpause", "tasks.clear_focus", "tasks.start", "tasks.submit", "tasks.complete",
-	"tasks.run_gates", "tasks.set_checklist", "tasks.set_gates", "tasks.context", "tasks.reject", "tasks.retry", "tasks.cancel",
+	"tasks.run_gates", "tasks.set_checklist", "tasks.set_gates", "tasks.context", "tasks.reject", "tasks.retry", "tasks.cancel", "tasks.cancel_subtree",
 	"tasks.depend", "tasks.undepend", "tasks.contain", "tasks.uncontain", "tasks.reap_stale_focus",
 	"tasks.claim", "tasks.heartbeat_lease", "tasks.release_lease", "tasks.lease", "tasks.reap_stale_leases", "tasks.event_feed",
 ] as const;
@@ -169,6 +169,7 @@ export function tasksOperations(tasks: Tasks, artifacts: ArtifactStore, sessionI
 		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))),
 		define("tasks.cancel", (input: OperationInput) => tasks.transition(string(input, "id"), "cancel", eventContext(input))),
+		define("tasks.cancel_subtree", (input: OperationInput) => tasks.cancelSubtree(string(input, "id"), eventContext(input))),
 		define("tasks.depend", (input: OperationInput) => tasks.depend(string(input, "id"), string(input, "dependency_id"), eventContext(input))),
 		define("tasks.undepend", (input: OperationInput) => tasks.undepend(string(input, "id"), string(input, "dependency_id"), eventContext(input))),
 		define("tasks.contain", (input: OperationInput) => tasks.contain(string(input, "parent_id"), string(input, "child_id"), eventContext(input))),

package/src/playbook-definition.ts

@@ -42,10 +42,17 @@ export interface CompiledPlaybook {
 	externalLinks: PlaybookExternalLink[];
 }
 
+/** Trashed but not yet purged: artifacts.get() still returns it (trash is separate, orthogonal metadata -- "still directly showable"), so a stale composition edge left behind by remove/uncontain would otherwise resolve straight through and get compiled in. query() excludes trashed artifacts by default; use that instead of get() for every existence check a compiler makes. */
+function nonTrashedPlaybookIds(artifacts: ArtifactStore, ids: string[]): Set<string> {
+	if (ids.length === 0) return new Set();
+	return new Set(artifacts.query({ ids, kind: "playbook" }).map((artifact) => artifact.id));
+}
+
 function requirePlaybook(artifacts: ArtifactStore, id: string): Artifact {
 	const playbook = artifacts.get(id);
 	if (!playbook) throw new Error(`playbook artifact "${id}" not found`);
 	if (playbook.kind !== "playbook") throw new Error(`artifact "${id}" is not a playbook`);
+	if (!nonTrashedPlaybookIds(artifacts, [id]).has(id)) throw new Error(`playbook artifact "${id}" is trashed`);
 	return playbook;
 }
 
@@ -121,12 +128,13 @@ function compileNode(
 	if (ctx.tasks.length > PLAYBOOK_INVOCATION_MAX_CREATED_TASKS) throw new Error(`playbook invocation exceeds ${PLAYBOOK_INVOCATION_MAX_CREATED_TASKS} tasks`);
 
 	const edges = artifacts.relationships({ artifactIds: [playbookId] }).slice(0, PLAYBOOK_INVOCATION_MAX_LINKED_ARTIFACTS);
+	const composablePlaybookIds = nonTrashedPlaybookIds(artifacts, edges.filter((edge) => edge.from === playbookId).map((edge) => edge.to));
 	const prerequisiteIds = edges.filter((edge) => edge.from === playbookId && edge.relation === "depends_on").map((edge) => edge.to)
-		.filter((id) => artifacts.get(id)?.kind === "playbook");
+		.filter((id) => composablePlaybookIds.has(id));
 	const nestedIds = edges.filter((edge) => edge.from === playbookId && edge.relation === "contains").map((edge) => edge.to)
-		.filter((id) => artifacts.get(id)?.kind === "playbook");
+		.filter((id) => composablePlaybookIds.has(id));
 	for (const edge of edges) {
-		const isComposingFrom = edge.from === playbookId && (edge.relation === "contains" || edge.relation === "depends_on") && artifacts.get(edge.to)?.kind === "playbook";
+		const isComposingFrom = edge.from === playbookId && (edge.relation === "contains" || edge.relation === "depends_on") && composablePlaybookIds.has(edge.to);
 		if (isComposingFrom) continue;
 		if (edge.from === playbookId) ctx.externalLinks.push({ rootRef, relation: edge.relation, otherArtifactId: edge.to, ownerIsFrom: true });
 		else if (edge.to === playbookId) ctx.externalLinks.push({ rootRef, relation: edge.relation, otherArtifactId: edge.from, ownerIsFrom: false });

package/src/service.ts

@@ -359,6 +359,7 @@ function handlers(
 		"tasks.reject": forwardToModule("tasks.reject"),
 		"tasks.retry": forwardToModule("tasks.retry"),
 		"tasks.cancel": forwardToModule("tasks.cancel"),
+		"tasks.cancel_subtree": forwardToModule("tasks.cancel_subtree"),
 		"tasks.depend": forwardToModule("tasks.depend"),
 		"tasks.undepend": forwardToModule("tasks.undepend"),
 		"tasks.contain": forwardToModule("tasks.contain"),
@@ -481,7 +482,7 @@ export function createPapyrusService(path: string): PapyrusService {
 	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority));
 	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes));
 	moduleRegistry.registerAll(skillsOperations({ artifacts, events, scopes, artifactScopes, authority }));
-	moduleRegistry.registerAll(playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks }));
+	moduleRegistry.registerAll(playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity }));
 	moduleRegistry.registerAll(graphProjectionOperations(artifacts, projections, authority));
 	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, () => migrateDb(db), moduleRegistry, authority);
 	const state = (): SchemaState => {

package/src/task-service.ts

@@ -1,5 +1,6 @@
 import {
 	TASK_BODY_MAX_LENGTH,
+	TASK_CANCEL_SUBTREE_MAX_NODES,
 	TASK_EXECUTION_MAX_DEGREE,
 	TASK_EXECUTION_MAX_EDGES,
 	TASK_EXECUTION_MAX_NODES,
@@ -459,6 +460,41 @@ export class Tasks {
 		});
 	}
 
+	/**
+	 * Cancels a task and every task in its containment subtree (`contains` edges, transitively) --
+	 * a whole materialized playbook/skill run can be torn down in one call instead of enumerating
+	 * every task id by hand. A task already in a terminal state (done/canceled) is skipped, not
+	 * treated as an error, matching how a mixed-status subtree is the normal case (some steps
+	 * genuinely finished before the rest needed to be abandoned). Does not follow `depends_on` --
+	 * only containment cascades, a prerequisite is a different unit of work.
+	 */
+	cancelSubtree(id: string, context: TaskEventContext = {}): { canceled: string[]; skipped: string[] } {
+		this.require(id);
+		const visited = new Set<string>();
+		const queue = [id];
+		const canceled: string[] = [];
+		const skipped: string[] = [];
+		while (queue.length > 0) {
+			const current = queue.shift()!;
+			if (visited.has(current)) continue;
+			visited.add(current);
+			if (visited.size > TASK_CANCEL_SUBTREE_MAX_NODES) throw new Error(`cancelSubtree exceeds ${TASK_CANCEL_SUBTREE_MAX_NODES} tasks`);
+			const task = this.artifacts.get(current);
+			if (!task || task.kind !== "task") continue;
+			const childIds = this.artifacts.relationships({ artifactIds: [current] })
+				.filter((edge) => edge.from === current && edge.relation === "contains")
+				.map((edge) => edge.to);
+			queue.push(...childIds);
+			if (task.status === "done" || task.status === "canceled") {
+				skipped.push(current);
+				continue;
+			}
+			this.transition(current, "cancel", context);
+			canceled.push(current);
+		}
+		return { canceled, skipped };
+	}
+
 	complete(id: string, context: TaskEventContext = {}, options: TaskCompletionOptions = {}): TaskCompletion {
 		const task = this.requireReview(id);
 		this.requireNotBlocked(task);