@danypops/papyrus 0.11.3 → 0.12.0

package/src/module-registry.ts

@@ -0,0 +1,53 @@
+/**
+ * module-registry.ts — Branch-by-Abstraction step 1 of the modules/projections refactor
+ * (see docs reducing-papyrus-consumer-change-amplification-with-modules--pvdo and
+ * papyrus-full-context-mesh-and-domain-storage-ownership-bound-qhzp).
+ *
+ * A statically registered operation descriptor replaces one entry of the central
+ * operation switch in src/service.ts. This is intentionally minimal for this slice:
+ * one registry, one contract, no dynamic loading, no migration/authority/CLI descriptors
+ * yet — those are separate follow-up steps. The goal is to prove the shape end-to-end
+ * for a real module (Notes) without changing any observable behavior.
+ */
+
+export interface OperationDefinition<Input = unknown, Output = unknown> {
+	/** Dotted operation name, e.g. "notes.capture". Must be unique across every registered module. */
+	readonly name: string;
+	/** Owning module id, e.g. "notes". Used for boot diagnostics and future authority/migration scoping. */
+	readonly moduleId: string;
+	execute(input: Input): Output | Promise<Output>;
+}
+
+/**
+ * O(1) name -> descriptor lookup. Boot-time registration is O(N) and rejects duplicate
+ * names immediately rather than silently letting the last registration win, so a module
+ * collision fails fast instead of producing quiet cross-module dispatch bugs.
+ */
+export class OperationRegistry {
+	private readonly operations = new Map<string, OperationDefinition>();
+
+	register(operation: OperationDefinition): void {
+		const existing = this.operations.get(operation.name);
+		if (existing) {
+			throw new Error(`operation "${operation.name}" is already registered by module "${existing.moduleId}"`);
+		}
+		this.operations.set(operation.name, operation);
+	}
+
+	registerAll(operations: readonly OperationDefinition[]): void {
+		for (const operation of operations) this.register(operation);
+	}
+
+	get(name: string): OperationDefinition | undefined {
+		return this.operations.get(name);
+	}
+
+	has(name: string): boolean {
+		return this.operations.has(name);
+	}
+
+	/** Bounded by registration count, not a runtime query — safe to call freely for diagnostics/CLI listing. */
+	list(): string[] {
+		return [...this.operations.keys()].sort();
+	}
+}

package/src/modules/docs.ts

@@ -0,0 +1,77 @@
+/**
+ * modules/docs.ts — Docs as a Papyrus-native registered module
+ * (step 5, continued, of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo).
+ *
+ * Imports only src/domain-services.ts's Doc functions, which are already generic
+ * ArtifactStore-based with no other module's concrete class dependency.
+ */
+import type { AuthorityRegistry } from "../authority-registry.ts";
+import { assignDocumentProject, createDocument, linkDocument, listDocuments, showDocument, transitionDocument, type DocumentRelation } 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";
+
+const MODULE_ID = "docs";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+const eventContext = (input: OperationInput) => ({
+	actor: optionalString(input, "actor"),
+	source: optionalString(input, "source"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+});
+
+const artifactFilter = (input: OperationInput) => ({
+	status: optionalString(input, "status"),
+	text: optionalString(input, "text"),
+	limit: optionalNumber(input, "limit"),
+	projectRoot: optionalString(input, "project_root"),
+});
+
+/** Registers every docs.* operation against the shared ArtifactStore port. 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. */
+export const DOCS_OPERATION_NAMES = [
+	"docs.create", "docs.list", "docs.show", "docs.activate", "docs.archive", "docs.reopen", "docs.link", "docs.assign_project",
+] as const;
+
+export function docsOperations(artifacts: ArtifactStore, scopes: ArtifactScopeStore, authority: AuthorityRegistry): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name, moduleId: MODULE_ID, execute,
+	});
+	return [
+		define("docs.create", (input: OperationInput) => createDocument(artifacts, scopes, {
+			title: string(input, "title"), body: optionalString(input, "body"), subtype: optionalString(input, "subtype"),
+			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
+			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
+			projectRoot: optionalString(input, "project_root"),
+		}, authority, eventContext(input))),
+		define("docs.list", (input: OperationInput) => listDocuments(artifacts, scopes, artifactFilter(input))),
+		define("docs.show", (input: OperationInput) => showDocument(artifacts, string(input, "id"))),
+		define("docs.activate", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "activate", authority, eventContext(input))),
+		define("docs.archive", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "archive", authority, eventContext(input))),
+		define("docs.reopen", (input: OperationInput) => transitionDocument(artifacts, string(input, "id"), "reopen", authority, eventContext(input))),
+		define("docs.link", (input: OperationInput) => linkDocument(artifacts, string(input, "id"), string(input, "relation") as DocumentRelation, string(input, "target_id"), authority, eventContext(input))),
+		define("docs.assign_project", (input: OperationInput) => assignDocumentProject(artifacts, scopes, string(input, "id"), optionalString(input, "project_root"))),
+	];
+}

