@danypops/papyrus 0.6.0 → 0.8.0

package/src/ops.ts

@@ -6,7 +6,7 @@ import { createRequire } from "node:module";
 import { exec } from "node:child_process";
 import type { Db } from "./db.ts";
 import { inTransaction } from "./db.ts";
-import type { Artifact, CreateArtifactInput } from "./domain/artifact.ts";
+import type { Artifact, CreateArtifactInput, UpdateArtifactInput } from "./domain/artifact.ts";
 import type { Gate, GateResult, GateRunOptions } from "./domain/gate.ts";
 export type { Artifact } from "./domain/artifact.ts";
 export type { Gate, GateResult } from "./domain/gate.ts";
@@ -204,6 +204,22 @@ export function linkArtifacts(db: Db, fromId: string, relation: string, toId: st
 	});
 }
 
+export function updateArtifactContent(db: Db, id: string, input: UpdateArtifactInput): Artifact | null {
+	const artifact = getArtifact(db, id);
+	if (!artifact) return null;
+	const now = new Date().toISOString();
+	inTransaction(db, () => {
+		db.prepare("UPDATE artifacts SET title = ?, body = ?, labels = ?, updated_at = ? WHERE id = ?").run(
+			input.title ?? artifact.title,
+			input.body ?? artifact.body,
+			JSON.stringify(input.labels ?? artifact.labels),
+			now,
+			id,
+		);
+	});
+	return getArtifact(db, id);
+}
+
 export function updateStatus(db: Db, id: string, status: string): Artifact | null {
 	const art = getArtifact(db, id);
 	if (!art) return null;

package/src/ports/artifact-store.ts

@@ -6,6 +6,7 @@ import type {
 	ArtifactQuery,
 	CreateArtifactInput,
 	RelationshipQuery,
+	UpdateArtifactInput,
 } from "../domain/artifact.ts";
 
 export interface ArtifactStore {
@@ -15,5 +16,6 @@ export interface ArtifactStore {
 	link(link: ArtifactLink): void;
 	setStatus(id: string, status: string): Artifact | null;
 	setExtra(id: string, extra: Record<string, unknown>): Artifact | null;
+	updateContent(id: string, input: UpdateArtifactInput): Artifact | null;
 	relationships(filter?: RelationshipQuery): ArtifactEdge[];
 }

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

@@ -1,21 +1,43 @@
+export type TaskFocusStatus = "active" | "paused";
+
+export interface TaskFocusState {
+	taskId: string;
+	status: TaskFocusStatus;
+	updatedAt: string;
+	pauseReason?: string;
+}
+
 export interface TaskFocusStore {
-	get(): string | undefined;
-	set(taskId: string): void;
+	get(): TaskFocusState | undefined;
+	set(taskId: string): TaskFocusState;
+	pause(taskId: string, reason?: string): TaskFocusState;
+	unpause(taskId: string): TaskFocusState;
 	clear(taskId?: string): void;
 }
 
 export class InMemoryTaskFocusStore implements TaskFocusStore {
-	private taskId: string | undefined;
+	private state: TaskFocusState | undefined;
+
+	get(): TaskFocusState | undefined { return this.state; }
+
+	set(taskId: string): TaskFocusState {
+		this.state = { taskId, status: "active", updatedAt: new Date().toISOString() };
+		return this.state;
+	}
 
-	get(): string | undefined {
-		return this.taskId;
+	pause(taskId: string, reason?: string): TaskFocusState {
+		if (this.state?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		this.state = { ...this.state, status: "paused", updatedAt: new Date().toISOString(), ...(reason ? { pauseReason: reason } : {}) };
+		return this.state;
 	}
 
-	set(taskId: string): void {
-		this.taskId = taskId;
+	unpause(taskId: string): TaskFocusState {
+		if (this.state?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
+		this.state = { taskId, status: "active", updatedAt: new Date().toISOString() };
+		return this.state;
 	}
 
 	clear(taskId?: string): void {
-		if (taskId === undefined || taskId === this.taskId) this.taskId = undefined;
+		if (taskId === undefined || this.state?.taskId === taskId) this.state = undefined;
 	}
 }

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

@@ -0,0 +1,40 @@
+import type { TaskProjectScope, TaskScopeSource, TaskViewMode, TaskViewPreference } from "../domain/task-scope.ts";
+
+export interface TaskScopeStore {
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope;
+	get(taskId: string): TaskProjectScope | undefined;
+	taskIds(projectRoot: string | undefined, limit: number): string[];
+	view(projectRoot: string): TaskViewPreference;
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference;
+}
+
+export class InMemoryTaskScopeStore implements TaskScopeStore {
+	private readonly scopes = new Map<string, TaskProjectScope>();
+	private readonly views = new Map<string, TaskViewPreference>();
+
+	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
+		const scope = { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
+		this.scopes.set(taskId, scope);
+		return scope;
+	}
+
+	get(taskId: string): TaskProjectScope | undefined { return this.scopes.get(taskId); }
+
+	taskIds(projectRoot: string | undefined, limit: number): string[] {
+		return [...this.scopes.values()]
+			.filter((scope) => scope.projectRoot === projectRoot)
+			.map((scope) => scope.taskId)
+			.sort()
+			.slice(0, limit);
+	}
+
+	view(projectRoot: string): TaskViewPreference {
+		return this.views.get(projectRoot) ?? { projectRoot, mode: "project" };
+	}
+
+	setView(projectRoot: string, mode: TaskViewMode, rootTaskId?: string): TaskViewPreference {
+		const view = { projectRoot, mode, ...(rootTaskId === undefined ? {} : { rootTaskId }) };
+		this.views.set(projectRoot, view);
+		return view;
+	}
+}

package/src/service.ts

@@ -5,15 +5,17 @@ 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,
@@ -41,8 +43,6 @@ import { instantiateSkillWorkflow } from "./skill-execution.ts";
 
 export const EXPECTED_OPERATION_NAMES = [
 	"system.migrate",
-	"automation.status",
-	"automation.reconcile",
 	"artifact.create",
 	"artifact.query",
 	"artifact.show",
@@ -52,19 +52,26 @@ export const EXPECTED_OPERATION_NAMES = [
 	"gates.run",
 	"rules.injectable",
 	"tasks.create",
+	"tasks.update",
 	"tasks.list",
 	"tasks.graph",
 	"tasks.plan",
 	"tasks.show",
 	"tasks.history",
+	"tasks.scope",
+	"tasks.set_scope",
+	"tasks.assign_project",
 	"tasks.active",
+	"tasks.focused",
 	"tasks.focus",
+	"tasks.pause",
+	"tasks.unpause",
+	"tasks.clear_focus",
 	"tasks.start",
 	"tasks.submit",
 	"tasks.complete",
 	"tasks.run_gates",
 	"tasks.set_checklist",
-	"tasks.set_automation",
 	"tasks.context",
 	"tasks.reject",
 	"tasks.retry",
@@ -117,6 +124,13 @@ function optionalString(input: OperationInput, key: string): string | undefined
 	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;
@@ -148,8 +162,8 @@ function handlers(
 	artifacts: ArtifactStore,
 	gates: GateRunner,
 	tasks: Tasks,
-	automation: TaskAutomationReconciler,
 	events: TaskEventStore,
+	scopes: TaskScopeStore,
 	migrate: () => unknown,
 ): Record<OperationName, OperationHandler> {
 	const eventContext = (input: OperationInput): TaskEventContext => ({
@@ -162,15 +176,19 @@ function handlers(
 		const context = eventContext(input);
 		return { ...context, source: context.source ?? source };
 	};
-	const taskFilter = (input: OperationInput) => ({
+	const artifactFilter = (input: OperationInput) => ({
 		status: optionalString(input, "status"),
 		text: optionalString(input, "text"),
 		limit: optionalNumber(input, "limit"),
 	});
+	const taskFilter = (input: OperationInput) => ({
+		...artifactFilter(input),
+		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);
@@ -183,6 +201,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),
@@ -218,7 +238,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"),
@@ -231,6 +251,13 @@ 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.update": (input) => 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")! } : {}),
 		}, eventContext(input)),
 		"tasks.list": (input) => tasks.list(taskFilter(input)),
 		"tasks.graph": (input) => tasks.graph(taskFilter(input)),
@@ -241,18 +268,29 @@ function handlers(
 			cursor: optionalNumber(input, "cursor"),
 			direction: optionalString(input, "direction") as TaskEventDirection | undefined,
 		}),
-		"tasks.active": () => tasks.active(),
-		"tasks.focus": (input) => tasks.focus(string(input, "id")),
+		"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.focused": (input) => tasks.focused(taskFilter(input)),
+		"tasks.focus": (input) => tasks.focus(string(input, "id"), eventContext(input)),
+		"tasks.pause": (input) => tasks.pauseFocus(eventContext(input)),
+		"tasks.unpause": (input) => tasks.unpauseFocus(eventContext(input)),
+		"tasks.clear_focus": (input) => tasks.clearFocus(eventContext(input)),
 		"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.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": () => taskContext(artifacts, tasks.active()?.id),
+		"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)),
@@ -263,7 +301,7 @@ function handlers(
 			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
 			templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
 		}),
-		"docs.list": (input) => listDocuments(artifacts, taskFilter(input)),
+		"docs.list": (input) => listDocuments(artifacts, artifactFilter(input)),
 		"docs.show": (input) => showDocument(artifacts, string(input, "id")),
 		"docs.activate": (input) => transitionDocument(artifacts, string(input, "id"), "activate"),
 		"docs.archive": (input) => transitionDocument(artifacts, string(input, "id"), "archive"),
@@ -275,7 +313,7 @@ function handlers(
 			severity: optionalString(input, "severity") as "block" | "warn" | "info" | undefined,
 			labels: input["labels"] as string[] | undefined, extra: input["extra"] as Record<string, unknown> | undefined,
 		}),
-		"rules.list": (input) => listRules(artifacts, taskFilter(input)),
+		"rules.list": (input) => listRules(artifacts, artifactFilter(input)),
 		"rules.show": (input) => showRule(artifacts, string(input, "id")),
 		"rules.preview": (input) => previewRule(artifacts, string(input, "id")),
 		"rules.enable": (input) => transitionRule(artifacts, string(input, "id"), "enable"),
@@ -291,28 +329,42 @@ function handlers(
 			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,
 		}),
-		"skills.list": (input) => listSkills(artifacts, taskFilter(input)),
+		"skills.list": (input) => listSkills(artifacts, artifactFilter(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") }),
+		}, { 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, options: { automation?: TaskAutomationSettings } = {}): PapyrusService {
+export function createPapyrusService(path: string): 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 automation = new TaskAutomationReconciler(tasks, options.automation ?? taskAutomationSettings({}));
-	const registry = handlers(artifacts, gates, tasks, automation, events, () => migrateDb(db));
+	const scopes = new SQLiteTaskScopeStore(db);
+	const tasks = new Tasks(artifacts, gates, focus, events, scopes);
+	const registry = handlers(artifacts, gates, tasks, events, scopes, () => migrateDb(db));
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };
@@ -323,8 +375,8 @@ export function createPapyrusService(path: string, options: { automation?: TaskA
 		async execute(operation, input = {}) {
 			const handler = registry[operation as OperationName];
 			if (!handler) throw new UnknownOperationError(`unknown operation "${operation}"`);
-			if (operation !== "system.migrate" && operation !== "automation.status" && state().migrationRequired) {
-				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-history`");
+			if (operation !== "system.migrate" && state().migrationRequired) {
+				throw new MigrationRequiredError("database migration required; run `papyrus migrate task-focus`");
 			}
 			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-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;