@danypops/papyrus 0.41.0 → 0.42.1

package/src/modules/notes.ts

@@ -12,9 +12,10 @@
  * OperationInput parsing helpers, matching the "module code does not import another
  * module's infrastructure" constraint.
  */
-import type { OperationDefinition } from "../module-registry.ts";
+
 import type { NoteEventDirection } from "../domain/note-event.ts";
-import { Notes, type NoteDisposition } from "../note-service.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import type { NoteDisposition, Notes } from "../note-service.ts";
 
 const MODULE_ID = "notes";
 
@@ -42,39 +43,76 @@ function optionalNumber(input: OperationInput, key: string): number | undefined
 
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const NOTES_OPERATION_NAMES = [
-	"notes.capture", "notes.list", "notes.show", "notes.history", "notes.consume", "notes.promote", "notes.archive",
+	"notes.capture",
+	"notes.list",
+	"notes.show",
+	"notes.history",
+	"notes.consume",
+	"notes.promote",
+	"notes.archive",
 ] as const;
 
 /** Registers every notes.* operation against one Notes instance. Behavior is unchanged from the prior inline handlers in src/service.ts. */
 export function notesOperations(notes: Notes): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("notes.capture", (input: OperationInput) => notes.capture({
-			body: string(input, "body"), title: optionalString(input, "title"), projectRoot: string(input, "project_root"),
-			actor: optionalString(input, "actor"), source: optionalString(input, "source"), sessionId: optionalString(input, "session_id"),
-		})),
-		define("notes.list", (input: OperationInput) => notes.list({
-			projectRoot: string(input, "project_root"), status: optionalString(input, "status") as "draft" | "active" | "archived" | undefined,
-			text: optionalString(input, "text"), limit: optionalNumber(input, "limit"),
-		})),
+		define("notes.capture", (input: OperationInput) =>
+			notes.capture({
+				body: string(input, "body"),
+				title: optionalString(input, "title"),
+				projectRoot: string(input, "project_root"),
+				actor: optionalString(input, "actor"),
+				source: optionalString(input, "source"),
+				sessionId: optionalString(input, "session_id"),
+			}),
+		),
+		define("notes.list", (input: OperationInput) =>
+			notes.list({
+				projectRoot: string(input, "project_root"),
+				status: optionalString(input, "status") as "draft" | "active" | "archived" | undefined,
+				text: optionalString(input, "text"),
+				limit: optionalNumber(input, "limit"),
+			}),
+		),
 		define("notes.show", (input: OperationInput) => notes.show(string(input, "id"), string(input, "project_root"))),
-		define("notes.history", (input: OperationInput) => notes.history(string(input, "id"), string(input, "project_root"), {
-			limit: optionalNumber(input, "limit"), cursor: optionalNumber(input, "cursor"), direction: optionalString(input, "direction") as NoteEventDirection | undefined,
-		})),
-		define("notes.consume", (input: OperationInput) => notes.consume(string(input, "id"), {
-			projectRoot: string(input, "project_root"), actor: optionalString(input, "actor"), source: optionalString(input, "source"),
-			sessionId: optionalString(input, "session_id"), reason: optionalString(input, "reason"),
-		})),
-		define("notes.promote", (input: OperationInput) => notes.promote(string(input, "id"), string(input, "target_id"), {
-			projectRoot: string(input, "project_root"), actor: optionalString(input, "actor"), source: optionalString(input, "source"),
-			sessionId: optionalString(input, "session_id"), reason: optionalString(input, "reason"),
-		})),
-		define("notes.archive", (input: OperationInput) => notes.archive(string(input, "id"), {
-			projectRoot: string(input, "project_root"), disposition: string(input, "disposition") as NoteDisposition,
-			actor: optionalString(input, "actor"), source: optionalString(input, "source"), sessionId: optionalString(input, "session_id"),
-			reason: optionalString(input, "reason"),
-		})),
+		define("notes.history", (input: OperationInput) =>
+			notes.history(string(input, "id"), string(input, "project_root"), {
+				limit: optionalNumber(input, "limit"),
+				cursor: optionalNumber(input, "cursor"),
+				direction: optionalString(input, "direction") as NoteEventDirection | undefined,
+			}),
+		),
+		define("notes.consume", (input: OperationInput) =>
+			notes.consume(string(input, "id"), {
+				projectRoot: string(input, "project_root"),
+				actor: optionalString(input, "actor"),
+				source: optionalString(input, "source"),
+				sessionId: optionalString(input, "session_id"),
+				reason: optionalString(input, "reason"),
+			}),
+		),
+		define("notes.promote", (input: OperationInput) =>
+			notes.promote(string(input, "id"), string(input, "target_id"), {
+				projectRoot: string(input, "project_root"),
+				actor: optionalString(input, "actor"),
+				source: optionalString(input, "source"),
+				sessionId: optionalString(input, "session_id"),
+				reason: optionalString(input, "reason"),
+			}),
+		),
+		define("notes.archive", (input: OperationInput) =>
+			notes.archive(string(input, "id"), {
+				projectRoot: string(input, "project_root"),
+				disposition: string(input, "disposition") as NoteDisposition,
+				actor: optionalString(input, "actor"),
+				source: optionalString(input, "source"),
+				sessionId: optionalString(input, "session_id"),
+				reason: optionalString(input, "reason"),
+			}),
+		),
 	];
 }

