@themoltnet/agent-daemon 0.6.2 → 0.7.0

package/dist/main.js

@@ -12,6 +12,7 @@ import { execFile, execFileSync } from "node:child_process";
 import { DefaultResourceLoader, SessionManager, createAgentSession, createBashToolDefinition, createEditToolDefinition, createReadToolDefinition, createSyntheticSourceInfo, createWriteToolDefinition, defineTool, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { Type, getModel } from "@earendil-works/pi-ai";
 import { MemoryProvider, RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, createShadowPathPredicate, ensureImageSelector, loadGuestAssets } from "@earendil-works/gondolin";
+import { DatabaseSync } from "node:sqlite";
 import { once } from "node:events";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { resourceFromAttributes } from "@opentelemetry/resources";
@@ -4756,7 +4757,10 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: FulfillBriefInput,
 		outputSchema: FulfillBriefOutput,
 		outputKind: "artifact",
+		resumable: true,
 		workspaceMode: "dedicated_worktree",
+		workspaceScope: "session",
+		sessionScope: "correlation",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -4766,6 +4770,8 @@ var BUILT_IN_TASK_TYPES = {
 		outputSchema: AssessBriefOutput,
 		outputKind: "judgment",
 		workspaceMode: "dedicated_worktree",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateInputAsync: validateAssessBriefInputAsync
@@ -4775,6 +4781,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: CuratePackInput,
 		outputSchema: CuratePackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -4783,6 +4791,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RenderPackInput,
 		outputSchema: RenderPackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent,
 		validateInputAsync: validateRenderPackInputAsync
@@ -4792,6 +4802,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgePackInput,
 		outputSchema: JudgePackOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateOutput: validateJudgePackOutput,
@@ -4802,6 +4814,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RunEvalInput,
 		outputSchema: RunEvalOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateOutput: validateRunEvalOutput
 	},
@@ -4810,6 +4824,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgeEvalVariantInput,
 		outputSchema: JudgeEvalVariantOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateInput: validateJudgeEvalVariantInput,
 		validateOutput: validateJudgeEvalVariantOutput,
@@ -5732,6 +5748,49 @@ function taskTypeUsesSubagents(taskType) {
 function taskTypeWorkspaceMode(taskType) {
 	return getTaskTypeEntry(taskType)?.workspaceMode ?? "shared_mount";
 }
+/**
+* Whether the daemon may keep a warm executor session alive after one
+* attempt completes and reuse it for later related tasks.
+*
+* Unknown task types default to `false`.
+*/
+function taskTypeResumable(taskType) {
+	return getTaskTypeEntry(taskType)?.resumable === true;
+}
+/**
+* Lifetime of the task type's workspace.
+*
+* Unknown task types and task types without an explicit policy default to the
+* disposable per-attempt behavior.
+*/
+function taskTypeWorkspaceScope(taskType) {
+	return getTaskTypeEntry(taskType)?.workspaceScope ?? "attempt";
+}
+/**
+* Granularity of daemon-local warm-session reuse.
+*
+* Unknown task types and task types without an explicit policy default to no
+* reuse.
+*/
+function taskTypeSessionScope(taskType) {
+	return getTaskTypeEntry(taskType)?.sessionScope ?? "none";
+}
+/**
+* Resolve the daemon-relevant execution policy declared by a task type.
+*
+* This is the single read path for "may this task reuse a warm session?" and
+* "does its workspace belong to the attempt or the session?" so daemon code
+* doesn't need to hand-roll defaults or peek at the raw registry shape.
+*/
+function getTaskExecutionPolicy(taskType) {
+	return {
+		resumable: taskTypeResumable(taskType),
+		workspaceMode: taskTypeWorkspaceMode(taskType),
+		workspaceScope: taskTypeWorkspaceScope(taskType),
+		sessionScope: taskTypeSessionScope(taskType),
+		usesSubagents: taskTypeUsesSubagents(taskType)
+	};
+}
 //#endregion
 //#region ../../libs/tasks/src/wire.ts
 /**
@@ -5994,6 +6053,10 @@ var COMMON_OPTIONAL_FLAGS = `\
                               this, the pi session aborts and the attempt
                               fails with code 'max_bash_timeouts_exceeded'.
                               0 = disabled. Default: 3.
+  --warm-session-ttl-sec <n>  Retain resumable daemon slots (Pi sessions +
+                              reusable worktrees) in local daemon state for
+                              this many seconds after use. 0 = disable reuse.
+                              Default: 1800.
   --debug                     Verbose logging: also log successful list/claim
                               outcomes (candidate counts, claim attempts).`;
 var REGISTERED_TASK_TYPES = Object.keys(BUILT_IN_TASK_TYPES).sort();
@@ -15329,9 +15392,11 @@ var NO_SKILLS = () => ({
 	diagnostics: []
 });
 /**
-* Construct an in-memory `AgentSession`. The caller is responsible for
-* eventually invoking `session.prompt(...)` and for tearing down — the
-* helper does no lifecycle management beyond construction.
+* Construct an `AgentSession`. By default it is in-memory; callers may opt
+* parent sessions into daemon-owned file persistence via `sessionPersistence`.
+* The caller is responsible for eventually invoking `session.prompt(...)` and
+* for tearing down — the helper does no lifecycle management beyond
+* construction.
 */
 async function buildAgentSession(args) {
 	const piOtelExtension = createPiOtelExtension({
@@ -15346,15 +15411,23 @@ async function buildAgentSession(args) {
 		skillsOverride: args.skillsOverride ?? NO_SKILLS
 	});
 	await resourceLoader.reload();
+	const sessionManager = args.sessionPersistence ? await resolvePersistentSessionManager({
+		cwd: args.mountPath,
+		sessionDir: args.sessionPersistence.sessionDir
+	}) : SessionManager.inMemory(args.mountPath);
 	return (await createAgentSession({
 		agentDir: args.piAuthDir,
 		cwd: args.mountPath,
 		model: args.modelHandle,
 		customTools: args.customTools,
-		sessionManager: SessionManager.inMemory(),
+		sessionManager,
 		resourceLoader
 	})).session;
 }
+async function resolvePersistentSessionManager(args) {
+	await SessionManager.list(args.cwd, args.sessionDir);
+	return SessionManager.continueRecent(args.cwd, args.sessionDir);
+}
 //#endregion
 //#region ../../libs/pi-extension/src/runtime/inject-task-context.ts
 /**
@@ -15965,6 +16038,113 @@ function resolveSubmitTools(taskType, opts = {}) {
 	};
 }
 //#endregion
+//#region ../../libs/pi-extension/src/runtime/task-workspace.ts
+function prepareTaskWorkspace(task, requestedMountPath, executionPlan) {
+	const branch = executionPlan?.worktreeBranch ?? null;
+	if (!branch) return {
+		mountPath: requestedMountPath,
+		mode: "shared_mount",
+		branch: null,
+		cleanup: () => {}
+	};
+	const mainRepo = findMainWorktree();
+	const worktreeDir = resolveTaskWorktreePath(mainRepo, executionPlan?.workspaceId ?? `task-${task.id}`);
+	const relMount = relative(mainRepo, requestedMountPath);
+	const mountPath = relMount === "" || relMount.startsWith("..") ? worktreeDir : join(worktreeDir, relMount);
+	const keepWorkspace = executionPlan?.workspaceScope === "session" && executionPlan.sessionKey !== null;
+	if (keepWorkspace) ensureReusableTaskWorktree(mainRepo, worktreeDir, branch);
+	else {
+		removeExistingTaskWorktree(mainRepo, worktreeDir);
+		addTaskWorktree(mainRepo, worktreeDir, branch);
+	}
+	return {
+		mountPath,
+		mode: "dedicated_worktree",
+		branch,
+		cleanup: keepWorkspace ? () => {} : () => {
+			execFileSync("git", [
+				"-C",
+				mainRepo,
+				"worktree",
+				"remove",
+				"--force",
+				worktreeDir
+			], { stdio: "pipe" });
+		}
+	};
+}
+function resolveTaskWorktreePath(mainRepo, workspaceId) {
+	return join(mainRepo, ".worktrees", workspaceId);
+}
+function ensureReusableTaskWorktree(mainRepo, worktreeDir, branch) {
+	if (isRegisteredWorktree$1(mainRepo, worktreeDir)) return;
+	if (existsSync(worktreeDir)) throw new Error(`Expected reusable worktree ${worktreeDir} to be git-managed, but it exists outside git worktree metadata.`);
+	addTaskWorktree(mainRepo, worktreeDir, branch);
+}
+function addTaskWorktree(mainRepo, worktreeDir, branch) {
+	const baseRef = resolveWorktreeBaseRef(mainRepo);
+	execFileSync("git", gitRefExists(mainRepo, `refs/heads/${branch}`) ? [
+		"-C",
+		mainRepo,
+		"worktree",
+		"add",
+		worktreeDir,
+		branch
+	] : [
+		"-C",
+		mainRepo,
+		"worktree",
+		"add",
+		"-b",
+		branch,
+		worktreeDir,
+		baseRef
+	], { stdio: "pipe" });
+}
+function removeExistingTaskWorktree(mainRepo, worktreeDir) {
+	if (!existsSync(worktreeDir) || !isRegisteredWorktree$1(mainRepo, worktreeDir)) return;
+	execFileSync("git", [
+		"-C",
+		mainRepo,
+		"worktree",
+		"remove",
+		"--force",
+		worktreeDir
+	], { stdio: "pipe" });
+}
+function isRegisteredWorktree$1(mainRepo, worktreeDir) {
+	const list = execFileSync("git", [
+		"-C",
+		mainRepo,
+		"worktree",
+		"list",
+		"--porcelain"
+	], {
+		encoding: "utf8",
+		stdio: "pipe"
+	});
+	const marker = `worktree ${worktreeDir}\n`;
+	return list.includes(marker) || list.endsWith(`worktree ${worktreeDir}`);
+}
+function resolveWorktreeBaseRef(mainRepo) {
+	return gitRefExists(mainRepo, "refs/heads/main") ? "main" : "HEAD";
+}
+function gitRefExists(mainRepo, ref) {
+	try {
+		execFileSync("git", [
+			"-C",
+			mainRepo,
+			"show-ref",
+			"--verify",
+			"--quiet",
+			ref
+		], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region ../../libs/pi-extension/src/runtime/execute-pi-task.ts
 /**
 * executePiTask — run a single Task attempt using pi-coding-agent inside a
@@ -16013,7 +16193,9 @@ async function executePiTask(claimedTask, reporter, opts) {
 	const task = claimedTask.task;
 	const attemptN = claimedTask.attemptN;
 	const startTime = Date.now();
-	const workspace = prepareTaskWorkspace(task, opts.mountPath ?? process.cwd());
+	const requestedMountPath = opts.mountPath ?? process.cwd();
+	const executionPlan = opts.makeExecutionPlan?.(claimedTask) ?? null;
+	const workspace = prepareTaskWorkspace(task, requestedMountPath, executionPlan);
 	const mountPath = workspace.mountPath;
 	if (reporter.cancelSignal.aborted) return {
 		taskId: task.id,
@@ -16229,7 +16411,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 					"moltnet.task.id": task.id,
 					"moltnet.task.attempt": attemptN,
 					"moltnet.task.type": task.taskType
-				}
+				},
+				sessionPersistence: executionPlan?.sessionPersistence ?? void 0
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
@@ -16457,107 +16640,6 @@ async function executePiTask(claimedTask, reporter, opts) {
 		}
 	}
 }
-function resolveTaskWorktreeBranch(task) {
-	if (taskTypeWorkspaceMode(task.taskType) !== "dedicated_worktree") return null;
-	if (task.taskType === "fulfill_brief") {
-		const input = task.input;
-		const slug = slugifyBranchComponent(typeof input.title === "string" && input.title.trim().length > 0 ? input.title : typeof input.brief === "string" && input.brief.trim().length > 0 ? input.brief : task.taskType) || "task";
-		if (task.correlationId) return `moltnet/${task.correlationId}/${slug}`;
-		return `feat/${(typeof input.scopeHint === "string" && input.scopeHint.trim().length > 0 ? slugifyBranchComponent(input.scopeHint) : "task") || "task"}-${slug}`;
-	}
-	return `task/${slugifyBranchComponent(task.taskType) || "task"}-${task.id.slice(0, 8)}`;
-}
-function slugifyBranchComponent(input) {
-	return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
-}
-function prepareTaskWorkspace(task, requestedMountPath) {
-	const branch = resolveTaskWorktreeBranch(task);
-	if (!branch) return {
-		mountPath: requestedMountPath,
-		mode: "shared_mount",
-		branch: null,
-		cleanup: () => {}
-	};
-	const mainRepo = findMainWorktree();
-	const worktreeDir = join(mainRepo, ".worktrees", `task-${task.id}`);
-	removeExistingTaskWorktree(mainRepo, worktreeDir);
-	const relMount = relative(mainRepo, requestedMountPath);
-	const mountPath = relMount === "" || relMount.startsWith("..") ? worktreeDir : join(worktreeDir, relMount);
-	const baseRef = resolveWorktreeBaseRef(mainRepo);
-	execFileSync("git", gitRefExists(mainRepo, `refs/heads/${branch}`) ? [
-		"-C",
-		mainRepo,
-		"worktree",
-		"add",
-		worktreeDir,
-		branch
-	] : [
-		"-C",
-		mainRepo,
-		"worktree",
-		"add",
-		"-b",
-		branch,
-		worktreeDir,
-		baseRef
-	], { stdio: "pipe" });
-	return {
-		mountPath,
-		mode: "dedicated_worktree",
-		branch,
-		cleanup: () => {
-			execFileSync("git", [
-				"-C",
-				mainRepo,
-				"worktree",
-				"remove",
-				"--force",
-				worktreeDir
-			], { stdio: "pipe" });
-		}
-	};
-}
-function removeExistingTaskWorktree(mainRepo, worktreeDir) {
-	if (!existsSync(worktreeDir)) return;
-	const list = execFileSync("git", [
-		"-C",
-		mainRepo,
-		"worktree",
-		"list",
-		"--porcelain"
-	], {
-		encoding: "utf8",
-		stdio: "pipe"
-	});
-	const marker = `worktree ${worktreeDir}\n`;
-	if (!list.includes(marker) && !list.endsWith(`worktree ${worktreeDir}`)) return;
-	execFileSync("git", [
-		"-C",
-		mainRepo,
-		"worktree",
-		"remove",
-		"--force",
-		worktreeDir
-	], { stdio: "pipe" });
-}
-function resolveWorktreeBaseRef(mainRepo) {
-	return gitRefExists(mainRepo, "refs/heads/main") ? "main" : "HEAD";
-}
-function gitRefExists(mainRepo, ref) {
-	try {
-		execFileSync("git", [
-			"-C",
-			mainRepo,
-			"show-ref",
-			"--verify",
-			"--quiet",
-			ref
-		], { stdio: "pipe" });
-		return true;
-	} catch {
-		return false;
-	}
-}
 function emptyUsage(provider, model) {
 	return {
 		inputTokens: 0,
@@ -16757,6 +16839,419 @@ function createGhCliClient() {
 	};
 }
 //#endregion
+//#region src/lib/daemon-slot-registry.ts
+var DaemonSlotRegistryError = class extends Error {
+	constructor(operation, cause) {
+		super(`Daemon slot registry failed during ${operation}`, { cause });
+		this.operation = operation;
+		this.name = "DaemonSlotRegistryError";
+	}
+};
+var DaemonSlotRegistry = class {
+	db;
+	constructor(dbPath) {
+		try {
+			this.db = new DatabaseSync(dbPath);
+			this.withDb("initialize schema", () => {
+				this.db.exec(`
+      PRAGMA journal_mode = WAL;
+
+      CREATE TABLE IF NOT EXISTS daemon_slots (
+        agent_name TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        slot_key TEXT NOT NULL,
+        task_type TEXT NOT NULL,
+        state TEXT NOT NULL CHECK (state IN ('active', 'idle')),
+        last_task_id TEXT NOT NULL,
+        last_attempt_n INTEGER NOT NULL,
+        created_at_ms INTEGER NOT NULL,
+        last_used_at_ms INTEGER NOT NULL,
+        expires_at_ms INTEGER NOT NULL,
+        PRIMARY KEY (agent_name, provider, model, slot_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS daemon_slot_sessions (
+        agent_name TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        slot_key TEXT NOT NULL,
+        session_dir TEXT NOT NULL UNIQUE,
+        session_path TEXT,
+        PRIMARY KEY (agent_name, provider, model, slot_key),
+        FOREIGN KEY (agent_name, provider, model, slot_key)
+          REFERENCES daemon_slots(agent_name, provider, model, slot_key)
+          ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS daemon_slot_workspaces (
+        agent_name TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        slot_key TEXT NOT NULL,
+        workspace_id TEXT NOT NULL UNIQUE,
+        worktree_path TEXT NOT NULL,
+        worktree_branch TEXT,
+        PRIMARY KEY (agent_name, provider, model, slot_key),
+        FOREIGN KEY (agent_name, provider, model, slot_key)
+          REFERENCES daemon_slots(agent_name, provider, model, slot_key)
+          ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS daemon_slots_expires_idx
+        ON daemon_slots (expires_at_ms);
+        `);
+			});
+		} catch (error) {
+			throw new DaemonSlotRegistryError("open database", error);
+		}
+	}
+	close() {
+		try {
+			this.db.close();
+		} catch (error) {
+			throw new DaemonSlotRegistryError("close database", error);
+		}
+	}
+	beginSlot(input) {
+		const now = Date.now();
+		const expiresAtMs = now + input.ttlSec * 1e3;
+		this.withDb("upsert slot", () => this.db.prepare(`INSERT INTO daemon_slots (
+           agent_name, provider, model, slot_key, task_type, state,
+           last_task_id, last_attempt_n, created_at_ms, last_used_at_ms,
+           expires_at_ms
+         ) VALUES (
+           :agentName, :provider, :model, :slotKey, :taskType, 'active',
+           :lastTaskId, :lastAttemptN, :createdAtMs, :lastUsedAtMs,
+           :expiresAtMs
+         )
+         ON CONFLICT(agent_name, provider, model, slot_key) DO UPDATE SET
+           task_type = excluded.task_type,
+           state = 'active',
+           last_task_id = excluded.last_task_id,
+           last_attempt_n = excluded.last_attempt_n,
+           last_used_at_ms = excluded.last_used_at_ms,
+           expires_at_ms = excluded.expires_at_ms`).run({
+			agentName: input.agentName,
+			provider: input.provider,
+			model: input.model,
+			slotKey: input.slotKey,
+			taskType: input.taskType,
+			lastTaskId: input.lastTaskId,
+			lastAttemptN: input.lastAttemptN,
+			createdAtMs: now,
+			lastUsedAtMs: now,
+			expiresAtMs
+		}));
+		if (input.sessionDir) this.withDb("upsert slot session", () => this.db.prepare(`INSERT INTO daemon_slot_sessions (
+             agent_name, provider, model, slot_key, session_dir, session_path
+           ) VALUES (
+             :agentName, :provider, :model, :slotKey, :sessionDir, :sessionPath
+           )
+           ON CONFLICT(agent_name, provider, model, slot_key) DO UPDATE SET
+             session_dir = excluded.session_dir,
+             session_path = excluded.session_path`).run({
+			agentName: input.agentName,
+			provider: input.provider,
+			model: input.model,
+			slotKey: input.slotKey,
+			sessionDir: input.sessionDir,
+			sessionPath: input.sessionPath
+		}));
+		if (input.workspaceId && input.worktreePath) this.withDb("upsert slot workspace", () => this.db.prepare(`INSERT INTO daemon_slot_workspaces (
+             agent_name, provider, model, slot_key, workspace_id, worktree_path,
+             worktree_branch
+           ) VALUES (
+             :agentName, :provider, :model, :slotKey, :workspaceId, :worktreePath,
+             :worktreeBranch
+           )
+           ON CONFLICT(agent_name, provider, model, slot_key) DO UPDATE SET
+             workspace_id = excluded.workspace_id,
+             worktree_path = excluded.worktree_path,
+             worktree_branch = excluded.worktree_branch`).run({
+			agentName: input.agentName,
+			provider: input.provider,
+			model: input.model,
+			slotKey: input.slotKey,
+			workspaceId: input.workspaceId,
+			worktreePath: input.worktreePath,
+			worktreeBranch: input.worktreeBranch
+		}));
+	}
+	finishSlot(identity, slotKey, ttlSec, sessionPath) {
+		const now = Date.now();
+		this.withDb("finish slot", () => this.db.prepare(`UPDATE daemon_slots
+           SET state = 'idle',
+               last_used_at_ms = ?,
+               expires_at_ms = ?
+         WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?`).run(now, now + ttlSec * 1e3, identity.agentName, identity.provider, identity.model, slotKey));
+		if (sessionPath !== null) this.withDb("update slot session path", () => this.db.prepare(`UPDATE daemon_slot_sessions
+             SET session_path = ?
+           WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?`).run(sessionPath, identity.agentName, identity.provider, identity.model, slotKey));
+	}
+	reapExpiredSlots(now = Date.now()) {
+		this.withDb("begin reap transaction", () => this.db.exec("BEGIN IMMEDIATE"));
+		try {
+			const slots = this.withDb("select expired slots", () => this.db.prepare(`SELECT
+             agent_name as agentName,
+             provider,
+             model,
+             slot_key as slotKey,
+             task_type as taskType,
+             state,
+             last_task_id as lastTaskId,
+             last_attempt_n as lastAttemptN,
+             created_at_ms as createdAtMs,
+             last_used_at_ms as lastUsedAtMs,
+             expires_at_ms as expiresAtMs
+           FROM daemon_slots
+           WHERE expires_at_ms <= ?`).all(now));
+			if (slots.length < 1) {
+				this.withDb("commit empty reap transaction", () => this.db.exec("COMMIT"));
+				return [];
+			}
+			const selectSession = this.withDb("prepare slot session lookup", () => this.db.prepare(`SELECT
+             agent_name as agentName,
+             provider,
+             model,
+             slot_key as slotKey,
+             session_dir as sessionDir,
+             session_path as sessionPath
+           FROM daemon_slot_sessions
+           WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?`));
+			const selectWorkspace = this.withDb("prepare slot workspace lookup", () => this.db.prepare(`SELECT
+               agent_name as agentName,
+               provider,
+               model,
+               slot_key as slotKey,
+               workspace_id as workspaceId,
+               worktree_path as worktreePath,
+               worktree_branch as worktreeBranch
+             FROM daemon_slot_workspaces
+             WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?`));
+			const deleteStmt = this.withDb("prepare expired slot delete", () => this.db.prepare("DELETE FROM daemon_slots WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?"));
+			const out = [];
+			for (const slot of slots) {
+				const session = this.withDb("select slot session", () => selectSession.get(slot.agentName, slot.provider, slot.model, slot.slotKey) ?? null);
+				const workspace = this.withDb("select slot workspace", () => selectWorkspace.get(slot.agentName, slot.provider, slot.model, slot.slotKey) ?? null);
+				out.push({
+					slot,
+					session,
+					workspace
+				});
+				this.withDb("delete expired slot", () => deleteStmt.run(slot.agentName, slot.provider, slot.model, slot.slotKey));
+			}
+			this.withDb("commit reap transaction", () => this.db.exec("COMMIT"));
+			for (const item of out) {
+				if (item.session) cleanupPiSessionDir(item.session.sessionDir);
+				if (item.workspace) cleanupReusableWorktree(item.workspace.worktreePath);
+			}
+			return out;
+		} catch (error) {
+			try {
+				this.db.exec("ROLLBACK");
+			} catch {}
+			throw error instanceof DaemonSlotRegistryError ? error : new DaemonSlotRegistryError("reap expired slots", error);
+		}
+	}
+	withDb(operation, fn) {
+		try {
+			return fn();
+		} catch (error) {
+			throw new DaemonSlotRegistryError(operation, error);
+		}
+	}
+};
+function resolveLatestPiSessionPath(sessionDir) {
+	try {
+		const latestEntry = readdirSync(sessionDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort().at(-1);
+		return latestEntry ? join(sessionDir, latestEntry) : null;
+	} catch {
+		return null;
+	}
+}
+function cleanupPiSessionDir(sessionDir) {
+	rmSync(sessionDir, {
+		recursive: true,
+		force: true
+	});
+}
+function cleanupReusableWorktree(worktreePath) {
+	const mainRepo = findMainWorktree();
+	if (isRegisteredWorktree(mainRepo, worktreePath)) {
+		execFileSync("git", [
+			"-C",
+			mainRepo,
+			"worktree",
+			"remove",
+			"--force",
+			worktreePath
+		], { stdio: "pipe" });
+		return;
+	}
+	rmSync(worktreePath, {
+		recursive: true,
+		force: true
+	});
+}
+function isRegisteredWorktree(mainRepo, worktreeDir) {
+	const list = execFileSync("git", [
+		"-C",
+		mainRepo,
+		"worktree",
+		"list",
+		"--porcelain"
+	], {
+		encoding: "utf8",
+		stdio: "pipe"
+	});
+	const marker = `worktree ${worktreeDir}\n`;
+	return list.includes(marker) || list.endsWith(`worktree ${worktreeDir}`);
+}
+//#endregion
+//#region src/lib/slugify.ts
+function slugifyAsciiLower(input, maxLen, preserveChars = []) {
+	const preserved = new Set(preserveChars.map((char) => char.toLowerCase()));
+	let out = "";
+	let pendingDash = false;
+	for (const rawChar of input) {
+		const char = rawChar.toLowerCase();
+		const isAlphaNum = char >= "a" && char <= "z" || char >= "0" && char <= "9";
+		const isPreserved = preserved.has(char);
+		if (isAlphaNum || isPreserved) {
+			if (pendingDash && out.length > 0 && out.length < maxLen) out += "-";
+			pendingDash = false;
+			if (out.length < maxLen) out += char;
+			else break;
+			continue;
+		}
+		pendingDash = out.length > 0;
+	}
+	return out;
+}
+//#endregion
+//#region src/lib/session-policy.ts
+/**
+* Resolve the daemon-facing execution policy for a task and, when the task
+* type permits warm reuse, compute the daemon-local `sessionKey`.
+*
+* `correlationId` remains the audit/query key; `sessionKey` is narrower and
+* may fold in task-type-specific discriminators so eval/review flows stay
+* isolated even inside one correlation group.
+*/
+function deriveTaskSessionDescriptor(task) {
+	const policy = getTaskExecutionPolicy(task.taskType);
+	return {
+		policy,
+		sessionKey: buildTaskSessionKey(task, policy)
+	};
+}
+function buildTaskSessionKey(task, policy) {
+	if (!policy.resumable) return null;
+	switch (policy.sessionScope) {
+		case "none": return null;
+		case "correlation": return task.correlationId ? `${task.taskType}:correlation:${task.correlationId}` : null;
+		case "custom": return buildCustomSessionKey(task);
+	}
+}
+function buildCustomSessionKey(task) {
+	switch (task.taskType) {
+		case "run_eval": {
+			const variantLabel = typeof task.input.variantLabel === "string" ? task.input.variantLabel : null;
+			if (!task.correlationId || !variantLabel) return null;
+			return `run_eval:correlation:${task.correlationId}:variant:${slugifySessionComponent(variantLabel)}`;
+		}
+		case "judge_eval_variant": {
+			const runTaskIds = Array.isArray(task.input.runTaskIds) ? task.input.runTaskIds.filter((value) => typeof value === "string") : [];
+			if (runTaskIds.length < 1) return null;
+			return `judge_eval_variant:run_tasks:${[...runTaskIds].sort().join(",")}`;
+		}
+		default: return null;
+	}
+}
+function slugifySessionComponent(input) {
+	return slugifyAsciiLower(input.trim(), 64);
+}
+//#endregion
+//#region src/lib/task-execution-plan.ts
+function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec) {
+	const descriptor = deriveTaskSessionDescriptor(task);
+	const slotKey = warmSessionTtlSec > 0 ? descriptor.sessionKey : null;
+	const workspaceScope = slotKey !== null ? descriptor.policy.workspaceScope : "attempt";
+	const slotId = slotKey ? buildDaemonSlotId(identity, slotKey) : null;
+	const sessionDir = slotId ? `${stateDirs.piSessionsDir}/${encodeURIComponent(slotId)}` : null;
+	const worktreeBranch = resolveTaskWorktreeBranch(task, descriptor.policy);
+	const workspaceId = worktreeBranch !== null ? resolveTaskWorkspaceId(task, {
+		sessionKey: slotId,
+		workspaceScope,
+		sessionPersistence: sessionDir ? { sessionDir } : null
+	}) : null;
+	return {
+		descriptor,
+		sessionKey: slotId,
+		slotKey,
+		slotId,
+		workspaceScope,
+		sessionPersistence: sessionDir ? { sessionDir } : null,
+		workspaceId,
+		worktreeBranch
+	};
+}
+function buildDaemonSlotId(identity, slotKey) {
+	return [
+		"agent",
+		slugSlotIdentityComponent(identity.agentName),
+		"provider",
+		slugSlotIdentityComponent(identity.provider),
+		"model",
+		slugSlotIdentityComponent(identity.model),
+		"key",
+		slotKey
+	].join(":");
+}
+function slugSlotIdentityComponent(input) {
+	return slugifyAsciiLower(input.trim(), 64, [
+		".",
+		"_",
+		"-"
+	]);
+}
+function resolveTaskWorktreeBranch(task, policy) {
+	if (policy.workspaceMode !== "dedicated_worktree") return null;
+	if (task.taskType === "fulfill_brief") {
+		const input = task.input;
+		const slug = slugifyAsciiLower(typeof input.title === "string" && input.title.trim().length > 0 ? input.title : typeof input.brief === "string" && input.brief.trim().length > 0 ? input.brief : task.taskType, 60) || "task";
+		if (task.correlationId) return `moltnet/${task.correlationId}/${slug}`;
+		return `feat/${(typeof input.scopeHint === "string" && input.scopeHint.trim().length > 0 ? slugifyAsciiLower(input.scopeHint, 60) : "task") || "task"}-${slug}`;
+	}
+	return `task/${slugifyAsciiLower(task.taskType, 60) || "task"}-${task.id.slice(0, 8)}`;
+}
+function resolveTaskWorkspaceId(task, executionPlan) {
+	if (executionPlan.workspaceScope === "session" && executionPlan.sessionKey !== null) return `session-${encodeURIComponent(executionPlan.sessionKey)}`;
+	return `task-${task.id}`;
+}
+//#endregion
+//#region src/lib/execution-plan-cache.ts
+function createExecutionPlanCache(args) {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		getOrCreate(claimedTask) {
+			const key = buildClaimedTaskKey(claimedTask);
+			const existing = cache.get(key);
+			if (existing) return existing;
+			const plan = buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec);
+			cache.set(key, plan);
+			return plan;
+		},
+		delete(claimedTask) {
+			cache.delete(buildClaimedTaskKey(claimedTask));
+		}
+	};
+}
+function buildClaimedTaskKey(task) {
+	return `${task.task.id}:${task.attemptN}`;
+}
+//#endregion
 //#region src/lib/finalize.ts
 async function finalizeTask(agent, output, ctx = {}) {
 	if (output.status === "cancelled") return;
@@ -16841,7 +17336,8 @@ var DEFAULTS = {
 	maxBatchSize: 50,
 	flushIntervalMs: 200,
 	maxTurns: 0,
-	maxBashTimeouts: 3
+	maxBashTimeouts: 3,
+	warmSessionTtlSec: 1800
 };
 var MissingRequiredOptionError = class extends Error {
 	constructor(flag) {
@@ -16865,6 +17361,7 @@ function parseCommonOptions(args) {
 		flushIntervalMs: parseNonNegativeInt(args["flush-interval-ms"], "flush-interval-ms", DEFAULTS.flushIntervalMs),
 		maxTurns: parseNonNegativeInt(args["max-turns"], "max-turns", DEFAULTS.maxTurns),
 		maxBashTimeouts: parseNonNegativeInt(args["max-bash-timeouts"], "max-bash-timeouts", DEFAULTS.maxBashTimeouts),
+		warmSessionTtlSec: parseNonNegativeInt(args["warm-session-ttl-sec"], "warm-session-ttl-sec", DEFAULTS.warmSessionTtlSec),
 		debug: args.debug === true
 	};
 }
@@ -16900,6 +17397,7 @@ function commonOptionDefs() {
 		"flush-interval-ms": { type: "string" },
 		"max-turns": { type: "string" },
 		"max-bash-timeouts": { type: "string" },
+		"warm-session-ttl-sec": { type: "string" },
 		debug: { type: "boolean" }
 	};
 }
@@ -16982,6 +17480,18 @@ function findUp(startDir, filename) {
 	}
 }
 //#endregion
