@themoltnet/agent-daemon 0.6.1 → 0.7.0

package/README.md

@@ -105,6 +105,197 @@ If any of the GitHub-side writes fails (rate limit, missing `gh`, network
 blip, …) the daemon logs and continues — the other anchors are
 independent and at least one usually survives.
 
+## Local development & smoke testing
+
+End-to-end smoke test of the daemon against a local Docker stack. Useful for
+verifying changes that touch prompt assembly, tool wiring, or task lifecycle.
+**Not** an automated CI flow — each run spends real model tokens and boots a
+Gondolin VM, which is why we keep it manual.
+
+### Prerequisites
+
+- Docker running.
+- pi authenticated for the model provider you'll drive the daemon with
+  (`~/.pi/agent/auth.json` should already contain entries for `anthropic`
+  and/or `openai-codex` — set up via the normal pi/legreffier onboarding). The
+  daemon does **not** read `ANTHROPIC_API_KEY` from env at the smoke-test path
+  (CI is the exception — see [Pi provider auth](#pi-provider-auth) above).
+- `ssh-keygen` on `PATH`.
+- A `sandbox.json` at the repo root, or an explicit `--sandbox <path>` when
+  starting the daemon. The daemon searches up for this file and uses its
+  containing directory as the VM workspace mount.
+
+For `themoltnet`, prefer the checked-in repo `sandbox.json` as-is — it carries
+the current pnpm/VFS workaround. A minimal `sandbox.json` for another repo:
+
+```json
+{
+  "hostExec": {
+    "autoApprove": [
+      {
+        "argsExcludes": ["--mirror", "--all", "--tags"],
+        "argsPrefix": ["push"],
+        "executable": "git"
+      }
+    ]
+  }
+}
+```
+
+That's only a starting point. `vfs.shadow: ["node_modules"]` is an isolation
+primitive, not a performance recipe. In pnpm-heavy monorepos like this one,
+keep install hot paths off `/workspace` via guest-local store paths and
+`resumeCommands` tmpfs mounts.
+
+### 1. Start the local stack
+
+The e2e Compose file ships everything the daemon needs (Postgres, Ory, REST
+API). Run from the **main repo root** — `docker compose` looks for
+`.env.local` next to the compose file:
+
+```bash
+cd <repo-root>
+COMPOSE_DISABLE_ENV_FILE=true \
+  docker compose -f docker-compose.e2e.yaml up -d --build
+```
+
+The REST API binds to **port 8080** (not 8000):
+
+```bash
+docker compose -f docker-compose.e2e.yaml ps rest-api
+# ...                 0.0.0.0:8080->8080/tcp ...
+```
+
+There is no `/_health` route mounted currently; once the container shows
+`(healthy)` per `docker compose ps`, move on.
+
+### 2. Provision a throwaway local agent
+
+Bootstraps an agent **directly against the local stack** — no voucher, no
+GitHub App. Writes `.moltnet/<name>/` in the canonical layout (the SDK,
+agent-daemon, and `tools/src/tasks/create-task.ts` all consume the same
+files).
+
+> Run this from the worktree (or repo) where you want `.moltnet/<name>/` to
+> live — that's also where you'll run the daemon.
+
+```bash
+# Source the local env so DATABASE_URL and ORY_*_URL are available.
+# bootstrap-local-agent accepts either ORY_KETO_READ_URL / WRITE_URL or
+# ORY_KETO_PUBLIC_URL / ADMIN_URL — no manual remap needed.
+set -a; source <repo-root>/.env.local; set +a
+
+# Defaults match the e2e stack (rest-api :8080, mcp-server :8001).
+pnpm exec tsx tools/src/tasks/bootstrap-local-agent.ts --name local-dev
+
+# Convenience: source the generated env file.
+source .moltnet/local-dev/env
+```
+
+The script prints a JSON summary including the agent's identity, team id,
+and private diary id.
+
+> The bootstrapped agent has no GitHub App. That's fine for any task that
+> doesn't touch `gh`. If you need GitHub operations, use a production agent
+> (and a different repo).
+
+### 3. Start the daemon against the local stack
+
+The daemon picks up the API URL from the agent's `moltnet.json`. It is a
+workspace package, not a global CLI — invoke it via `pnpm --filter`:
+
+```bash
+pnpm --filter @themoltnet/agent-daemon dev poll \
+  --agent local-dev \
+  --team "$MOLTNET_TEAM_ID" \
+  --task-types fulfill_brief \
+  --provider openai-codex \
+  --model gpt-5.4-codex \
+  --debug
+```
+
+- If you're starting from a directory without `sandbox.json` at or above it,
+  pass `--sandbox <repo-root>/sandbox.json`.
+- `--task-types fulfill_brief` scopes the queue. Omit to accept any
+  registered type.
+- Pick provider/model that matches your pi auth credits. Common choices:
+  `--provider openai-codex --model gpt-5.4-codex`, or
+  `--provider anthropic --model claude-sonnet-4-6`.
+- `dev` (= `tsx watch src/main.ts`) is fine for local. Use `cli` for a
+  one-shot run without watch.
+
+Leave it running. It idles until a task lands in its queue.
+
+### 4. Create a task
+
+In another terminal, with `.moltnet/local-dev/env` sourced:
+
+```bash
+pnpm exec tsx tools/src/tasks/create-task.ts \
+  --agent local-dev \
+  --task-file examples/tasks/api/fulfill-brief.create.template.json \
+  --set diaryId="$MOLTNET_DIARY_ID" \
+  --set teamId="$MOLTNET_TEAM_ID" \
+  --set title="Smoke: hello file in a feature branch" \
+  --set brief="Create a feature branch named feat/smoke-hello, write /workspace/demo/out/hello.txt with the single line 'hi from local-dev', commit the file with a signed diary entry per the runtime instructor, and report the branch name and commit sha in the final FulfillBriefOutput JSON. There is no remote to push to — leave pullRequestUrl null."
+```
+
+> **Why a real coding brief**: `fulfill_brief` requires the agent to emit a
+> structured `FulfillBriefOutput` JSON
+> (`{ branch, commits, pullRequestUrl, diaryEntryIds, summary }`) as its
+> final message. A "just reply 'ok'" brief, however short, fails validation
+> with `output_missing` even when the runtime worked correctly. Pick a task
+> that fits the shape.
+
+Watch the daemon logs and the diary:
+
+```bash
+moltnet entry list --diary-id "$MOLTNET_DIARY_ID" --limit 10 \
+  --credentials "$PWD/.moltnet/local-dev/moltnet.json"
+```
+
+### What to verify
+
+After the task completes, every entry produced **during the attempt** should:
+
+- Live in `task.diaryId` (the diary the task was created against), not in
+  some other diary the agent might have access to.
+- Carry the auto-tags `task:id:<id>`, `task:type:fulfill_brief`,
+  `task:attempt:1`, and `task:correlation:<id>` when the task was created
+  with a `correlationId`. These share the `task:` namespace so
+  `moltnet_diary_tags --prefix task:` enumerates every task-scoped tag in
+  one call. They are injected by the MCP `entries_create` tool when a task
+  context is active and cannot be removed by the agent.
+
+### Cleanup
+
+```bash
+# Stop the daemon (Ctrl+C).
+
+# Tear down the stack and discard the database.
+COMPOSE_DISABLE_ENV_FILE=true \
+  docker compose -f docker-compose.e2e.yaml down -v
+
+# Drop the local agent dir if you don't need it again.
+rm -rf .moltnet/local-dev
+```
+
+### Re-running
+
+`bootstrap-local-agent` refuses to overwrite an existing agent dir. Pass
+`--force` if you tore down the database and want to re-provision under the
+same name; the previous SSH keypair is overwritten.
+
+### Why this isn't automated CI
+
+Each run costs model tokens, takes minutes, and depends on a working Gondolin
+snapshot. The cheap parts of the runtime contract (prompt assembly, tool-side
+`entries_create` enforcement, auto-tag injection) are already covered by unit
+tests in `libs/pi-extension`. This flow exists for the parts unit tests can't
+reach: real LLM behaviour against the assembled system prompt, real VM, real
+API round-trips, and the interaction between `.moltnet/<agent>/` identity
+material and the active `sandbox.json`.
+
 ## License
 
 AGPL-3.0-only.

package/dist/main.js

@@ -6,12 +6,13 @@ import { ROOT_CONTEXT, SpanStatusCode, context, metrics, propagation, trace } fr
 import { pino, transport } from "pino";
 import { readFile } from "node:fs/promises";
 import { createHash as createHash$1 } from "node:crypto";
-import path, { dirname, isAbsolute, join, resolve } from "node:path";
+import path, { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 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";
@@ -3037,22 +3038,6 @@ function validateRubricWeights(rubric) {
 	if (Math.abs(sum - 1) > 1e-6) return `Rubric weights must sum to 1.0 (got ${sum.toFixed(6)})`;
 	return null;
 }
-`
-You are reviewing a GitHub pull request for **complexity** — how hard
-this change is to review safely, NOT whether it's correct or whether
-the feature is worthwhile. The diff has already been opened by the
-producer; your job is to score reviewability.
-
-You may run \`gh pr diff <number>\`, \`gh pr view <number>\`, and read
-files in the workspace. Don't run tests, don't push commits, don't
-modify anything. The PR's GitHub URL is in the target metadata.
-
-When in doubt about a criterion, score conservatively (lower) and
-explain what made the call ambiguous. Reviewers will read your
-rationale; "looks fine" is not useful, "the change touches three
-unrelated subsystems and the test coverage on the auth path is
-unchanged" is.
-`.trim();
 //#endregion
 //#region ../../libs/tasks/src/success-criteria.ts
 /**
@@ -4772,6 +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
 	},
@@ -4780,6 +4769,9 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: AssessBriefInput,
 		outputSchema: AssessBriefOutput,
 		outputKind: "judgment",
+		workspaceMode: "dedicated_worktree",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateInputAsync: validateAssessBriefInputAsync
@@ -4789,6 +4781,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: CuratePackInput,
 		outputSchema: CuratePackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -4797,6 +4791,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RenderPackInput,
 		outputSchema: RenderPackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent,
 		validateInputAsync: validateRenderPackInputAsync
@@ -4806,6 +4802,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgePackInput,
 		outputSchema: JudgePackOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateOutput: validateJudgePackOutput,
@@ -4816,6 +4814,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RunEvalInput,
 		outputSchema: RunEvalOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateOutput: validateRunEvalOutput
 	},
@@ -4824,6 +4824,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgeEvalVariantInput,
 		outputSchema: JudgeEvalVariantOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateInput: validateJudgeEvalVariantInput,
 		validateOutput: validateJudgeEvalVariantOutput,
@@ -5737,6 +5739,58 @@ function getTaskOutputSchema(taskType) {
 function taskTypeUsesSubagents(taskType) {
 	return getTaskTypeEntry(taskType)?.usesSubagents === true;
 }
+/**
+* Filesystem isolation policy requested by the task type.
+*
+* Unknown task types and task types without an explicit policy default to the
+* legacy/shared behaviour.
+*/
+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
 /**
@@ -5999,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();
@@ -6362,6 +6420,15 @@ function buildAssessBriefUserPrompt(input, ctx) {
 		rubric.preamble,
 		""
 	].join("\n") : "";
+	const workspaceSection = ctx.workspace?.mode === "dedicated_worktree" ? [
+		"### Workspace",
+		"",
+		"This review attempt is running inside a dedicated disposable git",
+		"worktree created for this task. If you need to check out the target",
+		"branch or inspect refs locally, do it only inside this worktree.",
+		ctx.workspace.branch ? `The current review branch is \`${ctx.workspace.branch}\`. You may replace it with the target branch locally if that helps your inspection.` : "The current checkout is disposable and will be cleaned up when the task ends.",
+		""
+	].join("\n") : "";
 	return [
 		"# Assess Brief Judge",
 		"",
@@ -6402,6 +6469,7 @@ function buildAssessBriefUserPrompt(input, ctx) {
 		"  read it from the task you fetched in step 1 and pass",
 		"  `taskFilter: { correlationId: \"<id>\" }`.",
 		"",
+		workspaceSection,
 		preambleSection,
 		"## Criteria",
 		"",
@@ -6661,6 +6729,14 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 		"from this branch naming scheme when correlationId is set.",
 		""
 	].join("\n") : "";
+	const workspaceSection = ctx.workspace?.mode === "dedicated_worktree" ? [
+		"### Workspace",
+		"",
+		"This attempt is running inside a dedicated git worktree created",
+		"for this task. Do not repurpose or switch the primary checkout.",
+		ctx.workspace.branch ? `The current branch is \`${ctx.workspace.branch}\`. Stay on this branch unless the runtime instructor explicitly tells you otherwise.` : "Stay on the branch that was pre-provisioned for this task.",
+		""
+	].join("\n") : "";
 	return [
 		"# Fulfill Brief Agent",
 		"",
@@ -6681,9 +6757,10 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 		criteriaSection,
 		seedSection,
 		correlationSection,
+		workspaceSection,
 		"### Workflow",
 		"",
-		`1. Create a feature branch (starting prefix suggestion: \`${branchSlug}<short-slug>\`).`,
+		ctx.workspace?.mode === "dedicated_worktree" ? `1. Use the already-provisioned dedicated worktree branch${ctx.workspace.branch ? ` (\`${ctx.workspace.branch}\`)` : ""}; do not create or switch the primary checkout.` : `1. Create a feature branch (starting prefix suggestion: \`${branchSlug}<short-slug>\`).`,
 		"2. Understand the problem — read relevant code; do not speculate.",
 		"3. Implement the change. Keep commits small and coherent.",
 		"4. Add tests if applicable.",
@@ -7081,7 +7158,8 @@ function buildTaskUserPrompt(task, ctx) {
 			return buildFulfillBriefUserPrompt(task.input, {
 				diaryId: ctx.diaryId,
 				taskId: ctx.taskId,
-				correlationId: task.correlationId
+				correlationId: task.correlationId,
+				workspace: ctx.workspace
 			});
 		case ASSESS_BRIEF_TYPE:
 			if (!Check(AssessBriefInput, task.input)) {
@@ -7090,7 +7168,8 @@ function buildTaskUserPrompt(task, ctx) {
 			}
 			return buildAssessBriefUserPrompt(task.input, {
 				diaryId: ctx.diaryId,
-				taskId: ctx.taskId
+				taskId: ctx.taskId,
+				workspace: ctx.workspace
 			});
 		case CURATE_PACK_TYPE:
 			if (!Check(CuratePackInput, task.input)) {
@@ -15313,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({
@@ -15330,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
 /**
@@ -15949,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
@@ -15997,7 +16193,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 	const task = claimedTask.task;
 	const attemptN = claimedTask.attemptN;
 	const startTime = Date.now();
-	const mountPath = 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,
 		attemptN,
@@ -16028,7 +16227,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 			"--relative-paths"
 		], { stdio: "pipe" });
 	} catch {}
-	const managed = await resumeVm({
+	let managed = null;
+	managed = await resumeVm({
 		checkpointPath,
 		agentName: opts.agentName,
 		mountPath,
@@ -16088,13 +16288,19 @@ async function executePiTask(claimedTask, reporter, opts) {
 			taskType: task.taskType,
 			teamId: task.teamId,
 			provider: opts.provider,
-			model: opts.model
+			model: opts.model,
+			workspaceMode: workspace.mode,
+			workspaceBranch: workspace.branch
 		});
 		let taskPrompt;
 		try {
 			taskPrompt = buildTaskUserPrompt(task, {
 				diaryId,
 				taskId: task.id,
+				workspace: {
+					mode: workspace.mode,
+					branch: workspace.branch
+				},
 				extras: opts.promptExtras
 			});
 		} catch (err) {
@@ -16205,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);
@@ -16424,7 +16631,13 @@ async function executePiTask(claimedTask, reporter, opts) {
 				console.error(`executePiTask: reporter.close() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
 			}
 		}
-		await managed.vm.close();
+		if (managed) await managed.vm.close();
+		try {
+			workspace.cleanup();
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			console.error(`executePiTask: workspace cleanup failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		}
 	}
 }
 function emptyUsage(provider, model) {
@@ -16626,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;
@@ -16710,7 +17336,8 @@ var DEFAULTS = {
 	maxBatchSize: 50,
 	flushIntervalMs: 200,
 	maxTurns: 0,
-	maxBashTimeouts: 3
+	maxBashTimeouts: 3,
+	warmSessionTtlSec: 1800
 };
 var MissingRequiredOptionError = class extends Error {
 	constructor(flag) {
@@ -16734,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
 	};
 }
@@ -16769,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" }
 	};
 }
@@ -16851,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({
@@ -16922,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({
@@ -16972,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
@@ -17010,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,
@@ -17044,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();
@@ -17052,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();
 	}
@@ -17112,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({
@@ -17160,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
@@ -17204,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.1",
+  "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/sdk": "0.102.0",
-    "@themoltnet/pi-extension": "0.16.1",
-    "@themoltnet/agent-runtime": "0.15.0"
+    "@themoltnet/pi-extension": "0.17.0",
+    "@themoltnet/agent-runtime": "0.15.1",
+    "@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/tasks": "0.1.0",
+    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/database": "0.1.0",
-    "@moltnet/bootstrap": "0.1.0"
+    "@moltnet/tasks": "0.1.0",
+    "@moltnet/crypto-service": "0.1.0"
   },
   "nx": {
     "tags": [