package/src/modules/playbooks.ts

@@ -1,11 +1,11 @@
 /**
  * modules/playbooks.ts — Playbooks as a Papyrus-native registered module.
  *
- * A Playbook (trigger + ordered steps, contains/depends_on composition, predefined
- * rules/docs) is a completely different beast from a Skill (a mechanically instantiated
- * artifact-template or workflow blueprint) at the AUTHORING level -- but playbooks.invoke
- * recycles the exact same materialization engine workflow Skills use (playbook-execution.ts
- * compiles a Playbook's composition tree into a SkillDefinition, then hands off to
+ * A Playbook is prose-first, whole-artifact composition (contains/depends_on between real
+ * Playbook artifacts) rather than a raw JSON blueprint -- but its own step list can also
+ * declare Doc/Rule blueprints and typed arguments and nested pipeline calls. playbooks.invoke
+ * recycles the shared blueprint materialization engine (playbook-execution.ts compiles a
+ * Playbook's steps and composition tree into a BlueprintDefinition, then hands off to
  * workflow-execution.ts's shared core). See domain-services.ts's Playbook section and
  * playbook-definition.ts for the full rationale.
  */
@@ -23,11 +23,11 @@ import {
 	updatePlaybook,
 } from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
+import { invokePlaybook } from "../playbook-execution.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 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";
 
