@danypops/papyrus 0.5.0 → 0.7.0

package/src/service.ts

@@ -5,14 +5,18 @@ 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 { SQLiteTaskScopeStore } from "./adapters/sqlite-task-scope-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 { TaskViewMode } from "./domain/task-scope.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 type { TaskScopeStore } from "./ports/task-scope-store.ts";
 import { projectTaskExecution } from "./task-execution.ts";
 import { Tasks, type TaskStatus } from "./task-service.ts";
+import { TaskAutomationReconciler, taskAutomationSettings, type TaskAutomationSettings } from "./task-automation.ts";
 import {
 	createArtifactTemplate,
 	createDocument,
@@ -40,6 +44,8 @@ import { instantiateSkillWorkflow } from "./skill-execution.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
 	"system.migrate",
+	"automation.status",
+	"automation.reconcile",
 	"artifact.create",
 	"artifact.query",
 	"artifact.show",
@@ -54,6 +60,9 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.plan",
 	"tasks.show",
 	"tasks.history",
+	"tasks.scope",
+	"tasks.set_scope",
+	"tasks.assign_project",
 	"tasks.active",
 	"tasks.focus",
 	"tasks.start",
@@ -61,6 +70,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	"tasks.complete",
 	"tasks.run_gates",
 	"tasks.set_checklist",
+	"tasks.set_automation",
 	"tasks.context",
 	"tasks.reject",
 	"tasks.retry",
@@ -144,7 +154,9 @@ function handlers(
 	artifacts: ArtifactStore,
 	gates: GateRunner,
 	tasks: Tasks,
+	automation: TaskAutomationReconciler,
 	events: TaskEventStore,
+	scopes: TaskScopeStore,
 	migrate: () => unknown,
 ): Record<OperationName, OperationHandler> {
 	const eventContext = (input: OperationInput): TaskEventContext => ({
@@ -161,9 +173,14 @@ function handlers(
 		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"),
 	});
 	return {
 		"system.migrate": () => migrate(),
+		"automation.status": () => automation.status(),
+		"automation.reconcile": () => automation.reconcile(),
 		"artifact.create": (input) => {
 			const normalized = normalizeCreateInput(input);
 			if (normalized.kind !== "task") return artifacts.create(normalized);
@@ -176,6 +193,8 @@ function handlers(
 				labels: normalized.labels,
 				extra: normalized.extra,
 				templateId: normalized.templateId,
+				projectRoot: string(input, "project_root"),
+				projectSource: "cwd",
 			}, eventContextFor(input, "artifact-api"));
 		},
 		"artifact.query": (input) => artifacts.query(input),
@@ -211,7 +230,7 @@ function handlers(
 				? tasks.runGates(id, eventContextFor(input, "gates-api"))
 				: gates.runAsync(id);
 		},
-		"rules.injectable": () => listInjectableRules(artifacts, tasks.active()?.id)
+		"rules.injectable": (input) => listInjectableRules(artifacts, tasks.active(taskFilter(input))?.id)
 			.map(({ id, title, body, extra }) => ({ id, title, body, extra })),
 		"tasks.create": (input) => tasks.create({
 			title: string(input, "title"),
@@ -224,6 +243,8 @@ 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,
+			projectRoot: string(input, "project_root"),
+			projectSource: "cwd",
 		}, eventContext(input)),
 		"tasks.list": (input) => tasks.list(taskFilter(input)),
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
@@ -234,14 +255,29 @@ function handlers(
 			cursor: optionalNumber(input, "cursor"),
 			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
 		}),
-		"tasks.active": () => tasks.active(),
+		"tasks.scope": (input) => tasks.scopeSelection(string(input, "project_root")),
+		"tasks.set_scope": (input) => tasks.setView(
+			string(input, "project_root"),
+			string(input, "scope") as TaskViewMode,
+			optionalString(input, "root_task_id"),
+		),
+		"tasks.assign_project": (input) => tasks.assignProject(
+			string(input, "id"),
+			string(input, "project_root"),
+			eventContext(input),
+		),
+		"tasks.active": (input) => tasks.active(taskFilter(input)),
 		"tasks.focus": (input) => tasks.focus(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.set_automation": (input) => {
+			if (typeof input["enabled"] !== "boolean") throw new Error("enabled must be a boolean");
+			return tasks.setAutomation(string(input, "id"), input["enabled"], eventContext(input));
+		},
+		"tasks.context": (input) => taskContext(artifacts, tasks.active()?.id, new Set(tasks.list(taskFilter(input)).map((task) => task.id))),
 		"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)),
@@ -286,21 +322,37 @@ function handlers(
 		"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") }),