package/src/modules/graph-projection.ts

@@ -0,0 +1,82 @@
+/**
+ * modules/graph-projection.ts — the generic graph projection protocol as a registered
+ * Papyrus-native module (step 6 of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo). See
+ * src/domain/graph-projection.ts and src/graph-projection-service.ts for the protocol
+ * itself; this file only parses/validates raw operation input into that typed shape.
+ */
+import type { AuthorityRegistry } from "../authority-registry.ts";
+import { GRAPH_PROJECTION_SCHEMA_VERSION, type GraphProjectionBatch, type ProjectedArtifact, type ProjectedEdge } from "../domain/graph-projection.ts";
+import { GraphProjection } from "../graph-projection-service.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import type { ArtifactStore } from "../ports/artifact-store.ts";
+import type { GraphProjectionStore } from "../ports/graph-projection-store.ts";
+
+const MODULE_ID = "graph_projection";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function number(input: OperationInput, key: string): number {
+	const value = input[key];
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} is required and must be a number`);
+	return value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseArtifact(raw: unknown, index: number): ProjectedArtifact {
+	if (!isRecord(raw)) throw new Error(`artifacts[${index}] must be an object`);
+	return {
+		externalId: string(raw, "external_id"),
+		kind: string(raw, "kind"),
+		...(typeof raw["subtype"] === "string" ? { subtype: raw["subtype"] } : {}),
+		title: string(raw, "title"),
+		...(typeof raw["body"] === "string" ? { body: raw["body"] } : {}),
+		...(Array.isArray(raw["labels"]) ? { labels: raw["labels"] as string[] } : {}),
+		...(isRecord(raw["extra"]) ? { extra: raw["extra"] } : {}),
+	};
+}
+
+function parseEdge(raw: unknown, index: number): ProjectedEdge {
+	if (!isRecord(raw)) throw new Error(`edges[${index}] must be an object`);
+	return { from: string(raw, "from"), relation: string(raw, "relation"), to: string(raw, "to") };
+}
+
+function parseBatch(input: OperationInput): GraphProjectionBatch {
+	const schemaVersion = string(input, "schema_version");
+	const rawArtifacts = input["artifacts"];
+	const rawEdges = input["edges"] ?? [];
+	if (!Array.isArray(rawArtifacts)) throw new Error("artifacts must be an array");
+	if (!Array.isArray(rawEdges)) throw new Error("edges must be an array");
+	return {
+		schemaVersion: schemaVersion as typeof GRAPH_PROJECTION_SCHEMA_VERSION,
+		producerId: string(input, "producer_id"),
+		batchId: string(input, "batch_id"),
+		sequence: number(input, "sequence"),
+		artifacts: rawArtifacts.map(parseArtifact),
+		edges: rawEdges.map(parseEdge),
+	};
+}
+
+/** Registers graph_projection.apply and graph_projection.checkpoint against one GraphProjection instance. */
+/** 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 GRAPH_PROJECTION_OPERATION_NAMES = ["graph_projection.apply", "graph_projection.checkpoint"] as const;
+
+export function graphProjectionOperations(artifacts: ArtifactStore, store: GraphProjectionStore, authority: AuthorityRegistry): OperationDefinition[] {
+	const projection = new GraphProjection(artifacts, store, authority);
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name, moduleId: MODULE_ID, execute,
+	});
+	return [
+		define("graph_projection.apply", (input: OperationInput) => projection.apply(parseBatch(input))),
+		define("graph_projection.checkpoint", (input: OperationInput) => projection.checkpoint(string(input, "producer_id"))),
+	];
+}

package/src/modules/notes.ts

@@ -0,0 +1,76 @@
+/**
+ * modules/notes.ts — Notes as the first Papyrus-native registered module
+ * (step 5 of the incremental refactor in reducing-papyrus-consumer-change-amplification-with-modules--pvdo,
+ * combined with step 1 for a real proof-of-shape rather than an empty abstraction).
+ *
+ * Notes was chosen first because it owns no bespoke schema (it reuses the generic doc
+ * table via NOTE_SUBTYPE) and has exactly six operations — the smallest real module to
+ * prove the OperationRegistry shape against before extracting Tasks or Docs.
+ *
+ * This module does not import another module's infrastructure (src/task-service.ts,
+ * src/domain-services.ts, etc.) — only its own src/note-service.ts and the shared
+ * OperationInput parsing helpers, matching the "module code does not import another
+ * module's infrastructure" constraint.
+ */
+import type { OperationDefinition } from "../module-registry.ts";
+import { Notes, type NoteDisposition } from "../note-service.ts";
+
+const MODULE_ID = "notes";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+/** 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.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,
+	});
+	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.show", (input: OperationInput) => notes.show(string(input, "id"), string(input, "project_root"))),
+		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/rules.ts

@@ -0,0 +1,81 @@
+/**
+ * modules/rules.ts — Rules as a Papyrus-native registered module
+ * (step 5, continued, of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo).
+ *
+ * rules.injectable is intentionally NOT registered here even though its operation name
+ * starts with "rules.": its implementation requires tasks.active() (the current Task
+ * Focus) to decide which scoped rules apply, a genuine cross-module concern. It stays a
+ * composition-root operation in src/service.ts rather than importing Tasks internals
+ * into this module or introducing a premature "modules call each other through the
+ * registry" convention.
+ */
+import { assignRuleProject, createRule, gateTaskWithRule, listRules, previewRule, showRule, transitionRule } 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";
+
+const MODULE_ID = "rules";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+const eventContext = (input: OperationInput) => ({
+	actor: optionalString(input, "actor"),
+	source: optionalString(input, "source"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+});
+
+const artifactFilter = (input: OperationInput) => ({
+	status: optionalString(input, "status"),
+	text: optionalString(input, "text"),
+	limit: optionalNumber(input, "limit"),
+	projectRoot: optionalString(input, "project_root"),
+});
+
+/** 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",
+] 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,
+	});
+	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.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"))),
+	];
+}

package/src/modules/skills.ts

@@ -0,0 +1,113 @@
+/**
+ * modules/skills.ts — Skills as a Papyrus-native registered module
+ * (step 5, continued, of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo).
+ *
+ * skills.instantiate is intentionally NOT registered here even though its operation name
+ * starts with "skills.": when the target template's targetKind is "task" it calls
+ * tasks.create() directly instead of the generic instantiateTemplate path — a genuine
+ * cross-module concern, same category as rules.injectable (see modules/rules.ts). It
+ * stays a composition-root operation in src/service.ts.
+ *
+ * skills.run depends on the Task-domain ports (TaskEventStore, TaskScopeStore) as
+ * constructor parameters. These are shared port contracts every module may depend on,
+ * the same way every module already depends on ArtifactStore — not "another module's
+ * infrastructure" in the sense of a concrete class. skill-execution.ts already has this
+ * port dependency pre-existing; untangling it is a separate, larger concern than this
+ * extraction.
+ */
+import type { AuthorityRegistry } from "../authority-registry.ts";
+import { assignSkillProject, createArtifactTemplate, createSkill, listSkills, showSkill, skillInvocation, transitionSkill } 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";
+import type { TaskEventStore } from "../ports/task-event-store.ts";
+import type { TaskScopeStore } from "../ports/task-scope-store.ts";
+import { instantiateSkillWorkflow } from "../skill-execution.ts";
+
+const MODULE_ID = "skills";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+const eventContext = (input: OperationInput) => ({
+	actor: optionalString(input, "actor"),
+	source: optionalString(input, "source"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+});
+
+const eventContextFor = (input: OperationInput, source: string) => {
+	const context = eventContext(input);
+	return { ...context, source: context.source ?? source };
+};
+
+const artifactFilter = (input: OperationInput) => ({
+	status: optionalString(input, "status"),
+	text: optionalString(input, "text"),
+	limit: optionalNumber(input, "limit"),
+	projectRoot: optionalString(input, "project_root"),
+});
+
+export interface SkillsModuleDeps {
+	artifacts: ArtifactStore;
+	events: TaskEventStore;
+	scopes: TaskScopeStore;
+	/** Docs/Rules/Skills project scoping (distinct from `scopes`, which is Task-run project scoping for skills.run's materialized blueprint tasks). */
+	artifactScopes: ArtifactScopeStore;
+	authority: AuthorityRegistry;
+}
+
+/** Registers every skills.* operation except skills.instantiate (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. skills.instantiate is deliberately absent -- see the module comment above. */
+export const SKILLS_OPERATION_NAMES = [
+	"skills.create", "skills.create_template", "skills.list", "skills.show", "skills.invoke", "skills.run", "skills.enable", "skills.disable", "skills.assign_project",
+] as const;
+
+export function skillsOperations({ artifacts, events, scopes, artifactScopes, authority }: SkillsModuleDeps): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name, moduleId: MODULE_ID, execute,
+	});
+	return [
+		define("skills.create", (input: OperationInput) => createSkill(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,
+			definition: input["definition"],
+			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
+			projectRoot: optionalString(input, "project_root"),
+		}, authority, eventContext(input))),
+		define("skills.create_template", (input: OperationInput) => createArtifactTemplate(artifacts, artifactScopes, {
+			title: string(input, "title"), targetKind: string(input, "target_kind"), defaults: input["defaults"] as Record<string, unknown> | undefined,
+			required: input["required"] as string[] | undefined, body: optionalString(input, "body"), labels: input["labels"] as string[] | undefined,
+			projectRoot: optionalString(input, "project_root"),
+		}, authority, eventContext(input))),
+		define("skills.list", (input: OperationInput) => listSkills(artifacts, artifactScopes, artifactFilter(input))),
+		define("skills.show", (input: OperationInput) => showSkill(artifacts, string(input, "id"))),
+		define("skills.invoke", (input: OperationInput) => skillInvocation(artifacts, string(input, "id"))),
+		define("skills.run", (input: OperationInput) => instantiateSkillWorkflow(artifacts, string(input, "id"), {
+			runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
+			arguments: input["arguments"] as Record<string, unknown> | undefined,
+		}, { events, scopes, projectRoot: string(input, "project_root"), context: eventContextFor(input, "skill-run") })),
+		define("skills.enable", (input: OperationInput) => transitionSkill(artifacts, string(input, "id"), "enable", eventContext(input))),
+		define("skills.disable", (input: OperationInput) => transitionSkill(artifacts, string(input, "id"), "disable", eventContext(input))),
+		define("skills.assign_project", (input: OperationInput) => assignSkillProject(artifacts, artifactScopes, string(input, "id"), optionalString(input, "project_root"))),
+	];
+}

package/src/modules/tasks.ts

@@ -0,0 +1,164 @@
+/**
+ * modules/tasks.ts — Tasks as the second Papyrus-native registered module
+ * (step 5, continued, of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo).
+ *
+ * Deliberately more representative than modules/notes.ts: Tasks owns real schema
+ * (task_events, task_focus, task_scopes and their migrations, still in src/db.ts for
+ * this slice — module-owned migrations are a separate follow-up,
+ * add-a-module-migration-ledger-keyed-by-moduleid-version-with-3e7k), a much larger
+ * operation surface, and cross-module edges (rules.gate links a rule to a task;
+ * graph.link routes depends_on through Tasks.depend for cycle safety — those two
+ * remain in src/service.ts since they are graph.* / rules.* operations, not tasks.*).
+ *
+ * Task-domain-internal files (task-context.ts, task-execution.ts, domain/task-event.ts,
+ * domain/task-scope.ts) are imported directly — they belong to this bounded context,
+ * unlike a different module's infrastructure. Generic input-parsing helpers are
+ * duplicated locally rather than imported from src/service.ts, matching the precedent
+ * set by modules/notes.ts: a module does not import another module's infrastructure,
+ * including the composition root's own helpers.
+ */
+import type { Checklist } from "../domain/checklist.ts";
+import type { TaskEventContext, TaskEventDirection } from "../domain/task-event.ts";
+import type { TaskViewMode } from "../domain/task-scope.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import type { ArtifactStore } from "../ports/artifact-store.ts";
+import { taskContext } from "../task-context.ts";
+import { projectTaskExecution } from "../task-execution.ts";
+import { Tasks, type TaskStatus } from "../task-service.ts";
+
+const MODULE_ID = "tasks";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalStringArray(input: OperationInput, key: string): string[] | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) throw new Error(`${key} must be an array of strings`);
+	return value as string[];
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+const eventContext = (input: OperationInput): TaskEventContext => ({
+	actor: optionalString(input, "actor"),
+	source: optionalString(input, "source"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+	reason: optionalString(input, "reason"),
+});
+
+const taskFilter = (input: OperationInput) => ({
+	status: optionalString(input, "status"),
+	text: optionalString(input, "text"),
+	limit: optionalNumber(input, "limit"),
+	projectRoot: string(input, "project_root"),
+	scope: optionalString(input, "scope") as TaskViewMode | undefined,
+	rootTaskId: optionalString(input, "root_task_id"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+});
+
+/**
+ * Registers every tasks.* operation against one Tasks instance. Behavior is unchanged from
+ * the prior inline handlers in src/service.ts. tasks.context needs the raw ArtifactStore
+ * port directly (taskContext is a plain-artifact query, not a Tasks method), so the
+ * composition root passes the same artifacts port it already constructs Tasks with —
+ * this is not "another module's infrastructure", it is the shared port every module writes
+ * through.
+ */
+/** 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 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.context", "tasks.reject", "tasks.retry", "tasks.cancel",
+	"tasks.depend", "tasks.undepend", "tasks.contain", "tasks.uncontain",
+] as const;
+
+export function tasksOperations(tasks: Tasks, artifacts: ArtifactStore): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name, moduleId: MODULE_ID, execute,
+	});
+	return [
+		define("tasks.create", (input: OperationInput) => tasks.create({
+			title: string(input, "title"),
+			body: optionalString(input, "body"),
+			status: optionalString(input, "status") as TaskStatus | undefined,
+			labels: input["labels"] as string[] | undefined,
+			extra: input["extra"] as Record<string, unknown> | undefined,
+			gates: input["gates"] as Parameters<Tasks["create"]>[0]["gates"],
+			checklist: input["checklist"] as Checklist | undefined,
+			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
+			parentId: optionalString(input, "parent_id") ?? optionalString(input, "parentId"),
+			dependsOn: (input["depends_on"] ?? input["dependsOn"]) as string[] | undefined,
+			projectRoot: string(input, "project_root"),
+			projectSource: "cwd",
+		}, eventContext(input))),
+		define("tasks.update", (input: OperationInput) => tasks.update(string(input, "id"), {
+			...(input["title"] !== undefined ? { title: optionalString(input, "title")! } : {}),
+			...(input["body"] !== undefined ? { body: optionalString(input, "body")! } : {}),
+			...(input["labels"] !== undefined ? { labels: optionalStringArray(input, "labels")! } : {}),
+			...(input["status"] !== undefined ? { status: string(input, "status") as "todo" } : {}),
+		}, eventContext(input))),
+		define("tasks.list", (input: OperationInput) => tasks.list(taskFilter(input))),
+		define("tasks.graph", (input: OperationInput) => tasks.graph(taskFilter(input))),
+		define("tasks.plan", (input: OperationInput) => projectTaskExecution(tasks.graph(taskFilter(input)))),
+		define("tasks.show", (input: OperationInput) => tasks.show(string(input, "id"))),
+		define("tasks.history", (input: OperationInput) => tasks.history(string(input, "id"), {
+			limit: optionalNumber(input, "limit"),
+			cursor: optionalNumber(input, "cursor"),
+			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
+		})),
+		define("tasks.scope", (input: OperationInput) => tasks.scopeSelection(string(input, "project_root"))),
+		define("tasks.set_scope", (input: OperationInput) => tasks.setView(
+			string(input, "project_root"),
+			string(input, "scope") as TaskViewMode,
+			optionalString(input, "root_task_id"),
+		)),
+		define("tasks.assign_project", (input: OperationInput) => tasks.assignProject(
+			string(input, "id"),
+			string(input, "project_root"),
+			eventContext(input),
+		)),
+		define("tasks.active", (input: OperationInput) => tasks.active(taskFilter(input))),
+		define("tasks.focused", (input: OperationInput) => tasks.focused(taskFilter(input))),
+		define("tasks.focus", (input: OperationInput) => tasks.focus(string(input, "id"), eventContext(input))),
+		define("tasks.pause", (input: OperationInput) => tasks.pauseFocus(eventContext(input))),
+		define("tasks.unpause", (input: OperationInput) => tasks.unpauseFocus(eventContext(input))),
+		define("tasks.clear_focus", (input: OperationInput) => tasks.clearFocus(eventContext(input))),
+		define("tasks.start", (input: OperationInput) => tasks.transition(string(input, "id"), "start", eventContext(input))),
+		define("tasks.submit", (input: OperationInput) => tasks.transition(string(input, "id"), "submit", eventContext(input))),
+		define("tasks.complete", (input: OperationInput) => tasks.completeAsync(string(input, "id"), eventContext(input))),
+		define("tasks.run_gates", (input: OperationInput) => tasks.runGates(string(input, "id"), eventContext(input))),
+		define("tasks.set_checklist", (input: OperationInput) => tasks.setChecklist(string(input, "id"), input["checklist"] as Checklist)),
+		define("tasks.context", (input: OperationInput) => taskContext(
+			artifacts,
+			tasks.active(taskFilter(input))?.id,
+			new Set(tasks.list(taskFilter(input)).map((task) => task.id)),
+		)),
+		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.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))),
+		define("tasks.uncontain", (input: OperationInput) => tasks.uncontain(string(input, "parent_id"), string(input, "child_id"), eventContext(input))),
+	];
+}