@@ -75,8 +75,19 @@ const artifactFilter = (input: OperationInput) => ({
 
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const PLAYBOOKS_OPERATION_NAMES = [
-	"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",
+	"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",
 ] as const;
 
 export interface PlaybooksModuleDeps {
@@ -91,41 +102,91 @@ export interface PlaybooksModuleDeps {
 	sessionIdentity: SessionIdentity;
 }
 
-export function playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity }: 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,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("playbooks.create", (input: OperationInput) => createPlaybook(artifacts, artifactScopes, {
-			title: string(input, "title"), body: optionalString(input, "body"), trigger: optionalString(input, "trigger"),
-			steps: input["steps"] as string[] | undefined, tools: input["tools"] as string[] | undefined,
-			arguments: input["arguments"],
-			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
-			projectRoot: optionalString(input, "project_root"),
-		}, eventContext(input))),
+		define("playbooks.create", (input: OperationInput) =>
+			createPlaybook(
+				artifacts,
+				artifactScopes,
+				{
+					title: string(input, "title"),
+					body: optionalString(input, "body"),
+					trigger: optionalString(input, "trigger"),
+					steps: input.steps,
+					tools: input.tools as string[] | undefined,
+					arguments: input.arguments,
+					labels: input.labels as string[] | undefined,
+					extra: input.extra as Record<string, unknown> | undefined,
+					projectRoot: optionalString(input, "project_root"),
+				},
+				eventContext(input),
+			),
+		),
 		define("playbooks.list", (input: OperationInput) => listPlaybooks(artifacts, artifactScopes, artifactFilter(input))),
 		define("playbooks.show", (input: OperationInput) => showPlaybook(artifacts, string(input, "id"))),
-		define("playbooks.preview", (input: OperationInput) => playbookInvocation(artifacts, string(input, "id"), input["arguments"] as Record<string, string> | undefined)),
+		define("playbooks.preview", (input: OperationInput) =>
+			playbookInvocation(artifacts, string(input, "id"), input.arguments as Record<string, unknown> | undefined),
+		),
 		define("playbooks.invoke", (input: OperationInput) => {
-			const result = invokePlaybook(artifacts, string(input, "id"), {
-				runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
-				arguments: input["arguments"] as Record<string, unknown> | undefined,
-			}, { events, scopes, projectRoot: optionalString(input, "project_root"), context: eventContextFor(input, "playbook-run") });
+			const result = invokePlaybook(
+				artifacts,
+				string(input, "id"),
+				{
+					runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
+					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;
 			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))),
-		define("playbooks.disable", (input: OperationInput) => transitionPlaybook(artifacts, string(input, "id"), "disable", eventContext(input))),
-		define("playbooks.assign_project", (input: OperationInput) => assignPlaybookProject(artifacts, artifactScopes, string(input, "id"), optionalString(input, "project_root"))),
-		define("playbooks.update", (input: OperationInput) => updatePlaybook(artifacts, string(input, "id"), {
-			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
-		}, eventContext(input))),
-		define("playbooks.contain", (input: OperationInput) => containPlaybook(artifacts, string(input, "parent_id"), string(input, "child_id"), eventContext(input))),
-		define("playbooks.uncontain", (input: OperationInput) => uncontainPlaybook(artifacts, string(input, "parent_id"), string(input, "child_id"), eventContext(input))),
-		define("playbooks.depend", (input: OperationInput) => dependPlaybook(artifacts, string(input, "id"), string(input, "dependency_id"), eventContext(input))),
-		define("playbooks.undepend", (input: OperationInput) => undependPlaybook(artifacts, string(input, "id"), string(input, "dependency_id"), eventContext(input))),
+		define("playbooks.enable", (input: OperationInput) =>
+			transitionPlaybook(artifacts, string(input, "id"), "enable", eventContext(input)),
+		),
+		define("playbooks.disable", (input: OperationInput) =>
+			transitionPlaybook(artifacts, string(input, "id"), "disable", eventContext(input)),
+		),
+		define("playbooks.assign_project", (input: OperationInput) =>
+			assignPlaybookProject(artifacts, artifactScopes, string(input, "id"), optionalString(input, "project_root")),
+		),
+		define("playbooks.update", (input: OperationInput) =>
+			updatePlaybook(
+				artifacts,
+				string(input, "id"),
+				{
+					title: optionalString(input, "title"),
+					body: optionalString(input, "body"),
+					labels: input.labels as string[] | undefined,
+				},
+				eventContext(input),
+			),
+		),
+		define("playbooks.contain", (input: OperationInput) =>
+			containPlaybook(artifacts, string(input, "parent_id"), string(input, "child_id"), eventContext(input)),
+		),
+		define("playbooks.uncontain", (input: OperationInput) =>
+			uncontainPlaybook(artifacts, string(input, "parent_id"), string(input, "child_id"), eventContext(input)),
+		),
+		define("playbooks.depend", (input: OperationInput) =>
+			dependPlaybook(artifacts, string(input, "id"), string(input, "dependency_id"), eventContext(input)),
+		),
+		define("playbooks.undepend", (input: OperationInput) =>
+			undependPlaybook(artifacts, string(input, "id"), string(input, "dependency_id"), eventContext(input)),
+		),
 	];
 }

package/src/modules/rules.ts

@@ -10,7 +10,16 @@
  * into this module or introducing a premature "modules call each other through the
  * registry" convention.
  */
-import { assignRuleProject, createRule, gateTaskWithRule, listRules, previewRule, showRule, transitionRule, updateRule } from "../domain-services.ts";
+import {
+	assignRuleProject,
+	createRule,
+	gateTaskWithRule,
+	listRules,
+	previewRule,
+	showRule,
+	transitionRule,
+	updateRule,
+} from "../domain-services.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { ArtifactScopeStore } from "../ports/artifact-scope-store.ts";
 import type { ArtifactStore } from "../ports/artifact-store.ts";
@@ -55,30 +64,63 @@ const artifactFilter = (input: OperationInput) => ({
 /** Registers every rules.* operation except rules.injectable (see module comment). Behavior is unchanged from the prior inline handlers in src/service.ts. */
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. rules.injectable is deliberately absent -- see the module comment above. */
 export const RULES_OPERATION_NAMES = [
-	"rules.create", "rules.list", "rules.show", "rules.preview", "rules.enable", "rules.disable", "rules.gate", "rules.assign_project", "rules.update",
+	"rules.create",
+	"rules.list",
+	"rules.show",
+	"rules.preview",
+	"rules.enable",
+	"rules.disable",
+	"rules.gate",
+	"rules.assign_project",
+	"rules.update",
 ] as const;
 
 export function rulesOperations(artifacts: ArtifactStore, scopes: ArtifactScopeStore): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
-		define("rules.create", (input: OperationInput) => createRule(artifacts, scopes, {
-			title: string(input, "title"), body: optionalString(input, "body"), condition: optionalString(input, "condition"),
-			action: optionalString(input, "rule_action") ?? optionalString(input, "governance_action"),
-			severity: optionalString(input, "severity") as "block" | "warn" | "info" | undefined,
-			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
-			projectRoot: optionalString(input, "project_root"),
-		}, eventContext(input))),
+		define("rules.create", (input: OperationInput) =>
+			createRule(
+				artifacts,
+				scopes,
+				{
+					title: string(input, "title"),
+					body: optionalString(input, "body"),
+					condition: optionalString(input, "condition"),
+					action: optionalString(input, "rule_action") ?? optionalString(input, "governance_action"),
+					severity: optionalString(input, "severity") as "block" | "warn" | "info" | undefined,
+					labels: input.labels as string[] | undefined,
+					extra: input.extra as Record<string, unknown> | undefined,
+					projectRoot: optionalString(input, "project_root"),
+				},
+				eventContext(input),
+			),
+		),
 		define("rules.list", (input: OperationInput) => listRules(artifacts, scopes, artifactFilter(input))),
 		define("rules.show", (input: OperationInput) => showRule(artifacts, string(input, "id"))),
 		define("rules.preview", (input: OperationInput) => previewRule(artifacts, string(input, "id"))),
 		define("rules.enable", (input: OperationInput) => transitionRule(artifacts, string(input, "id"), "enable", eventContext(input))),
 		define("rules.disable", (input: OperationInput) => transitionRule(artifacts, string(input, "id"), "disable", eventContext(input))),
-		define("rules.gate", (input: OperationInput) => gateTaskWithRule(artifacts, string(input, "id"), string(input, "task_id"), eventContext(input))),
-		define("rules.assign_project", (input: OperationInput) => assignRuleProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),
-		define("rules.update", (input: OperationInput) => updateRule(artifacts, string(input, "id"), {
-			title: optionalString(input, "title"), body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
-		}, eventContext(input))),
+		define("rules.gate", (input: OperationInput) =>
+			gateTaskWithRule(artifacts, string(input, "id"), string(input, "task_id"), eventContext(input)),
+		),
+		define("rules.assign_project", (input: OperationInput) =>
+			assignRuleProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root")),
+		),
+		define("rules.update", (input: OperationInput) =>
+			updateRule(
+				artifacts,
+				string(input, "id"),
+				{
+					title: optionalString(input, "title"),
+					body: optionalString(input, "body"),
+					labels: input.labels as string[] | undefined,
+				},
+				eventContext(input),
+			),
+		),
 	];
 }

package/src/modules/session-identity.ts

@@ -29,10 +29,14 @@ export const SESSION_IDENTITY_OPERATION_NAMES = ["session.register", "session.re
 /** Registers every session.* operation against one SessionIdentity instance. */
 export function sessionIdentityOperations(sessionIdentity: SessionIdentity): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
-		name, moduleId: MODULE_ID, execute,
+		name,
+		moduleId: MODULE_ID,
+		execute,
 	});
 	return [
 		define("session.register", (input: OperationInput) => sessionIdentity.register(string(input, "session_id"))),
-		define("session.release", (input: OperationInput) => sessionIdentity.release(string(input, "session_id"), optionalString(input, "session_secret"))),
+		define("session.release", (input: OperationInput) =>
+			sessionIdentity.release(string(input, "session_id"), optionalString(input, "session_secret")),
+		),
 	];
 }