+//#region src/lib/state-dir.ts
+function ensureDaemonStateDirs(mountPath) {
+	const rootDir = join(mountPath, ".moltnet", "d");
+	const piSessionsDir = join(rootDir, "pi-sessions");
+	mkdirSync(piSessionsDir, { recursive: true });
+	return {
+		rootDir,
+		piSessionsDir,
+		registryDbPath: join(rootDir, "daemon-state.sqlite")
+	};
+}
+//#endregion
 //#region src/lib/turn-event-logger.ts
 function makeTurnEventHandler(base, context = {}) {
 	const log = base.child({
@@ -17053,6 +17563,19 @@ async function runPolling(opts) {
 	const listLimit = optionalPositiveInt(values["list-limit"], "list-limit", 10);
 	if (taskTypes.length === 0) console.error(`[${opts.modeLabel}] --task-types is empty — daemon will accept any registered type. Pass an explicit list to limit scope (e.g. --task-types fulfill_brief).`);
 	const sandbox = resolveSandbox(process.cwd(), values.sandbox);
+	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
+	const slotRegistry = new DaemonSlotRegistry(stateDirs.registryDbPath);
+	const slotIdentity = {
+		agentName: common.agent,
+		provider: common.provider,
+		model: common.model
+	};
+	const mainRepo = findMainWorktree();
+	const executionPlans = createExecutionPlanCache({
+		stateDirs,
+		slotIdentity,
+		warmSessionTtlSec: common.warmSessionTtlSec
+	});
 	const ctx = await resolveAgentContext(common.agent);
 	const cfg = loadConfig();
 	const otelShutdown = await initWorkerOtel({
@@ -17103,6 +17626,7 @@ async function runPolling(opts) {
 			provider: common.provider,
 			model: common.model,
 			sandboxConfig: sandbox.config,
+			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			makeOnTurnEvent: makeTurnEventHandlerFactory(rootLogger),
 			maxTurns: common.maxTurns,
 			maxBashTimeouts: common.maxBashTimeouts
@@ -17141,6 +17665,26 @@ async function runPolling(opts) {
 				log: (msg, err) => rootLogger.warn({ err }, msg)
 			}),
 			executeTask: async (claimedTask, reporter) => {
+				const executionPlan = executionPlans.getOrCreate(claimedTask);
+				const sessionDescriptor = executionPlan.descriptor;
+				const expired = slotRegistry.reapExpiredSlots();
+				if (expired.length > 0) rootLogger.info({
+					expiredCount: expired.length,
+					slotKeys: expired.map((item) => item.slot.slotKey)
+				}, "agent-daemon.daemon_slots_reaped");
+				rootLogger.debug({
+					taskId: claimedTask.task.id,
+					taskType: claimedTask.task.taskType,
+					resumable: sessionDescriptor.policy.resumable,
+					workspaceMode: sessionDescriptor.policy.workspaceMode,
+					workspaceScope: sessionDescriptor.policy.workspaceScope,
+					sessionScope: sessionDescriptor.policy.sessionScope,
+					slotKey: executionPlan.slotKey,
+					slotId: executionPlan.slotId,
+					sessionKey: executionPlan.sessionKey,
+					piSessionDir: executionPlan.sessionPersistence?.sessionDir ?? null,
+					workspaceId: executionPlan.workspaceId
+				}, "agent-daemon.task_execution_policy");
 				if (taskTypes.length > 0 && !taskTypes.includes(claimedTask.task.taskType)) return {
 					taskId: claimedTask.task.id,
 					attemptN: claimedTask.attemptN,
@@ -17175,7 +17719,25 @@ async function runPolling(opts) {
 						retryable: false
 					}
 				};
-				return executeTask(claimedTask, reporter);
+				if (executionPlan.slotKey && executionPlan.sessionPersistence) slotRegistry.beginSlot({
+					...slotIdentity,
+					slotKey: executionPlan.slotKey,
+					taskType: claimedTask.task.taskType,
+					sessionDir: executionPlan.sessionPersistence.sessionDir,
+					sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
+					workspaceId: executionPlan.workspaceId,
+					worktreePath: executionPlan.workspaceId ? resolveTaskWorktreePath(mainRepo, executionPlan.workspaceId) : null,
+					worktreeBranch: executionPlan.worktreeBranch,
+					lastTaskId: claimedTask.task.id,
+					lastAttemptN: claimedTask.attemptN,
+					ttlSec: common.warmSessionTtlSec
+				});
+				try {
+					return await executeTask(claimedTask, reporter);
+				} finally {
+					executionPlans.delete(claimedTask);
+					if (executionPlan.slotKey) slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, common.warmSessionTtlSec, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+				}
 			}
 		});
 		const drained = await runtime.start();
@@ -17183,6 +17745,7 @@ async function runPolling(opts) {
 		rootLogger.info({ processed: drained.length }, "agent-daemon.drained");
 		return drained.some((o) => o.status !== "completed") ? 1 : 0;
 	} finally {
+		slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();
 	}
@@ -17243,6 +17806,19 @@ async function runOnce(argv) {
 		throw err;
 	}
 	const sandbox = resolveSandbox(process.cwd(), values.sandbox);
+	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
+	const slotRegistry = new DaemonSlotRegistry(stateDirs.registryDbPath);
+	const slotIdentity = {
+		agentName: opts.agent,
+		provider: opts.provider,
+		model: opts.model
+	};
+	const mainRepo = findMainWorktree();
+	const executionPlans = createExecutionPlanCache({
+		stateDirs,
+		slotIdentity,
+		warmSessionTtlSec: opts.warmSessionTtlSec
+	});
 	const ctx = await resolveAgentContext(opts.agent);
 	const cfg = loadConfig();
 	const otelShutdown = await initWorkerOtel({
@@ -17291,16 +17867,44 @@ async function runOnce(argv) {
 		onSignal("SIGTERM");
 	});
 	try {
-		const executeTask = createPiTaskExecutor({
+		const rawExecuteTask = createPiTaskExecutor({
 			agentName: opts.agent,
 			mountPath: sandbox.rootDir,
 			provider: opts.provider,
 			model: opts.model,
 			sandboxConfig: sandbox.config,
+			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
 			maxTurns: opts.maxTurns,
 			maxBashTimeouts: opts.maxBashTimeouts
 		});
+		const executeTask = async (claimedTask, reporter) => {
+			const expired = slotRegistry.reapExpiredSlots();
+			if (expired.length > 0) rootLogger.info({
+				expiredCount: expired.length,
+				slotKeys: expired.map((item) => item.slot.slotKey)
+			}, "agent-daemon.daemon_slots_reaped");
+			const executionPlan = executionPlans.getOrCreate(claimedTask);
+			if (executionPlan.slotKey && executionPlan.sessionPersistence) slotRegistry.beginSlot({
+				...slotIdentity,
+				slotKey: executionPlan.slotKey,
+				taskType: claimedTask.task.taskType,
+				sessionDir: executionPlan.sessionPersistence.sessionDir,
+				sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
+				workspaceId: executionPlan.workspaceId,
+				worktreePath: executionPlan.workspaceId ? resolveTaskWorktreePath(mainRepo, executionPlan.workspaceId) : null,
+				worktreeBranch: executionPlan.worktreeBranch,
+				lastTaskId: claimedTask.task.id,
+				lastAttemptN: claimedTask.attemptN,
+				ttlSec: opts.warmSessionTtlSec
+			});
+			try {
+				return await rawExecuteTask(claimedTask, reporter);
+			} finally {
+				executionPlans.delete(claimedTask);
+				if (executionPlan.slotKey) slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, opts.warmSessionTtlSec, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+			}
+		};
 		const writeCorrelationAnchors = makePrBodyAnchorWriter({
 			gh: createGhCliClient(),
 			logger: rootLogger
@@ -17335,6 +17939,7 @@ async function runOnce(argv) {
 		console.log(JSON.stringify(output, null, 2));
 		return output.status === "completed" ? 0 : 1;
 	} finally {
+		slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "description": "MoltNet agent daemon — claims and executes tasks (fulfill_brief, assess_brief) from the MoltNet task-service via Pi-headless. CLI: moltnet-agent.",
@@ -33,19 +33,19 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
+    "@themoltnet/pi-extension": "0.17.0",
     "@themoltnet/agent-runtime": "0.15.1",
-    "@themoltnet/sdk": "0.102.0",
-    "@themoltnet/pi-extension": "0.16.2"
+    "@themoltnet/sdk": "0.102.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "vite": "^8.0.0",
     "vitest": "^3.0.0",
-    "@moltnet/crypto-service": "0.1.0",
     "@moltnet/bootstrap": "0.1.0",
     "@moltnet/database": "0.1.0",
-    "@moltnet/tasks": "0.1.0"
+    "@moltnet/tasks": "0.1.0",
+    "@moltnet/crypto-service": "0.1.0"
   },
   "nx": {
     "tags": [