@danypops/papyrus 0.2.0 → 0.2.1

package/README.md

@@ -129,7 +129,7 @@ Proof types are `file`, `symbol`, `code`, `test`, `command`, `artifact`, and `ur
 
 Papyrus also injects an Alef-style reconciliation block on every agent turn while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run gates before marking it done. The injection disappears when every task is complete.
 
-In TUI and RPC modes, the extension checks bounded active Tasks at Pi’s public `agent_settled` lifecycle boundary. If active work remains and no continuation is already pending, it queues one hidden next turn so the agent continues instead of handing off merely because a low-level run ended. Driving is single-flight and pauses after 20 automatic turns or 6 unchanged task snapshots. Use `/task-drive on`, `/task-drive off`, or `/task-drive status`; human input and task progress reset the bounded counters.
+In TUI and RPC modes, the extension checks bounded active Tasks at Pi’s public `agent_settled` lifecycle boundary. If active work remains and no continuation is already pending, it queues one hidden next turn so the agent continues instead of handing off merely because a low-level run ended. Active Tasks are the trigger; no manual command is required. Driving is single-flight and pauses after 20 automatic turns or 6 unchanged task snapshots; human input and task progress reset the bounded counters automatically.
 
 ## Why
 

package/extension/src/{task-driver.ts → active-task-continuation.ts}

@@ -4,20 +4,19 @@ export interface ActiveTaskMarker {
 	updated_at: string;
 }
 
-export interface TaskDriverOptions {
+export interface ActiveTaskContinuationOptions {
 	maxTurns: number;
 	maxUnchangedTurns: number;
 }
 
-export interface TaskDriverState {
-	enabled: boolean;
+export interface ActiveTaskContinuationState {
 	queued: boolean;
 	consecutiveTurns: number;
 	unchangedTurns: number;
 	pausedReason?: string;
 }
 
-export interface TaskDriverDecision {
+export interface ActiveTaskContinuationDecision {
 	action: "continue" | "wait" | "pause";
 	reason: string;
 	prompt?: string;
@@ -37,29 +36,27 @@ function continuationPrompt(tasks: ActiveTaskMarker[]): string {
 	const names = tasks.slice(0, DISPLAYED_TASK_LIMIT).map((task) => `- ${task.id}: ${task.title.slice(0, TITLE_LIMIT)}`);
 	return [
 		"Continue active Papyrus work now; do not hand off merely because the previous Pi run settled.",
-		"Reconcile the active Tasks, choose the next concrete action, use tools, run gates before completion, and continue until done, blocked, or the bounded task driver pauses.",
+		"Reconcile the active Tasks, choose the next concrete action, use tools, run gates before completion, and continue until done, blocked, or the bounded continuation pauses.",
 		"Active tasks:",
 		...names,
 	].join("\n");
 }
 
-export class TaskDriver {
-	private enabled = true;
+export class ActiveTaskContinuation {
 	private queued = false;
 	private consecutiveTurns = 0;
 	private unchangedTurns = 0;
 	private lastFingerprint: string | undefined;
 	private pausedReason: string | undefined;
 
-	constructor(private readonly options: TaskDriverOptions) {
+	constructor(private readonly options: ActiveTaskContinuationOptions) {
 		if (!Number.isInteger(options.maxTurns) || options.maxTurns < 1) throw new Error("maxTurns must be a positive integer");
 		if (!Number.isInteger(options.maxUnchangedTurns) || options.maxUnchangedTurns < 1) {
 			throw new Error("maxUnchangedTurns must be a positive integer");
 		}
 	}
 
-	evaluate(tasks: ActiveTaskMarker[], context: { idle: boolean; pendingMessages: boolean }): TaskDriverDecision {
-		if (!this.enabled) return { action: "wait", reason: "disabled" };
+	evaluate(tasks: ActiveTaskMarker[], context: { idle: boolean; pendingMessages: boolean }): ActiveTaskContinuationDecision {
 		if (!context.idle) return { action: "wait", reason: "Pi is not settled" };
 		if (context.pendingMessages) return { action: "wait", reason: "Pi already has pending messages" };
 		if (this.queued) return { action: "wait", reason: "continuation already queued" };
@@ -101,15 +98,8 @@ export class TaskDriver {
 		this.resetProgress();
 	}
 
-	setEnabled(enabled: boolean): void {
-		this.enabled = enabled;
-		if (enabled) this.resetProgress();
-		else this.queued = false;
-	}
-
-	status(): TaskDriverState {
+	status(): ActiveTaskContinuationState {
 		return {
-			enabled: this.enabled,
 			queued: this.queued,
 			consecutiveTurns: this.consecutiveTurns,
 			unchangedTurns: this.unchangedTurns,
@@ -117,7 +107,7 @@ export class TaskDriver {
 		};
 	}
 
-	private pause(reason: string): TaskDriverDecision {
+	private pause(reason: string): ActiveTaskContinuationDecision {
 		this.pausedReason = reason;
 		return { action: "pause", reason };
 	}

package/extension/src/index.ts

@@ -21,7 +21,7 @@ import { formatMetadata } from "./artifact-format.ts";
 import { callService } from "./service-client.ts";
 import { registerDomainTools } from "./domain-tools.ts";
 import type { TaskGraph } from "../../src/task-service.ts";
-import { TaskDriver, type ActiveTaskMarker } from "./task-driver.ts";
+import { ActiveTaskContinuation, type ActiveTaskMarker } from "./active-task-continuation.ts";
 import { buildTaskWidgetProjection } from "./task-widget.ts";
 
 function text(t: string, details: Record<string, unknown> = {}) {
@@ -137,7 +137,7 @@ class TaskOverlay {
 
 export default async function (pi: ExtensionAPI) {
 	registerDomainTools(pi);
-	const taskDriver = new TaskDriver({
+	const taskContinuation = new ActiveTaskContinuation({
 		maxTurns: TASK_DRIVER_MAX_TURNS,
 		maxUnchangedTurns: TASK_DRIVER_MAX_UNCHANGED_TURNS,
 	});
@@ -149,7 +149,7 @@ export default async function (pi: ExtensionAPI) {
 				status: "active",
 				limit: TASK_DRIVER_ACTIVE_LIMIT,
 			});
-			const decision = taskDriver.evaluate(active, {
+			const decision = taskContinuation.evaluate(active, {
 				idle: ctx.isIdle(),
 				pendingMessages: ctx.hasPendingMessages(),
 			});
@@ -160,40 +160,13 @@ export default async function (pi: ExtensionAPI) {
 					display: false,
 				}, { triggerTurn: true, deliverAs: "nextTurn" });
 			} else if (decision.action === "pause" && ctx.hasUI) {
-				ctx.ui.notify(`Papyrus task driving paused: ${decision.reason}. Use /task-drive on to resume.`, "warning");
+				ctx.ui.notify(`Papyrus task driving paused: ${decision.reason}. Human input or task progress resumes it automatically.`, "warning");
 			}
 		} catch {
 			// The daemon may be unavailable during startup, reload, or shutdown.
 		}
 	};
 
-	pi.registerCommand("task-drive", {
-		description: "Control bounded automatic continuation while active Papyrus Tasks remain",
-		handler: async (args, ctx) => {
-			const action = args.trim().toLowerCase() || "status";
-			if (action === "on") {
-				taskDriver.setEnabled(true);
-				ctx.ui.notify("Papyrus task driving enabled", "info");
-				await driveActiveTasks(ctx);
-				return;
-			}
-			if (action === "off") {
-				taskDriver.setEnabled(false);
-				ctx.ui.notify("Papyrus task driving disabled", "info");
-				return;
-			}
-			if (action !== "status") {
-				ctx.ui.notify("Usage: /task-drive <on|off|status>", "warning");
-				return;
-			}
-			const status = taskDriver.status();
-			ctx.ui.notify(
-				`Papyrus task driving: ${status.enabled ? "on" : "off"} · ${status.consecutiveTurns}/${TASK_DRIVER_MAX_TURNS} automatic turns${status.pausedReason ? ` · paused: ${status.pausedReason}` : ""}`,
-				"info",
-			);
-		},
-	});
-
 	// ── Low-level graph-store tools ────────────────────────────────────
 
 	pi.registerTool({
@@ -393,9 +366,9 @@ export default async function (pi: ExtensionAPI) {
 	// retry, compaction retry, and queued follow-up processing have finished.
 
 	pi.on("input", (event) => {
-		if (event.source !== "extension") taskDriver.onHumanInput();
+		if (event.source !== "extension") taskContinuation.onHumanInput();
 	});
-	pi.on("agent_start", () => { taskDriver.onAgentStart(); });
+	pi.on("agent_start", () => { taskContinuation.onAgentStart(); });
 	pi.on("agent_settled", async (_event, ctx) => { await driveActiveTasks(ctx); });
 
 	// ── "Are we there yet?" — inject active tasks into every turn ──────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],