@themoltnet/agent-daemon 0.6.2 → 0.8.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";
@@ -3044,10 +3045,10 @@ function validateRubricWeights(rubric) {
 * complementary places.
 *
 * Before this envelope existed, criteria were scattered: a vestigial
-* `criteriaCid` column nobody resolved, an `acceptanceCriteria: string[]`
-* field on `fulfill_brief.input` that was "interpreted by the claiming
-* agent," and inline `rubric` / `criteria[]` fields on judgment-task
-* inputs. None of those were machine-verifiable end-to-end.
+* `criteriaCid` column nobody resolved, free-form prose on
+* `fulfill_brief.input`, and inline `rubric` / `criteria[]` fields on
+* judgment-task inputs. None of those were machine-verifiable
+* end-to-end.
 *
 * This module defines a single, content-addressable envelope an imposer
 * attaches to any task type. It has four orthogonal sections — pick
@@ -4184,7 +4185,6 @@ var FULFILL_BRIEF_TYPE = "fulfill_brief";
 var FulfillBriefInput = Type$2.Object({
 	brief: Type$2.String({ minLength: 1 }),
 	title: Type$2.Optional(Type$2.String()),
-	acceptanceCriteria: Type$2.Optional(Type$2.Array(Type$2.String())),
 	successCriteria: Type$2.Optional(SuccessCriteria),
 	seedFiles: Type$2.Optional(Type$2.Array(Type$2.String())),
 	scopeHint: Type$2.Optional(Type$2.String())
@@ -4756,7 +4756,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 +4769,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 +4780,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: CuratePackInput,
 		outputSchema: CuratePackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -4783,6 +4790,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RenderPackInput,
 		outputSchema: RenderPackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent,
 		validateInputAsync: validateRenderPackInputAsync
@@ -4792,6 +4801,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgePackInput,
 		outputSchema: JudgePackOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateOutput: validateJudgePackOutput,
@@ -4802,6 +4813,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RunEvalInput,
 		outputSchema: RunEvalOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateOutput: validateRunEvalOutput
 	},
@@ -4810,6 +4823,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgeEvalVariantInput,
 		outputSchema: JudgeEvalVariantOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateInput: validateJudgeEvalVariantInput,
 		validateOutput: validateJudgeEvalVariantOutput,
@@ -5732,6 +5747,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 +6052,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();
@@ -6106,78 +6168,6 @@ function isHelpFlag(args) {
 	return args.includes("--help") || args.includes("-h");
 }
 //#endregion
-//#region ../../libs/agent-runtime/src/subagent-output-contracts.ts
-var REGISTRY = /* @__PURE__ */ new Map();
-/**
-* Register a subagent output contract. Idempotent: re-registering the
-* same name with a different schema throws — contracts are meant to
-* be stable. Re-registering with the identical contract object (same
-* reference) is a no-op for HMR and test convenience.
-*
-* Typically called at module-init time alongside task-type
-* registration. See task-types/index.ts in @moltnet/tasks for the
-* conventional pattern.
-*/
-function registerSubagentOutputContract(contract) {
-	if (!contract.name || contract.name.trim().length === 0) throw new Error("subagent output contract name is required");
-	if (!/^[a-z][a-z0-9_]*$/.test(contract.name)) throw new Error(`subagent output contract name '${contract.name}' must be lower_snake_case (starts with a letter, then [a-z0-9_]+)`);
-	const existing = REGISTRY.get(contract.name);
-	if (existing && existing !== contract) {
-		if (existing.parametersSchema !== contract.parametersSchema) throw new Error(`subagent output contract '${contract.name}' is already registered with a different schema; refusing to override`);
-	}
-	REGISTRY.set(contract.name, contract);
-}
-/**
-* Resolve a subagent output contract by name. Returns `null` for
-* unknown names — callers (the subagent custom tool) decide whether
-* that's a tool error the parent LLM can recover from or a hard fail.
-*/
-function getSubagentOutputContract(name) {
-	return REGISTRY.get(name) ?? null;
-}
-/**
-* List all registered contracts. Useful for diagnostics and for the
-* subagent tool's parameter description so a parent LLM can see what
-* contracts are available without enumerating them in its prompt.
-*/
-function listSubagentOutputContracts() {
-	return [...REGISTRY.values()];
-}
-//#endregion
-//#region ../../libs/agent-runtime/src/built-in-contract-registrations.ts
-/**
-* Built-in subagent output contracts (#1087, #943).
-*
-* Why this is an exported function and not a module-init side
-* effect:
-*
-*   - The registry is process-global. Module-init registration
-*     fires exactly once per Node process (ESM modules are cached
-*     by URL). Tests that call `__resetSubagentOutputContractsForTests()`
-*     to start from an empty registry have no way to repopulate
-*     the built-ins without re-evaluating the module — which the
-*     cache prevents. PR #1101 review M4.
-*   - An explicit `registerBuiltInSubagentContracts()` lets the
-*     package index call it once at module load AND lets test
-*     setup hooks call it again after `__reset...`.
-*   - `registerSubagentOutputContract` is itself idempotent for
-*     identical re-registrations, so calling this function twice
-*     in the same process is safe.
-*
-* Adding a new built-in: extend the body of this function. Do not
-* call `registerSubagentOutputContract` from anywhere else in the
-* package — keeping all built-ins in one function makes the set
-* auditable.
-*/
-function registerBuiltInSubagentContracts() {
-	registerSubagentOutputContract({
-		name: "judge_eval_variant_result",
-		description: "Per-variant grading result produced by a subagent of judge_eval_variant: scores against the shared rubric, composite, and a 1-3 sentence verdict for a single variant.",
-		parametersSchema: JudgeEvalVariantResult
-	});
-}
-registerBuiltInSubagentContracts();
-//#endregion
 //#region ../../libs/agent-runtime/src/context-bindings.ts
 var PROMPT_SEPARATOR = "\n\n---\n\n";
 /**
@@ -6637,13 +6627,7 @@ function buildCuratePackUserPrompt(input, ctx) {
 * is told to inspect them itself.
 */
 function buildFulfillBriefUserPrompt(input, ctx) {
-	const { brief, title, acceptanceCriteria, seedFiles, scopeHint } = input;
-	const criteriaSection = acceptanceCriteria?.length ? [
-		"### Acceptance criteria",
-		"",
-		...acceptanceCriteria.map((c) => `- ${c}`),
-		""
-	].join("\n") : "";
+	const { brief, title, seedFiles, scopeHint } = input;
 	const seedSection = seedFiles?.length ? [
 		"### Seed files",
 		"",
@@ -6691,7 +6675,6 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 		"",
 		brief,
 		"",
-		criteriaSection,
 		seedSection,
 		correlationSection,
 		workspaceSection,
@@ -13853,6 +13836,31 @@ function abortableSleep(ms, signal) {
 	});
 }
 //#endregion
+//#region ../../libs/agent-runtime/src/subagent-output-contracts.ts
+/**
+* Construct an immutable contract registry from a static list.
+*
+* The resulting registry is safe to share across sessions and
+* invocations — no mutation is possible after construction.
+*/
+function createSubagentContractRegistry(contracts) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const c of contracts) {
+		if (!c.name || c.name.trim().length === 0) throw new Error("subagent output contract name is required");
+		if (!/^[a-z][a-z0-9_]*$/.test(c.name)) throw new Error(`subagent output contract name '${c.name}' must be lower_snake_case (starts with a letter, then [a-z0-9_]+)`);
+		if (lookup.has(c.name)) throw new Error(`duplicate subagent output contract name '${c.name}' in constructor args`);
+		lookup.set(c.name, c);
+	}
+	return {
+		get(name) {
+			return lookup.get(name) ?? null;
+		},
+		list() {
+			return [...lookup.values()];
+		}
+	};
+}
+//#endregion
 //#region ../../libs/pi-extension/src/moltnet/render-phase6.ts
 function slugToTitle(value) {
 	return value.split(/[:/_-]+/).filter(Boolean).map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" ");