+		}, { events, scopes, projectRoot: string(input, "project_root"), 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)),
+		"skills.instantiate": (input) => {
+			const templateId = string(input, "template_id");
+			const template = artifacts.get(templateId);
+			if (template?.extra["targetKind"] !== "task") return instantiateTemplate(artifacts, templateId, normalizeCreateInput(input));
+			return tasks.create({
+				title: optionalString(input, "title") as string,
+				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,
+				templateId,
+				projectRoot: string(input, "project_root"),
+				projectSource: "cwd",
+			}, eventContextFor(input, "template-instantiation"));
+		},
 	};
 }
 
-export function createPapyrusService(path: string): PapyrusService {
+export function createPapyrusService(path: string, options: { automation?: TaskAutomationSettings } = {}): PapyrusService {
 	const db = openDb(path);
 	const artifacts = new SQLiteArtifactStore(db);
 	const gates = new SQLiteGateRunner(db);
 	const focus = new SQLiteTaskFocusStore(db);
 	const events = new SQLiteTaskEventStore(db);
-	const tasks = new Tasks(artifacts, gates, focus, events);
-	const registry = handlers(artifacts, gates, tasks, events, () => migrateDb(db));
+	const scopes = new SQLiteTaskScopeStore(db);
+	const tasks = new Tasks(artifacts, gates, focus, events, scopes);
+	const automation = new TaskAutomationReconciler(tasks, options.automation ?? taskAutomationSettings({}));
+	const registry = handlers(artifacts, gates, tasks, automation, events, scopes, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -311,8 +363,8 @@ export function createPapyrusService(path: string): PapyrusService {
 		async execute(operation, input = {}) {
 			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-history`");
+			if (operation !== "system.migrate" && operation !== "automation.status" && state().migrationRequired) {
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-scope`");
 			}
 			return handler(input);
 		},

package/src/skill-execution.ts

@@ -11,6 +11,8 @@ import {
 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 type { TaskScopeStore } from "./ports/task-scope-store.ts";
+import { normalizeProjectRoot } from "./domain/task-scope.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";
@@ -117,9 +119,10 @@ export function instantiateSkillWorkflow(
 	artifacts: ArtifactStore,
 	skillId: string,
 	input: InstantiateSkillWorkflowInput = {},
-	history?: { events: TaskEventStore; context?: TaskEventContext },
+	history?: { events: TaskEventStore; scopes: TaskScopeStore; projectRoot: string; context?: TaskEventContext },
 ): SkillWorkflowRunResult {
 	const { definition } = requireWorkflowSkill(artifacts, skillId);
+	const projectRoot = history ? normalizeProjectRoot(history.projectRoot) : undefined;
 	const arguments_ = resolveSkillArguments(definition, input.arguments);
 	const rendered = renderDefinition(definition, arguments_);
 	const runId = normalizeRunId(skillId, input.runId);
@@ -175,15 +178,18 @@ export function instantiateSkillWorkflow(
 				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 }),
-			});
+			if (history) {
+				history.scopes.assign(task.id, projectRoot, "cwd");
+				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;
 		});
 

package/src/task-automation.ts

@@ -0,0 +1,188 @@
+import {
+	TASK_AUTOMATION_ERROR_ID_MAX_LENGTH,
+	TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH,
+	TASK_AUTOMATION_GATE_CONCURRENCY,
+	TASK_AUTOMATION_HARD_MAX_RUNTIME_MS,
+	TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP,
+	TASK_AUTOMATION_INTERVAL_MS,
+	TASK_AUTOMATION_MAX_CANDIDATE_SCAN,
+	TASK_AUTOMATION_MAX_GATE_CONCURRENCY,
+	TASK_AUTOMATION_MAX_INTERVAL_MS,
+	TASK_AUTOMATION_MAX_RUNTIME_MS,
+	TASK_AUTOMATION_MAX_TASKS_PER_SWEEP,
+	TASK_AUTOMATION_MIN_INTERVAL_MS,
+} from "./constants.ts";
+import type { Artifact } from "./domain/artifact.ts";
+import { projectTaskExecution } from "./task-execution.ts";
+import type { Tasks } from "./task-service.ts";
+
+export interface TaskAutomationSettings {
+	enabled: boolean;
+	intervalMs: number;
+	maxTasksPerSweep: number;
+	gateConcurrency: number;
+	maxRuntimeMs: number;
+}
+
+export interface TaskAutomationResult {
+	skipped?: "disabled" | "in-flight";
+	examined: number;
+	completed: number;
+	rejected: number;
+	started: number;
+	errors: Array<{ taskId: string; message: string }>;
+	timedOut: boolean;
+}
+
+function boundedInteger(
+	env: Record<string, string | undefined>,
+	name: string,
+	fallback: number,
+	minimum: number,
+	maximum: number,
+): number {
+	const source = env[name];
+	if (source === undefined || source === "") return fallback;
+	const value = Number(source);
+	if (!Number.isInteger(value) || value < minimum || value > maximum) {
+		throw new Error(`${name} must be an integer between ${minimum} and ${maximum}`);
+	}
+	return value;
+}
+
+export function taskAutomationSettings(env: Record<string, string | undefined> = process.env): TaskAutomationSettings {
+	const enabled = env["PAPYRUS_AUTOMATION_ENABLED"] === "1";
+	if (env["PAPYRUS_AUTOMATION_ENABLED"] !== undefined && env["PAPYRUS_AUTOMATION_ENABLED"] !== "0" && !enabled) {
+		throw new Error("PAPYRUS_AUTOMATION_ENABLED must be 0 or 1");
+	}
+	return {
+		enabled,
+		intervalMs: boundedInteger(env, "PAPYRUS_AUTOMATION_INTERVAL_MS", TASK_AUTOMATION_INTERVAL_MS, TASK_AUTOMATION_MIN_INTERVAL_MS, TASK_AUTOMATION_MAX_INTERVAL_MS),
+		maxTasksPerSweep: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_TASKS", TASK_AUTOMATION_MAX_TASKS_PER_SWEEP, 1, TASK_AUTOMATION_HARD_MAX_TASKS_PER_SWEEP),
+		gateConcurrency: boundedInteger(env, "PAPYRUS_AUTOMATION_GATE_CONCURRENCY", TASK_AUTOMATION_GATE_CONCURRENCY, 1, TASK_AUTOMATION_MAX_GATE_CONCURRENCY),
+		maxRuntimeMs: boundedInteger(env, "PAPYRUS_AUTOMATION_MAX_RUNTIME_MS", TASK_AUTOMATION_MAX_RUNTIME_MS, 1, TASK_AUTOMATION_HARD_MAX_RUNTIME_MS),
+	};
+}
+
+function automationEnabled(task: Artifact): boolean {
+	const automation = task.extra["automation"];
+	return typeof automation === "object"
+		&& automation !== null
+		&& !Array.isArray(automation)
+		&& (automation as Record<string, unknown>)["enabled"] === true;
+}
+
+function emptyResult(skipped?: TaskAutomationResult["skipped"]): TaskAutomationResult {
+	return { ...(skipped ? { skipped } : {}), examined: 0, completed: 0, rejected: 0, started: 0, errors: [], timedOut: false };
+}
+
+function boundedError(taskId: string, error: unknown): TaskAutomationResult["errors"][number] {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		taskId: taskId.slice(0, TASK_AUTOMATION_ERROR_ID_MAX_LENGTH),
+		message: message.slice(0, TASK_AUTOMATION_ERROR_MESSAGE_MAX_LENGTH),
+	};
+}
+
+export interface TaskAutomationScheduler {
+	setInterval(callback: () => void, intervalMs: number): unknown;
+	clearInterval(handle: unknown): void;
+}
+
+const SYSTEM_SCHEDULER: TaskAutomationScheduler = {
+	setInterval: (callback, intervalMs) => setInterval(callback, intervalMs),
+	clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
+};
+
+export function scheduleTaskAutomation(
+	settings: TaskAutomationSettings,
+	sweep: () => Promise<unknown>,
+	onError: (error: unknown) => void,
+	scheduler: TaskAutomationScheduler = SYSTEM_SCHEDULER,
+): () => void {
+	if (!settings.enabled) return () => {};
+	const handle = scheduler.setInterval(() => { void sweep().catch(onError); }, settings.intervalMs);
+	return () => scheduler.clearInterval(handle);
+}
+
+export class TaskAutomationReconciler {
+	private inFlight = false;
+
+	constructor(
+		private readonly tasks: Tasks,
+		private readonly settings: TaskAutomationSettings,
+		private readonly now: () => number = () => Date.now(),
+	) {}
+
+	status(): TaskAutomationSettings & { inFlight: boolean } {
+		return { ...this.settings, inFlight: this.inFlight };
+	}
+
+	async reconcile(): Promise<TaskAutomationResult> {
+		if (!this.settings.enabled) return emptyResult("disabled");
+		if (this.inFlight) return emptyResult("in-flight");
+		this.inFlight = true;
+		try { return await this.runSweep(); }
+		finally { this.inFlight = false; }
+	}
+
+	private async runSweep(): Promise<TaskAutomationResult> {
+		const result = emptyResult();
+		const deadline = this.now() + this.settings.maxRuntimeMs;
+		const candidates = this.tasks.list({ status: "review", limit: TASK_AUTOMATION_MAX_CANDIDATE_SCAN })
+			.filter(automationEnabled)
+			.sort((left, right) => left.id.localeCompare(right.id))
+			.slice(0, this.settings.maxTasksPerSweep);
+		const completedIds = new Set<string>();
+
+		for (let offset = 0; offset < candidates.length; offset += this.settings.gateConcurrency) {
+			if (this.now() >= deadline) { result.timedOut = true; break; }
+			const batch = candidates.slice(offset, offset + this.settings.gateConcurrency);
+			await Promise.all(batch.map(async (task) => {
+				result.examined += 1;
+				try {
+					const completion = await this.tasks.completeAsync(task.id, {
+						actor: "daemon",
+						source: "automation-reconciler",
+						reason: "automation-enabled review reconciliation",
+					}, { focusSuccessor: false, gateDeadlineMs: deadline });
+					if (completion.completed) {
+						result.completed += 1;
+						completedIds.add(task.id);
+					} else result.rejected += 1;
+				} catch (error) {
+					result.errors.push(boundedError(task.id, error));
+				}
+			}));
+		}
+
+		let remaining = Math.max(0, this.settings.maxTasksPerSweep - result.examined);
+		if (remaining > 0 && completedIds.size > 0 && this.now() < deadline) {
+			let graph: ReturnType<Tasks["graph"]>;
+			try { graph = this.tasks.graph(); }
+			catch (error) {
+				result.errors.push(boundedError("graph", error));
+				return result;
+			}
+			const stateById = new Map(projectTaskExecution(graph).nodes.map((node) => [node.id, node.state]));
+			for (const node of [...graph.nodes].sort((left, right) => left.task.id.localeCompare(right.task.id))) {
+				if (remaining === 0 || this.now() >= deadline) break;
+				if (node.task.status !== "todo" || !automationEnabled(node.task) || stateById.get(node.task.id) !== "ready") continue;
+				if (!node.dependencyIds.some((id) => completedIds.has(id))) continue;
+				try {
+					this.tasks.transition(node.task.id, "start", {
+						actor: "daemon",
+						source: "automation-reconciler",
+						reason: "automation-enabled successor became ready",
+					});
+					result.started += 1;
+					remaining -= 1;
+				} catch (error) {
+					result.errors.push(boundedError(node.task.id, error));
+				}
+			}
+		}
+		if (this.now() >= deadline) result.timedOut = true;
+		return result;
+	}
+}

package/src/task-context.ts

@@ -34,8 +34,10 @@ function renderCurrent(task: Artifact): string[] {
 	];
 }
 
-export function taskContext(artifacts: ArtifactStore, activeTaskId?: string): string | null {
-	const tasks = artifacts.query({ kind: "task" }).sort((left, right) => left.updated_at.localeCompare(right.updated_at));
+export function taskContext(artifacts: ArtifactStore, activeTaskId?: string, taskIds?: Set<string>): string | null {
+	const tasks = artifacts.query({ kind: "task" })
+		.filter((task) => taskIds === undefined || taskIds.has(task.id))
+		.sort((left, right) => left.updated_at.localeCompare(right.updated_at));
 	const open = tasks.filter((task) => task.status !== "done" && task.status !== "canceled");
 	if (open.length === 0) return null;