@danypops/papyrus 0.3.0 → 0.5.0

package/src/domain-services.ts

@@ -1,4 +1,5 @@
 import type { Artifact, CreateArtifactInput } from "./domain/artifact.ts";
+import { validateSkillDefinition } from "./domain/skill-definition.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 
 export interface ListFilter {
@@ -98,6 +99,18 @@ export function listRules(artifacts: ArtifactStore, filter: ListFilter): Artifac
 	return artifacts.query({ kind: "rule", ...filter });
 }
 
+/** Global rules always apply; scoped workflow rules apply only while their run owns active focus. */
+export function listInjectableRules(artifacts: ArtifactStore, activeTaskId?: string): Artifact[] {
+	return artifacts.query({ kind: "rule", status: "active" }).filter((rule) => {
+		const scope = rule.extra["scope"];
+		if (scope === undefined) return true;
+		if (typeof scope !== "object" || scope === null || Array.isArray(scope)) return false;
+		const value = scope as Record<string, unknown>;
+		if (value["type"] !== "skill-run" || !Array.isArray(value["taskIds"])) return false;
+		return activeTaskId !== undefined && value["taskIds"].some((id) => id === activeTaskId);
+	});
+}
+
 export function showRule(artifacts: ArtifactStore, id: string): Artifact {
 	requireKind(artifacts, id, "rule");
 	return artifacts.get(id, { tree: true })!;
@@ -131,6 +144,7 @@ export interface CreateSkillInput {
 	trigger?: string;
 	steps?: string[];
 	tools?: string[];
+	definition?: unknown;
 	labels?: string[];
 	extra?: Record<string, unknown>;
 }
@@ -147,13 +161,19 @@ export interface CreateArtifactTemplateInput {
 export type SkillTransition = "enable" | "disable";
 
 export function createSkill(artifacts: ArtifactStore, input: CreateSkillInput): Artifact {
+	if (input.definition !== undefined && (input.trigger !== undefined || input.steps !== undefined || input.tools !== undefined)) {
+		throw new Error("workflow Skill definition cannot be mixed with legacy trigger, steps, or tools");
+	}
+	const definition = input.definition === undefined ? undefined : validateSkillDefinition(input.definition);
 	return artifacts.create({
 		kind: "skill",
+		subtype: definition ? "workflow" : undefined,
 		title: input.title,
 		body: input.body,
 		labels: input.labels,
 		extra: {
 			...(input.extra ?? {}),
+			...(definition ? { definition } : {}),
 			...(input.trigger ? { trigger: input.trigger } : {}),
 			...(input.steps ? { steps: input.steps } : {}),
 			...(input.tools ? { tools: input.tools } : {}),
@@ -194,6 +214,17 @@ export function skillInvocation(artifacts: ArtifactStore, id: string): string {
 	if (skill.subtype === "artifact-template") {
 		return `Create an artifact using Papyrus template "${skill.title}".\ntemplate_id: ${skill.id}\nAsk for or infer all required template fields, then call the skills domain tool instantiate action.`;
 	}
+	if (skill.subtype === "workflow") {
+		const definition = validateSkillDefinition(skill.extra["definition"]);
+		const required = Object.entries(definition.inputs)
+			.filter(([, input]) => input.required && input.default === undefined)
+			.map(([name]) => name);
+		return [
+			`Run Papyrus workflow Skill "${skill.title}" (${skill.id}).`,
+			`Required arguments: ${required.length > 0 ? required.join(", ") : "none"}.`,
+			"Call the skills domain tool with action=run and arguments after collecting required values.",
+		].join("\n");
+	}
 	const trigger = typeof skill.extra["trigger"] === "string" ? skill.extra["trigger"] : "manual invocation";
 	const steps = Array.isArray(skill.extra["steps"]) ? skill.extra["steps"].filter((step): step is string => typeof step === "string") : [];
 	const tools = Array.isArray(skill.extra["tools"]) ? skill.extra["tools"].filter((tool): tool is string => typeof tool === "string") : [];

package/src/ports/atomic-artifact-store.ts

@@ -0,0 +1,13 @@
+import type { ArtifactStore } from "./artifact-store.ts";
+
+/** Artifact store boundary for domain operations that must commit as one graph mutation. */
+export interface AtomicArtifactStore extends ArtifactStore {
+	atomic<T>(operation: () => T): T;
+}
+
+export function requireAtomicArtifactStore(store: ArtifactStore): AtomicArtifactStore {
+	if (!("atomic" in store) || typeof store.atomic !== "function") {
+		throw new Error("artifact store does not support atomic workflow runs");
+	}
+	return store as AtomicArtifactStore;
+}

package/src/ports/task-event-store.ts

@@ -0,0 +1,43 @@
+import { normalizeTaskHistoryQuery, validateTaskEvent, type AppendTaskEvent, type TaskEvent, type TaskHistoryPage, type TaskHistoryQuery } from "../domain/task-event.ts";
+
+export interface TaskEventStore {
+	atomic<T>(operation: () => T): T;
+	append(event: AppendTaskEvent): TaskEvent;
+	history(taskId: string, query?: TaskHistoryQuery): TaskHistoryPage;
+}
+
+export class InMemoryTaskEventStore implements TaskEventStore {
+	private events: TaskEvent[] = [];
+	private nextId = 1;
+
+	atomic<T>(operation: () => T): T {
+		const length = this.events.length;
+		const nextId = this.nextId;
+		try { return operation(); }
+		catch (error) {
+			this.events.length = length;
+			this.nextId = nextId;
+			throw error;
+		}
+	}
+
+	append(event: AppendTaskEvent): TaskEvent {
+		const stored: TaskEvent = {
+			...validateTaskEvent(event),
+			id: this.nextId++,
+			occurredAt: new Date().toISOString(),
+			schemaVersion: 1,
+		};
+		this.events.push(stored);
+		return stored;
+	}
+
+	history(taskId: string, query: TaskHistoryQuery = {}): TaskHistoryPage {
+		const { direction, limit, cursor } = normalizeTaskHistoryQuery(query);
+		const ordered = this.events
+			.filter((event) => event.taskId === taskId && (cursor === undefined || (direction === "desc" ? event.id < cursor : event.id > cursor)))
+			.sort((left, right) => direction === "desc" ? right.id - left.id : left.id - right.id);
+		const events = ordered.slice(0, limit);
+		return { events, ...(ordered.length > limit ? { nextCursor: events.at(-1)!.id } : {}) };
+	}
+}

package/src/service.ts

@@ -4,10 +4,13 @@ import { migrateDb, openDb, schemaVersion } from "./db.ts";
 import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
 import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
+import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
 import type { Checklist } from "./domain/checklist.ts";
+import type { TaskEventContext, TaskEventDirection } from "./domain/task-event.ts";
 import type { ArtifactStore } from "./ports/artifact-store.ts";
 import type { GateRunner } from "./ports/gate-runner.ts";
+import type { TaskEventStore } from "./ports/task-event-store.ts";
 import { projectTaskExecution } from "./task-execution.ts";
 import { Tasks, type TaskStatus } from "./task-service.ts";
 import {
@@ -20,6 +23,7 @@ import {
 	instantiateTemplate,
 	listDocuments,
 	listRules,
+	listInjectableRules,
 	listSkills,
 	previewRule,
 	showDocument,
@@ -32,6 +36,7 @@ import {
 	type DocumentRelation,
 } from "./domain-services.ts";
 import { taskContext } from "./task-context.ts";
+import { instantiateSkillWorkflow } from "./skill-execution.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
 	"system.migrate",
@@ -48,6 +53,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.graph",
 	"tasks.plan",
 	"tasks.show",
+	"tasks.history",
 	"tasks.active",
 	"tasks.focus",
 	"tasks.start",
@@ -80,6 +86,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"skills.list",
 	"skills.show",
 	"skills.invoke",
+	"skills.run",
 	"skills.enable",
 	"skills.disable",
 	"skills.instantiate",
@@ -137,8 +144,19 @@ function handlers(
 	artifacts: ArtifactStore,
 	gates: GateRunner,
 	tasks: Tasks,
+	events: TaskEventStore,
 	migrate: () => unknown,
 ): Record<OperationName, OperationHandler> {
+	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 eventContextFor = (input: OperationInput, source: string): TaskEventContext => {
+		const context = eventContext(input);
+		return { ...context, source: context.source ?? source };
+	};
 	const taskFilter = (input: OperationInput) => ({
 		status: optionalString(input, "status"),
 		text: optionalString(input, "text"),
@@ -146,7 +164,20 @@ function handlers(
 	});
 	return {
 		"system.migrate": () => migrate(),
-		"artifact.create": (input) => artifacts.create(normalizeCreateInput(input)),
+		"artifact.create": (input) => {
+			const normalized = normalizeCreateInput(input);
+			if (normalized.kind !== "task") return artifacts.create(normalized);
+			return tasks.create({
+				id: normalized.id,
+				title: string(input, "title"),
+				body: normalized.body,
+				subtype: normalized.subtype,
+				status: normalized.status as TaskStatus | undefined,
+				labels: normalized.labels,
+				extra: normalized.extra,
+				templateId: normalized.templateId,
+			}, eventContextFor(input, "artifact-api"));
+		},
 		"artifact.query": (input) => artifacts.query(input),
 		"artifact.show": (input) => artifacts.get(string(input, "id"), {
 			tree: input["tree"] === true,
@@ -169,9 +200,18 @@ function handlers(
 			depth: optionalNumber(input, "depth"),
 			maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
 		}),
-		"graph.status": (input) => artifacts.setStatus(string(input, "id"), string(input, "status")),
-		"gates.run": (input) => gates.runAsync(string(input, "id")),
-		"rules.injectable": () => artifacts.query({ kind: "rule", status: "active" })
+		"graph.status": (input) => {
+			const id = string(input, "id");
+			if (artifacts.get(id)?.kind === "task") throw new Error("task lifecycle changes require a tasks.* operation so history and review invariants are preserved");
+			return artifacts.setStatus(id, string(input, "status"));
+		},
+		"gates.run": (input) => {
+			const id = string(input, "id");
+			return artifacts.get(id)?.kind === "task"
+				? tasks.runGates(id, eventContextFor(input, "gates-api"))
+				: gates.runAsync(id);
+		},
+		"rules.injectable": () => listInjectableRules(artifacts, tasks.active()?.id)
 			.map(({ id, title, body, extra }) => ({ id, title, body, extra })),
 		"tasks.create": (input) => tasks.create({
 			title: string(input, "title"),
@@ -184,22 +224,27 @@ function handlers(
 			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,
-		}),
+		}, eventContext(input)),
 		"tasks.list": (input) => tasks.list(taskFilter(input)),
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
 		"tasks.plan": (input) => projectTaskExecution(tasks.graph(taskFilter(input))),
 		"tasks.show": (input) => tasks.show(string(input, "id")),
+		"tasks.history": (input) => tasks.history(string(input, "id"), {
+			limit: optionalNumber(input, "limit"),
+			cursor: optionalNumber(input, "cursor"),
+			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
+		}),
 		"tasks.active": () => tasks.active(),
 		"tasks.focus": (input) => tasks.focus(string(input, "id")),
-		"tasks.start": (input) => tasks.transition(string(input, "id"), "start"),
-		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit"),
-		"tasks.complete": (input) => tasks.completeAsync(string(input, "id")),
-		"tasks.run_gates": (input) => tasks.runGates(string(input, "id")),
+		"tasks.start": (input) => tasks.transition(string(input, "id"), "start", eventContext(input)),
+		"tasks.submit": (input) => tasks.transition(string(input, "id"), "submit", eventContext(input)),
+		"tasks.complete": (input) => tasks.completeAsync(string(input, "id"), eventContext(input)),
+		"tasks.run_gates": (input) => tasks.runGates(string(input, "id"), eventContext(input)),
 		"tasks.set_checklist": (input) => tasks.setChecklist(string(input, "id"), input["checklist"] as Checklist),
 		"tasks.context": () => taskContext(artifacts, tasks.active()?.id),
-		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject"),
-		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry"),
-		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel"),
+		"tasks.reject": (input) => tasks.transition(string(input, "id"), "reject", eventContext(input)),
+		"tasks.retry": (input) => tasks.transition(string(input, "id"), "retry", eventContext(input)),
+		"tasks.cancel": (input) => tasks.transition(string(input, "id"), "cancel", eventContext(input)),
 		"tasks.depend": (input) => tasks.depend(string(input, "id"), string(input, "dependency_id")),
 		"tasks.contain": (input) => tasks.contain(string(input, "parent_id"), string(input, "child_id")),
 		"docs.create": (input) => createDocument(artifacts, {
@@ -228,6 +273,7 @@ function handlers(
 		"skills.create": (input) => createSkill(artifacts, {
 			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,
 		}),
 		"skills.create_template": (input) => createArtifactTemplate(artifacts, {
@@ -237,6 +283,10 @@ function handlers(
 		"skills.list": (input) => listSkills(artifacts, taskFilter(input)),
 		"skills.show": (input) => showSkill(artifacts, string(input, "id")),
 		"skills.invoke": (input) => skillInvocation(artifacts, string(input, "id")),
+		"skills.run": (input) => instantiateSkillWorkflow(artifacts, string(input, "id"), {
+			runId: optionalString(input, "run_id") ?? optionalString(input, "runId"),
+			arguments: input["arguments"] as Record<string, unknown> | undefined,
+		}, { events, context: eventContextFor(input, "skill-run") }),
 		"skills.enable": (input) => transitionSkill(artifacts, string(input, "id"), "enable"),
 		"skills.disable": (input) => transitionSkill(artifacts, string(input, "id"), "disable"),
 		"skills.instantiate": (input) => instantiateTemplate(artifacts, string(input, "template_id"), normalizeCreateInput(input)),
@@ -248,8 +298,9 @@ export function createPapyrusService(path: string): PapyrusService {
 	const artifacts = new SQLiteArtifactStore(db);
 	const gates = new SQLiteGateRunner(db);
 	const focus = new SQLiteTaskFocusStore(db);
-	const tasks = new Tasks(artifacts, gates, focus);
-	const registry = handlers(artifacts, gates, tasks, () => migrateDb(db));
+	const events = new SQLiteTaskEventStore(db);
+	const tasks = new Tasks(artifacts, gates, focus, events);
+	const registry = handlers(artifacts, gates, tasks, events, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -261,7 +312,7 @@ export function createPapyrusService(path: string): PapyrusService {
 			const handler = registry[operation as OperationName];
 			if (!handler) throw new UnknownOperationError(`unknown operation "${operation}"`);
 			if (operation !== "system.migrate" && state().migrationRequired) {
-				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-lifecycle`");
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-history`");
 			}
 			return handler(input);
 		},

package/src/skill-execution.ts

@@ -0,0 +1,220 @@
+import { randomUUID } from "node:crypto";
+import { SKILL_MAX_RENDERED_BYTES, SKILL_RUN_ID_MAX_LENGTH, TASK_EXECUTION_MAX_EDGES } from "./constants.ts";
+import type { Artifact } from "./domain/artifact.ts";
+import { validateChecklist } from "./domain/checklist.ts";
+import {
+	resolveSkillArguments,
+	validateSkillDefinition,
+	type SkillArgumentValue,
+	type SkillDefinition,
+} from "./domain/skill-definition.ts";
+import type { ArtifactStore } from "./ports/artifact-store.ts";
+import type { TaskEventContext } from "./domain/task-event.ts";
+import type { TaskEventStore } from "./ports/task-event-store.ts";
+import { requireAtomicArtifactStore } from "./ports/atomic-artifact-store.ts";
+import { projectTaskExecution, type TaskExecutionPlan } from "./task-execution.ts";
+import type { TaskGraph, TaskNode, TaskStatus } from "./task-service.ts";
+
+const RUN_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const EXACT_PLACEHOLDER_PATTERN = /^{{\s*([A-Za-z][A-Za-z0-9_-]{0,63})\s*}}$/;
+const PLACEHOLDER_PATTERN = /{{\s*([A-Za-z][A-Za-z0-9_-]{0,63})\s*}}/g;
+const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+export interface InstantiateSkillWorkflowInput {
+	runId?: string;
+	arguments?: Record<string, unknown>;
+}
+
+export interface SkillWorkflowRunResult {
+	skillId: string;
+	runId: string;
+	arguments: Record<string, SkillArgumentValue>;
+	created: {
+		docs: string[];
+		rules: string[];
+		tasks: string[];
+	};
+	rootTaskIds: string[];
+	execution: TaskExecutionPlan;
+}
+
+function requireWorkflowSkill(artifacts: ArtifactStore, skillId: string): { skill: Artifact; definition: SkillDefinition } {
+	const skill = artifacts.get(skillId);
+	if (!skill) throw new Error(`skill artifact "${skillId}" not found`);
+	if (skill.kind !== "skill" || skill.subtype !== "workflow") {
+		throw new Error(`artifact "${skillId}" is not a workflow Skill`);
+	}
+	if (skill.status !== "active") throw new Error(`cannot run workflow Skill from ${skill.status}`);
+	return { skill, definition: validateSkillDefinition(skill.extra["definition"]) };
+}
+
+function normalizeRunId(skillId: string, requested: string | undefined): string {
+	const runId = requested ?? `${skillId.slice(0, 40)}-${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+	if (runId.length > SKILL_RUN_ID_MAX_LENGTH || !RUN_ID_PATTERN.test(runId)) {
+		throw new Error(`skill run id must match ${RUN_ID_PATTERN} and contain at most ${SKILL_RUN_ID_MAX_LENGTH} characters`);
+	}
+	return runId;
+}
+
+function renderValue(value: unknown, arguments_: Record<string, SkillArgumentValue>): unknown {
+	if (typeof value === "string") {
+		const exact = value.match(EXACT_PLACEHOLDER_PATTERN);
+		if (exact) {
+			const name = exact[1]!;
+			if (!(name in arguments_)) throw new Error(`skill input placeholder "${name}" has no argument value`);
+			return arguments_[name]!;
+		}
+		return value.replace(PLACEHOLDER_PATTERN, (_placeholder, name: string) => {
+			if (!(name in arguments_)) throw new Error(`skill input placeholder "${name}" has no argument value`);
+			return String(arguments_[name]!);
+		});
+	}
+	if (Array.isArray(value)) return value.map((entry) => renderValue(entry, arguments_));
+	if (typeof value !== "object" || value === null) return value;
+	const rendered: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (UNSAFE_KEYS.has(key)) throw new Error(`unsafe skill blueprint key "${key}"`);
+		rendered[key] = renderValue(entry, arguments_);
+	}
+	return rendered;
+}
+
+function renderDefinition(definition: SkillDefinition, arguments_: Record<string, SkillArgumentValue>): SkillDefinition {
+	const rendered = renderValue(definition, arguments_) as SkillDefinition;
+	const bytes = new TextEncoder().encode(JSON.stringify(rendered)).byteLength;
+	if (bytes > SKILL_MAX_RENDERED_BYTES) throw new Error(`rendered skill workflow exceeds ${SKILL_MAX_RENDERED_BYTES} bytes`);
+	for (const task of rendered.blueprints.tasks) {
+		if (task.extra?.["checklist"] !== undefined) {
+			task.extra["checklist"] = validateChecklist(task.extra["checklist"]);
+		}
+	}
+	return validateSkillDefinition(rendered);
+}
+
+function withRunLabel(labels: string[] | undefined, runId: string): string[] {
+	return [...new Set([...(labels ?? []), `skill-run:${runId}`])];
+}
+
+function executionGraph(tasks: Artifact[], definition: SkillDefinition, ids: Map<string, string>): TaskGraph {
+	const byRef = new Map(definition.blueprints.tasks.map((task) => [task.ref, task]));
+	const nodes: TaskNode[] = tasks.map((task) => {
+		const ref = task.extra["skillRun"] && typeof task.extra["skillRun"] === "object"
+			? (task.extra["skillRun"] as Record<string, unknown>)["ref"] as string
+			: "";
+		const blueprint = byRef.get(ref)!;
+		return {
+			task,
+			active: false,
+			parentIds: blueprint.parent ? [ids.get(blueprint.parent)!] : [],
+			childIds: definition.blueprints.tasks.filter((candidate) => candidate.parent === ref).map((candidate) => ids.get(candidate.ref)!),
+			dependencyIds: (blueprint.dependsOn ?? []).map((dependency) => ids.get(dependency)!),
+		};
+	});
+	return { nodes, rootIds: nodes.filter((node) => node.parentIds.length === 0).map((node) => node.task.id) };
+}
+
+export function instantiateSkillWorkflow(
+	artifacts: ArtifactStore,
+	skillId: string,
+	input: InstantiateSkillWorkflowInput = {},
+	history?: { events: TaskEventStore; context?: TaskEventContext },
+): SkillWorkflowRunResult {
+	const { definition } = requireWorkflowSkill(artifacts, skillId);
+	const arguments_ = resolveSkillArguments(definition, input.arguments);
+	const rendered = renderDefinition(definition, arguments_);
+	const runId = normalizeRunId(skillId, input.runId);
+	const refs = [
+		...rendered.blueprints.docs.map(({ ref }) => ref),
+		...rendered.blueprints.rules.map(({ ref }) => ref),
+		...rendered.blueprints.tasks.map(({ ref }) => ref),
+	];
+	const ids = new Map(refs.map((ref) => [ref, `${runId}-${ref}`]));
+	const taskIds = rendered.blueprints.tasks.map(({ ref }) => ids.get(ref)!);
+	const rootTaskIds = rendered.blueprints.tasks
+		.filter((task) => (task.dependsOn?.length ?? 0) === 0)
+		.map((task) => ids.get(task.ref)!);
+	const relationshipCount = rendered.links.length
+		+ rendered.blueprints.tasks.reduce((count, task) => count + (task.dependsOn?.length ?? 0) + (task.parent ? 2 : 0), 0)
+		+ rootTaskIds.length;
+	if (relationshipCount > TASK_EXECUTION_MAX_EDGES) {
+		throw new Error(`skill workflow run exceeds ${TASK_EXECUTION_MAX_EDGES} relationships`);
+	}
+
+	const atomic = requireAtomicArtifactStore(artifacts);
+	const persist = () => atomic.atomic(() => {
+		const docs = rendered.blueprints.docs.map((blueprint) => artifacts.create({
+			id: ids.get(blueprint.ref),
+			kind: "doc",
+			title: blueprint.title,
+			body: blueprint.body,
+			subtype: blueprint.subtype,
+			labels: withRunLabel(blueprint.labels, runId),
+			extra: { ...(blueprint.extra ?? {}), skillRun: { id: runId, skillId, ref: blueprint.ref } },
+		}));
+		const rules = rendered.blueprints.rules.map((blueprint) => artifacts.create({
+			id: ids.get(blueprint.ref),
+			kind: "rule",
+			title: blueprint.title,
+			body: blueprint.body,
+			labels: withRunLabel(blueprint.labels, runId),
+			extra: {
+				...(blueprint.extra ?? {}),
+				...(blueprint.condition ? { condition: blueprint.condition } : {}),
+				...(blueprint.action ? { action: blueprint.action } : {}),
+				...(blueprint.severity ? { severity: blueprint.severity } : {}),
+				skillRun: { id: runId, skillId, ref: blueprint.ref },
+				scope: { type: "skill-run", runId, taskIds },
+			},
+		}));
+		const tasks = rendered.blueprints.tasks.map((blueprint) => {
+			const task = artifacts.create({
+				id: ids.get(blueprint.ref),
+				kind: "task",
+				title: blueprint.title,
+				body: blueprint.body,
+				labels: withRunLabel(blueprint.labels, runId),
+				extra: { ...(blueprint.extra ?? {}), skillRun: { id: runId, skillId, ref: blueprint.ref } },
+			});
+			if (history) history.events.append({
+				taskId: task.id,
+				type: "created",
+				actor: history.context?.actor ?? "system",
+				source: history.context?.source ?? "skill-run",
+				toStatus: task.status as TaskStatus,
+				...(history.context?.sessionId === undefined ? {} : { sessionId: history.context.sessionId }),
+				...(history.context?.reason === undefined ? {} : { reason: history.context.reason }),
+			});
+			return task;
+		});
+
+		for (const blueprint of rendered.blueprints.tasks) {
+			const id = ids.get(blueprint.ref)!;
+			for (const dependency of blueprint.dependsOn ?? []) {
+				artifacts.link({ from: id, relation: "depends_on", to: ids.get(dependency)! });
+			}
+			if (blueprint.parent) {
+				const parentId = ids.get(blueprint.parent)!;
+				artifacts.link({ from: parentId, relation: "contains", to: id });
+				artifacts.link({ from: id, relation: "part_of", to: parentId });
+			}
+		}
+		for (const link of rendered.links) {
+			artifacts.link({ from: ids.get(link.from)!, relation: link.relation, to: ids.get(link.to)! });
+		}
+		for (const rootTaskId of rootTaskIds) artifacts.link({ from: skillId, relation: "triggers", to: rootTaskId });
+
+		return {
+			skillId,
+			runId,
+			arguments: arguments_,
+			created: {
+				docs: docs.map(({ id }) => id),
+				rules: rules.map(({ id }) => id),
+				tasks: tasks.map(({ id }) => id),
+			},
+			rootTaskIds,
+			execution: projectTaskExecution(executionGraph(tasks, rendered, ids)),
+		};
+	});
+	return history ? history.events.atomic(persist) : persist();
+}