@@ -14829,7 +14837,8 @@ function findMainWorktree() {
 function loadCredentials(agentDir) {
 	const moltnetJson = readFileSync(path.join(agentDir, "moltnet.json"), "utf8");
 	const agentEnvRaw = readFileSync(path.join(agentDir, "env"), "utf8");
-	const piAuthPath = process.env.PI_AUTH_PATH ?? path.join(process.env.HOME ?? "", ".pi", "agent", "auth.json");
+	const piAgentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(process.env.HOME ?? "", ".pi", "agent");
+	const piAuthPath = path.join(piAgentDir, "auth.json");
 	const piAuthJson = existsSync(piAuthPath) ? readFileSync(piAuthPath, "utf8") : null;
 	const gitconfigPath = path.join(agentDir, "gitconfig");
 	const gitconfig = existsSync(gitconfigPath) ? readFileSync(gitconfigPath, "utf8") : null;
@@ -15329,9 +15338,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({
@@ -15339,22 +15350,30 @@ async function buildAgentSession(args) {
 		spanAttributes: args.otelSpanAttrs
 	});
 	const resourceLoader = new DefaultResourceLoader({
-		cwd: args.mountPath,
+		cwd: args.cwdPath,
 		agentDir: args.piAuthDir,
 		extensionFactories: [piOtelExtension],
 		appendSystemPrompt: args.appendSystemPrompt,
 		skillsOverride: args.skillsOverride ?? NO_SKILLS
 	});
 	await resourceLoader.reload();
+	const sessionManager = args.sessionPersistence ? await resolvePersistentSessionManager({
+		cwd: args.cwdPath,
+		sessionDir: args.sessionPersistence.sessionDir
+	}) : SessionManager.inMemory(args.cwdPath);
 	return (await createAgentSession({
 		agentDir: args.piAuthDir,
-		cwd: args.mountPath,
+		cwd: args.cwdPath,
 		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
 /**
@@ -15589,6 +15608,7 @@ var DEFAULT_SUBAGENT_TIMEOUT_MS = 300 * 1e3;
 */
 function createSubagentTool(args) {
 	const buildSession = args.buildAgentSession ?? buildAgentSession;
+	const { contractRegistry } = args;
 	let callCount = 0;
 	return {
 		tool: defineTool({
@@ -15599,8 +15619,8 @@ function createSubagentTool(args) {
 			async execute(_id, params) {
 				if (!Check(SubagentToolParameters, params)) return toolError(`subagent: invalid parameters: ${JSON.stringify([...Errors(SubagentToolParameters, params)].slice(0, 3))}`);
 				const { task, output_schema } = params;
-				const contract = getSubagentOutputContract(output_schema);
-				if (!contract) return toolError(`subagent: unknown output_schema "${output_schema}". Registered contracts: [${listSubagentOutputContracts().map((c) => c.name).join(", ")}]`);
+				const contract = contractRegistry.get(output_schema);
+				if (!contract) return toolError(`subagent: unknown output_schema "${output_schema}". Registered contracts: [${contractRegistry.list().map((c) => c.name).join(", ")}]`);
 				callCount += 1;
 				const callIndex = callCount;
 				let captured = null;
@@ -15630,6 +15650,7 @@ function createSubagentTool(args) {
 				});
 				const session = await buildSession({
 					mountPath: args.mountPath,
+					cwdPath: args.cwdPath ?? args.mountPath,
 					piAuthDir: args.piAuthDir,
 					modelHandle: args.modelHandle,
 					agentName: args.agentName,
@@ -15965,6 +15986,115 @@ 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,
+		cwdPath: 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 cwdPath = 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: mainRepo,
+		cwdPath,
+		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
@@ -15991,15 +16121,24 @@ var noopTurnEventHandler = () => {};
 function createPiTaskExecutor(opts) {
 	let cachedCheckpoint = opts.checkpointPath ?? null;
 	return async (claimedTask, reporter) => {
-		if (!cachedCheckpoint) cachedCheckpoint = await ensureSnapshot({
-			config: opts.sandboxConfig?.snapshot,
-			onProgress: opts.onSnapshotProgress ?? ((m) => {
-				process.stderr.write(`[snapshot] ${m}\n`);
-			})
+		const reporterWasOpened = !reporter.cancelSignal.aborted;
+		if (reporterWasOpened) await reporter.open({
+			taskId: claimedTask.task.id,
+			attemptN: claimedTask.attemptN
 		});
 		return executePiTask(claimedTask, reporter, {
 			...opts,
-			checkpointPath: cachedCheckpoint
+			checkpointPath: cachedCheckpoint ?? void 0,
+			resolveCheckpointPath: async () => {
+				if (!cachedCheckpoint) cachedCheckpoint = await ensureSnapshot({
+					config: opts.sandboxConfig?.snapshot,
+					onProgress: opts.onSnapshotProgress ?? ((m) => {
+						process.stderr.write(`[snapshot] ${m}\n`);
+					})
+				});
+				return cachedCheckpoint;
+			},
+			reporterAlreadyOpened: reporterWasOpened
 		});
 	};
 }
@@ -16013,8 +16152,11 @@ 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 mountPath = workspace.mountPath;
+	const requestedMountPath = opts.mountPath ?? process.cwd();
+	const executionPlan = opts.makeExecutionPlan?.(claimedTask) ?? null;
+	let workspace = null;
+	let mountPath = requestedMountPath;
+	let cwdPath = requestedMountPath;
 	if (reporter.cancelSignal.aborted) return {
 		taskId: task.id,
 		attemptN,
@@ -16029,33 +16171,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 			retryable: false
 		}
 	};
-	const checkpointPath = opts.checkpointPath ?? await ensureSnapshot({
-		config: opts.sandboxConfig?.snapshot,
-		onProgress: opts.onSnapshotProgress ?? ((m) => {
-			process.stderr.write(`[snapshot] ${m}\n`);
-		})
-	});
-	const mainRepoForRepair = findMainWorktree();
-	try {
-		execFileSync("git", [
-			"-C",
-			mainRepoForRepair,
-			"worktree",
-			"repair",
-			"--relative-paths"
-		], { stdio: "pipe" });
-	} catch {}
+	let reporterOpen = opts.reporterAlreadyOpened ?? false;
 	let managed = null;
-	managed = await resumeVm({
-		checkpointPath,
-		agentName: opts.agentName,
-		mountPath,
-		extraAllowedHosts: opts.extraAllowedHosts,
-		sandboxConfig: opts.sandboxConfig
-	});
-	const diaryId = task.diaryId ?? "";
-	const taskTeamId = task.teamId ?? "";
-	let reporterOpen = false;
 	let session = null;
 	let subagentHandle = null;
 	const finalUsage = emptyUsage(opts.provider, opts.model);
@@ -16074,41 +16191,103 @@ async function executePiTask(claimedTask, reporter, opts) {
 			retryable: false
 		}
 	});
+	let onTurnEvent;
+	if (opts.makeOnTurnEvent) try {
+		onTurnEvent = opts.makeOnTurnEvent(claimedTask);
+	} catch (err) {
+		process.stderr.write(`[emit] makeOnTurnEvent threw: ${err instanceof Error ? err.message : String(err)}\n`);
+		onTurnEvent = noopTurnEventHandler;
+	}
+	else onTurnEvent = opts.onTurnEvent ?? noopTurnEventHandler;
+	const emit = (kind, payload) => {
+		try {
+			onTurnEvent(kind, summarizePayloadForLog(kind, payload));
+		} catch (err) {
+			process.stderr.write(`[emit] onTurnEvent threw for kind="${kind}": ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+		return reporter.record({
+			kind,
+			payload
+		});
+	};
+	const emitError = async (phase, message, extra = {}) => {
+		await emit("error", {
+			phase,
+			message,
+			...extra
+		});
+	};
 	try {
-		const mainRepo = findMainWorktree();
-		activateAgentEnv(managed.credentials.agentEnv, mainRepo);
-		await reporter.open({
+		if (!opts.reporterAlreadyOpened) await reporter.open({
 			taskId: task.id,
 			attemptN
 		});
 		reporterOpen = true;
-		let onTurnEvent;
-		if (opts.makeOnTurnEvent) try {
-			onTurnEvent = opts.makeOnTurnEvent(claimedTask);
+		let checkpointPath;
+		try {
+			checkpointPath = opts.checkpointPath ?? (opts.resolveCheckpointPath ? await opts.resolveCheckpointPath() : await ensureSnapshot({
+				config: opts.sandboxConfig?.snapshot,
+				onProgress: opts.onSnapshotProgress ?? ((m) => {
+					process.stderr.write(`[snapshot] ${m}\n`);
+				})
+			}));
 		} catch (err) {
-			process.stderr.write(`[emit] makeOnTurnEvent threw: ${err instanceof Error ? err.message : String(err)}\n`);
-			onTurnEvent = noopTurnEventHandler;
+			const message = err instanceof Error ? err.message : String(err);
+			await emitError("snapshot", message);
+			return makeFailedOutput("snapshot_failed", message);
 		}
-		else onTurnEvent = opts.onTurnEvent ?? noopTurnEventHandler;
-		const emit = (kind, payload) => {
+		try {
+			workspace = prepareTaskWorkspace(task, requestedMountPath, executionPlan);
+			mountPath = workspace.mountPath;
+			cwdPath = workspace.cwdPath;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await emitError("worktree_setup", message);
+			return makeFailedOutput("worktree_setup_failed", message);
+		}
+		try {
+			const mainRepoForRepair = findMainWorktree();
 			try {
-				onTurnEvent(kind, summarizePayloadForLog(kind, payload));
-			} catch (err) {
-				process.stderr.write(`[emit] onTurnEvent threw for kind="${kind}": ${err instanceof Error ? err.message : String(err)}\n`);
-			}
-			return reporter.record({
-				kind,
-				payload
+				execFileSync("git", [
+					"-C",
+					mainRepoForRepair,
+					"worktree",
+					"repair",
+					"--relative-paths"
+				], { stdio: "pipe" });
+			} catch {}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await emitError("worktree_setup", message);
+			return makeFailedOutput("worktree_setup_failed", message);
+		}
+		try {
+			managed = await resumeVm({
+				checkpointPath,
+				agentName: opts.agentName,
+				mountPath,
+				extraAllowedHosts: opts.extraAllowedHosts,
+				sandboxConfig: opts.sandboxConfig
 			});
-		};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await emitError("vm_resume", message);
+			return makeFailedOutput("vm_resume_failed", message);
+		}
+		const diaryId = task.diaryId ?? "";
+		const taskTeamId = task.teamId ?? "";
+		const mainRepo = findMainWorktree();
+		activateAgentEnv(managed.credentials.agentEnv, mainRepo);
+		const activeWorkspace = workspace;
+		if (!activeWorkspace) throw new Error("task workspace not prepared");
 		await emit("info", {
 			event: "execute_start",
 			taskType: task.taskType,
 			teamId: task.teamId,
 			provider: opts.provider,
 			model: opts.model,
-			workspaceMode: workspace.mode,
-			workspaceBranch: workspace.branch
+			workspaceMode: activeWorkspace.mode,
+			workspaceBranch: activeWorkspace.branch
 		});
 		let taskPrompt;
 		try {
@@ -16116,8 +16295,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 				diaryId,
 				taskId: task.id,
 				workspace: {
-					mode: workspace.mode,
-					branch: workspace.branch
+					mode: activeWorkspace.mode,
+					branch: activeWorkspace.branch
 				},
 				extras: opts.promptExtras
 			});
@@ -16169,7 +16348,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 				getTeamId: () => taskTeamId,
 				getSessionErrors: () => [],
 				clearSessionErrors: () => {},
-				getHostCwd: () => mountPath,
+				getHostCwd: () => cwdPath,
 				hostExecBaseEnv: new Set([...HOST_EXEC_DEFAULT_BASE_ENV, ...Object.keys(managed.credentials.agentEnv)]),
 				hostExecAutoApprove: opts.hostExecAutoApprove ?? opts.sandboxConfig?.hostExec?.autoApprove ?? false,
 				getTaskContext: () => ({
@@ -16197,6 +16376,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 			if (taskTypeUsesSubagents(task.taskType)) {
 				subagentHandle = createSubagentTool({
 					mountPath,
+					cwdPath,
 					piAuthDir,
 					modelHandle,
 					agentName: opts.agentName,
@@ -16205,12 +16385,14 @@ async function executePiTask(claimedTask, reporter, opts) {
 					parentTaskId: task.id,
 					parentTaskType: task.taskType,
 					parentAttemptN: attemptN,
+					contractRegistry: opts.subagentContractRegistry,
 					parentCancelSignal: reporter.cancelSignal
 				});
 				parentSubagentTools.push(subagentHandle.tool);
 			}
 			session = await buildAgentSession({
 				mountPath,
+				cwdPath,
 				piAuthDir,
 				modelHandle,
 				agentName: opts.agentName,
@@ -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);
@@ -16294,6 +16477,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 					is_error: event.isError,
 					result: event.isError ? truncateForWire(event.result) : void 0
 				}));
+				if (event.isError) track(emitError("tool_call_error", describeToolErrorMessage(event.result), {
+					tool: event.toolName,
+					result: truncateForWire(event.result)
+				}));
 				if (maxBashTimeouts > 0 && event.toolName === "bash" && event.isError && isBashTimeoutResult(event.result)) {
 					bashTimeoutCount += 1;
 					if (bashTimeoutCount >= maxBashTimeouts) triggerCapAbort("max_bash_timeouts_exceeded", `Aborted after ${bashTimeoutCount} bash timeouts in this attempt (cap ${maxBashTimeouts}).`);
@@ -16449,7 +16636,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 			}
 		}
 		if (managed) await managed.vm.close();
-		try {
+		if (workspace) try {
 			workspace.cleanup();
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
@@ -16457,107 +16644,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,
@@ -16661,6 +16747,23 @@ function truncateForWire(value) {
 		};
 	}
 }
+function describeToolErrorMessage(result) {
+	if (typeof result === "string" && result.trim().length > 0) return result.trim();
+	if (result && typeof result === "object") {
+		const content = result.content;
+		if (Array.isArray(content)) {
+			for (const item of content) if (item && typeof item === "object" && typeof item.text === "string") {
+				const text = item.text.trim();
+				if (text.length > 0) return text;
+			}
+		}
+	}
+	try {
+		return JSON.stringify(truncateForWire(result));
+	} catch {
+		return "Tool call failed";
+	}
+}
 //#endregion
 //#region src/config.ts
 function loadConfig() {
@@ -16757,6 +16860,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 +17357,8 @@ var DEFAULTS = {
 	maxBatchSize: 50,
 	flushIntervalMs: 200,
 	maxTurns: 0,
-	maxBashTimeouts: 3
+	maxBashTimeouts: 3,
+	warmSessionTtlSec: 1800
 };
 var MissingRequiredOptionError = class extends Error {
 	constructor(flag) {
@@ -16865,6 +17382,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 +17418,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 +17501,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 +17584,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({
@@ -17096,13 +17640,20 @@ async function runPolling(opts) {
 		maxPollIntervalMs
 	}, "agent-daemon.starting");
 	const outputs = [];
+	const subagentContractRegistry = createSubagentContractRegistry([{
+		name: "judge_eval_variant_result",
+		description: "Per-variant grading result produced by a subagent of judge_eval_variant: scores against the shared rubric, composite, and a 1-3 sentence verdict for a single variant.",
+		parametersSchema: JudgeEvalVariantResult
+	}]);
 	try {
 		const executeTask = createPiTaskExecutor({
 			agentName: common.agent,
+			subagentContractRegistry,
 			mountPath: sandbox.rootDir,
 			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 +17692,34 @@ async function runPolling(opts) {
 				log: (msg, err) => rootLogger.warn({ err }, msg)
 			}),
 			executeTask: async (claimedTask, reporter) => {
+				const executionPlan = executionPlans.getOrCreate(claimedTask);
+				const sessionDescriptor = executionPlan.descriptor;
+				let expired;
+				try {
+					expired = slotRegistry.reapExpiredSlots();
+					if (expired.length > 0) rootLogger.info({
+						expiredCount: expired.length,
+						slotKeys: expired.map((item) => item.slot.slotKey)
+					}, "agent-daemon.daemon_slots_reaped");
+				} catch (err) {
+					rootLogger.error({
+						phase: "daemon_slot_reap",
+						err: err instanceof Error ? err.message : String(err)
+					}, "agent-daemon.daemon_slot_reap_failed");
+				}
+				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 +17754,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 +17780,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 +17841,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({
@@ -17290,17 +17901,58 @@ async function runOnce(argv) {
 	process.on("SIGTERM", () => {
 		onSignal("SIGTERM");
 	});
+	const subagentContractRegistry = createSubagentContractRegistry([{
+		name: "judge_eval_variant_result",
+		description: "Per-variant grading result produced by a subagent of judge_eval_variant: scores against the shared rubric, composite, and a 1-3 sentence verdict for a single variant.",
+		parametersSchema: JudgeEvalVariantResult
+	}]);
 	try {
-		const executeTask = createPiTaskExecutor({
+		const rawExecuteTask = createPiTaskExecutor({
 			agentName: opts.agent,
+			subagentContractRegistry,
 			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) => {
+			try {
+				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");
+			} catch (err) {
+				rootLogger.error({
+					phase: "daemon_slot_reap",
+					err: err instanceof Error ? err.message : String(err)
+				}, "agent-daemon.daemon_slot_reap_failed");
+			}
+			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 +17987,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();
 	}