@themoltnet/agent-daemon 0.32.0 → 0.32.1

package/README.md

@@ -156,8 +156,9 @@ registered task type; unknown task-type names remain invalid.
   provider key referenced by `.pi/models.json`, for example `OLLAMA_API_KEY`.
 - `ssh-keygen` on `PATH`.
 - A runtime profile in the target team. The profile supplies provider, model,
-  sandbox policy, and runtime defaults. The daemon mounts the current working
-  directory as the VM workspace root.
+  sandbox policy, and runtime defaults. The daemon resolves the configured
+  agent root and uses that checkout as the VM workspace root, regardless of
+  the shell directory from which the command was launched.
 
 For `themoltnet`, prefer a profile sandbox equivalent to this minimal policy:
 
@@ -203,6 +204,26 @@ producer context, the judge fails with `producer_context_missing`.
 Repo-specific `resumeCommands` that should not run in scratch mode must still
 be guarded with `when.workspaceMode`.
 
+### Runtime resource lifecycle
+
+Each daemon process creates a unique runtime lane. Two polling processes using
+the same agent, runtime profile, and task correlation therefore write to
+different local Pi session directories and cannot race on the same slot.
+
+`freeform` Pi context remains correlation-scoped, but its checkout is
+attempt-scoped. Every attempt gets a fresh `daemon-task-<id>-attempt-<n>`
+workspace; retries and explicit continuations fork the previous checkpointed
+Pi session into that new workspace. The executor removes attempt workspaces on
+normal completion. At startup, and once per minute while polling, the daemon
+also reaps expired idle slots and terminal crash-orphans. Cleanup is restricted
+to daemon-owned session, scratch, and `.worktrees` roots.
+
+Provider failures are retried in the active Pi session before the daemon spends
+a task attempt. The default is four same-session retries. If those fail,
+deterministic retry classification runs before attempt-budget handling;
+`executor_threw` is always treated as an implementation/setup failure and is
+never promoted to another task attempt.
+
 ### 1. Start the local stack
 
 The e2e Compose file ships everything the daemon needs (Postgres, Ory, REST

package/dist/main.js

@@ -12,8 +12,9 @@ import { parseArgs, promisify } from "node:util";
 import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource } from "@themoltnet/agent-runtime";
 import { createPiRetryTriage, createPiTaskExecutor, findMainWorktree, normalizeRetryTriageResult, redactRetryTriageSecrets } from "@themoltnet/pi-extension";
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync, realpathSync, rmSync } from "node:fs";
 import { AuthenticationError, MoltNetError, connect } from "@themoltnet/sdk";
+import { createHash, randomUUID } from "node:crypto";
 import { once } from "node:events";
 import { pino, transport } from "pino";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
@@ -25,7 +26,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { getModel } from "@earendil-works/pi-ai";
 import { mkdir, realpath, stat } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
-import { createHash } from "node:crypto";
 import { Writable } from "node:stream";
 import { createGzip } from "node:zlib";
 //#region ../../libs/observability/src/instrumentation.ts
@@ -6537,7 +6537,7 @@ var BUILT_IN_TASK_TYPES = {
 		outputKind: "artifact",
 		resumable: true,
 		workspaceMode: "shared_mount",
-		workspaceScope: "session",
+		workspaceScope: "attempt",
 		sessionScope: "correlation",
 		acceptsInputWorkspaceOverride: true,
 		requiresReferences: false,
@@ -9880,6 +9880,11 @@ function createGhCliClient() {
 	};
 }
 //#endregion
+//#region src/lib/daemon-slot-identity.ts
+function createRuntimeInstanceId() {
+	return randomUUID();
+}
+//#endregion
 //#region src/lib/session-files.ts
 function resolveLatestPiSessionPath(sessionDir) {
 	try {
@@ -9950,10 +9955,10 @@ function slugifySessionComponent(input) {
 }
 //#endregion
 //#region src/lib/task-execution-plan.ts
-function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec, runtimeProfileWorkspacePolicy = {}) {
+function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec, runtimeProfileWorkspacePolicy = {}, attemptN) {
 	const descriptor = deriveTaskSessionDescriptor(task);
 	const workspaceMode = resolveTaskWorkspaceMode(task, descriptor.policy, runtimeProfileWorkspacePolicy);
-	const slotKey = warmSessionTtlSec > 0 ? descriptor.sessionKey : null;
+	const slotKey = warmSessionTtlSec > 0 && descriptor.sessionKey ? buildRuntimeSlotKey(descriptor.sessionKey, identity.runtimeInstanceId) : null;
 	const workspaceScope = slotKey !== null ? descriptor.policy.workspaceScope : "attempt";
 	const slotId = slotKey ? buildDaemonSlotId(identity, slotKey) : null;
 	const sessionDir = slotId ? `${stateDirs.piSessionsDir}/${encodeURIComponent(slotId)}` : null;
@@ -9961,7 +9966,8 @@ function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlS
 	const workspaceId = workspaceMode !== "shared_mount" ? resolveTaskWorkspaceId(task, {
 		sessionKey: slotId,
 		workspaceScope,
-		sessionPersistence: sessionDir ? { sessionDir } : null
+		sessionPersistence: sessionDir ? { sessionDir } : null,
+		attemptN
 	}) : null;
 	return {
 		descriptor,
@@ -9985,6 +9991,12 @@ function buildDaemonSlotId(identity, slotKey) {
 		slotKey
 	].join(":");
 }
+function buildRuntimeSlotKey(logicalSessionKey, runtimeInstanceId) {
+	return runtimeInstanceId ? `${logicalSessionKey}:worker:${slugSlotIdentityComponent(runtimeInstanceId)}` : logicalSessionKey;
+}
+function runtimeSlotKeyBelongsToInstance(slotKey, runtimeInstanceId) {
+	return slotKey.endsWith(`:worker:${slugSlotIdentityComponent(runtimeInstanceId)}`);
+}
 function slugSlotIdentityComponent(input) {
 	return slugifyAsciiLower(input.trim(), 64, [
 		".",
@@ -10039,7 +10051,7 @@ function toDaemonWorkspaceMode(mode) {
 }
 function resolveTaskWorkspaceId(task, executionPlan) {
 	if (executionPlan.workspaceScope === "session" && executionPlan.sessionKey !== null) return `session-${encodeURIComponent(executionPlan.sessionKey)}`;
-	return `task-${task.id}`;
+	return executionPlan.attemptN ? `daemon-task-${task.id}-attempt-${executionPlan.attemptN}` : `task-${task.id}`;
 }
 //#endregion
 //#region src/lib/execution-plan-cache.ts
@@ -10058,7 +10070,7 @@ function createExecutionPlanCache(args) {
 			const key = buildClaimedTaskKey(claimedTask);
 			const existing = cache.get(key);
 			if (existing) return existing;
-			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
+			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy, claimedTask.attemptN), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
 			assertPlanAllowedByWorkspacePolicy(plan, args.workspacePolicy);
 			cache.set(key, plan);
 			return plan;
@@ -10125,14 +10137,13 @@ async function resolveWarmSlot(slotRegistry, runtimeSessionStore, teamId, source
 	return {
 		kind: "found",
 		producerSlot: producerContext,
-		sessionPath: sourceSessionPath,
-		workspacePath: resolveProducerWorkspaceCopySource(producerContext, stateDirs)
+		sessionPath: sourceSessionPath
 	};
 }
 async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore, sourceAttemptResolver) {
 	if (claimedTask.task.taskType === "freeform") {
 		const continueFrom = claimedTask.task.input.continueFrom;
-		if (!continueFrom) return basePlan;
+		if (!continueFrom) return maybeAttachRetrySession(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore);
 		const resolution = await resolveWarmSlot(slotRegistry, runtimeSessionStore, claimedTask.task.teamId, continueFrom.taskId, continueFrom.attemptN, stateDirs);
 		if (resolution.kind === "missing") throw new ProducerContextResolutionError(`Continuation source task ${continueFrom.taskId} attempt ${continueFrom.attemptN} has no local runtime slot or durable runtime session — claim affinity filter should have prevented this claim`);
 		if (resolution.kind === "no-session-path") throw new ProducerContextResolutionError(`Continuation source attempt ${continueFrom.taskId}/${continueFrom.attemptN} has no persisted Pi session path`);
@@ -10164,7 +10175,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 			return {
 				...basePlan,
 				workspaceMode: "dedicated_worktree",
-				workspaceId: recoveredBranch ? `extend-${continueFrom.taskId}-attempt-${continueFrom.attemptN}` : null,
+				workspaceId: recoveredBranch ? buildAttemptWorkspaceId(claimedTask) : null,
 				worktreeBranch: recoveredBranch,
 				sessionPersistence: {
 					sessionDir,
@@ -10193,7 +10204,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		return {
 			...basePlan,
 			workspaceMode: "dedicated_worktree",
-			workspaceId: resolution.producerSlot.workspace?.workspaceId ?? null,
+			workspaceId: parentBranch ? buildAttemptWorkspaceId(claimedTask) : null,
 			worktreeBranch: parentBranch,
 			sessionPersistence: {
 				sessionDir,
@@ -10215,7 +10226,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		worktreeBranch: null,
 		workspaceKind: "scratch",
 		workspaceSeed: {
-			copyFromPath: resolution.workspacePath,
+			copyFromPath: resolveProducerWorkspaceCopySource(resolution.producerSlot, stateDirs),
 			source: "producer"
 		},
 		sessionPersistence: {
@@ -10224,6 +10235,25 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		}
 	};
 }
+function buildAttemptWorkspaceId(claimedTask) {
+	return `daemon-task-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
+}
+async function maybeAttachRetrySession(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore) {
+	if (claimedTask.attemptN <= 1 || !basePlan.sessionPersistence?.sessionDir) return basePlan;
+	const resolution = await resolveWarmSlot(slotRegistry, runtimeSessionStore, claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN - 1, stateDirs);
+	if (resolution.kind === "missing" || resolution.kind === "no-session-path") return basePlan;
+	const sourceSessionDir = dirname(resolution.sessionPath);
+	const targetSessionDir = basePlan.sessionPersistence.sessionDir;
+	if (sourceSessionDir === targetSessionDir) return basePlan;
+	return {
+		...basePlan,
+		worktreeBranch: basePlan.workspaceMode === "dedicated_worktree" && resolution.kind === "found" ? resolution.producerSlot.workspace?.worktreeBranch ?? basePlan.worktreeBranch : basePlan.worktreeBranch,
+		sessionPersistence: {
+			sessionDir: targetSessionDir,
+			forkFromSessionPath: resolution.sessionPath
+		}
+	};
+}
 function buildForkBranch(parentBranch, childTaskId, childAttemptN) {
 	return `${parentBranch}-fork-${childTaskId.slice(0, 8)}-${childAttemptN}`;
 }
@@ -10267,6 +10297,7 @@ var RETRYABLE_CODES = new Set([
 ]);
 var NON_RETRYABLE_CODES = new Set([
 	"bad_api_key",
+	"executor_threw",
 	"invalid_api_key",
 	"invalid_model",
 	"max_turns_exceeded",
@@ -10309,17 +10340,18 @@ var NON_RETRYABLE_MESSAGE_PATTERNS = [
 	/\bmax (?:turn|bash)/i
 ];
 async function classifyAttemptFailure(input) {
-	if (input.remainingAttempts !== null && input.remainingAttempts !== void 0) {
-		if (input.remainingAttempts <= 0) return {
+	const deterministic = classifyDeterministically(input.error);
+	if (input.remainingAttempts !== null && input.remainingAttempts !== void 0 && input.remainingAttempts <= 0) {
+		const deterministicReason = deterministic === "ambiguous" ? "" : ` Deterministic policy classified the failure as ${deterministic}.`;
+		return {
 			error: withRetryInfo(input.error, {
 				retryable: false,
 				source: "attempts_exhausted",
-				reason: `Attempt budget exhausted at attempt ${input.attemptN}${input.maxAttempts ? ` of ${input.maxAttempts}` : ""}.`
+				reason: `Attempt budget exhausted at attempt ${input.attemptN}${input.maxAttempts ? ` of ${input.maxAttempts}` : ""}.${deterministicReason}`
 			}),
 			source: "attempts_exhausted"
 		};
 	}
-	const deterministic = classifyDeterministically(input.error);
 	if (deterministic !== "ambiguous") {
 		const retryable = deterministic === "retryable";
 		const source = input.error.retryable === retryable ? "explicit" : "deterministic";
@@ -10895,6 +10927,269 @@ function createRuntimeProfileRetryTriage(options) {
 	});
 }
 //#endregion
+//#region src/lib/runtime-resource-reaper.ts
+var RUNTIME_SLOT_PAGE_LIMIT = 200;
+var ATTEMPT_LOOKUP_CONCURRENCY = 8;
+var TERMINAL_ATTEMPT_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"aborted",
+	"timed_out"
+]);
+/**
+* Reap daemon-owned local resources whose runtime slot is no longer usable.
+* The destructive path is deliberately conservative: uncertainty about slot
+* ownership, attempt state, listing completeness, or real filesystem
+* containment retains resources rather than risking another daemon's data.
+*/
+async function reapRuntimeSlotResources(deps, input) {
+	const now = input.now ?? Date.now();
+	const [activePage, idlePage] = await Promise.all([listOwnedSlots(deps.runtimeSlotStore, input, "active"), listOwnedSlots(deps.runtimeSlotStore, input, "idle")]);
+	const active = activePage.items;
+	const idle = idlePage.items;
+	const slots = [...active, ...idle];
+	const result = {
+		failed: 0,
+		failures: [],
+		removedSessions: 0,
+		removedWorkspaces: 0,
+		scanned: slots.length,
+		truncated: activePage.truncated || idlePage.truncated,
+		unsafePathDetails: [],
+		unsafePaths: 0
+	};
+	const reaped = new Set(idle.filter((item) => item.slot.expiresAtMs <= now).map((item) => item.slot.id));
+	for (const slotId of await findTerminalActiveSlotIds(deps, active, result)) reaped.add(slotId);
+	const retainedSessionDirs = new Set(slots.filter((item) => !reaped.has(item.slot.id)).flatMap((item) => item.session?.sessionDir ? [resolve(item.session.sessionDir)] : []));
+	const retainedWorkspacePaths = new Set(slots.filter((item) => !reaped.has(item.slot.id)).flatMap((item) => item.workspace?.worktreePath ? [resolve(item.workspace.worktreePath)] : []));
+	const worktrees = input.mainWorktree ? await listRegisteredWorktrees(input.mainWorktree) : {
+		kind: "ready",
+		paths: /* @__PURE__ */ new Set()
+	};
+	for (const item of slots) {
+		if (!reaped.has(item.slot.id)) continue;
+		if (!await slotStillQualifiesForReaping(deps, input, item, now, result)) continue;
+		const sessionDir = item.session?.sessionDir;
+		if (sessionDir && !retainedSessionDirs.has(resolve(sessionDir)) && existsSync(sessionDir)) if (!isRealPathInsideRoot(sessionDir, input.sessionRootDir)) recordUnsafePath(deps, result, item.slot.id, sessionDir, input.sessionRootDir);
+		else try {
+			rmSync(sessionDir, {
+				force: true,
+				recursive: true
+			});
+			result.removedSessions++;
+		} catch (err) {
+			recordFailure(deps, result, item.slot.id, sessionDir, input.sessionRootDir, err);
+		}
+		const workspacePath = item.workspace?.worktreePath;
+		if (!workspacePath || retainedWorkspacePaths.has(resolve(workspacePath))) continue;
+		const workspaceRoot = item.workspace?.kind === "scratch" ? input.scratchRootDir : input.mainWorktree ? resolve(input.mainWorktree, ".worktrees") : null;
+		if (!workspaceRoot) {
+			recordUnsafePath(deps, result, item.slot.id, workspacePath, null);
+			continue;
+		}
+		await removeWorkspace(deps, result, worktrees, input.mainWorktree, item.slot.id, workspacePath, workspaceRoot, item.workspace?.kind === "scratch");
+	}
+	if (!result.truncated) await reapLegacyOrphanWorktrees(deps, input, worktrees, retainedSessionDirs, retainedWorkspacePaths, result);
+	return result;
+}
+async function listOwnedSlots(store, input, state) {
+	const listed = await store.listSlots({
+		agentName: input.agentName,
+		limit: RUNTIME_SLOT_PAGE_LIMIT,
+		runtimeProfileId: input.runtimeProfileId,
+		state,
+		teamId: input.teamId
+	});
+	return {
+		items: listed.filter((item) => runtimeSlotKeyBelongsToInstance(item.slot.slotKey, input.runtimeInstanceId)),
+		truncated: listed.length === RUNTIME_SLOT_PAGE_LIMIT
+	};
+}
+async function findTerminalActiveSlotIds(deps, active, result) {
+	const byTask = /* @__PURE__ */ new Map();
+	for (const item of active) {
+		const taskSlots = byTask.get(item.slot.lastTaskId) ?? [];
+		taskSlots.push(item);
+		byTask.set(item.slot.lastTaskId, taskSlots);
+	}
+	const terminal = /* @__PURE__ */ new Set();
+	await mapWithConcurrency([...byTask.entries()], ATTEMPT_LOOKUP_CONCURRENCY, async ([taskId, taskSlots]) => {
+		let attempts;
+		try {
+			attempts = await deps.taskReader.listAttempts(taskId);
+		} catch (err) {
+			recordFailure(deps, result, null, `task:${taskId}`, null, err);
+			return;
+		}
+		for (const item of taskSlots) {
+			const attempt = attempts.find((candidate) => candidate.attemptN === item.slot.lastAttemptN);
+			if (attempt && TERMINAL_ATTEMPT_STATUSES.has(attempt.status)) terminal.add(item.slot.id);
+		}
+	});
+	return terminal;
+}
+async function slotStillQualifiesForReaping(deps, input, original, now, result) {
+	let page;
+	try {
+		page = await listOwnedSlots(deps.runtimeSlotStore, input, original.slot.state);
+	} catch (err) {
+		recordFailure(deps, result, original.slot.id, `slot:${original.slot.id}`, null, err);
+		return false;
+	}
+	const current = page.items.find((candidate) => candidate.slot.id === original.slot.id);
+	if (!current) return false;
+	if (current.slot.lastTaskId !== original.slot.lastTaskId || current.slot.lastAttemptN !== original.slot.lastAttemptN) return false;
+	return current.slot.state === "active" || current.slot.state === "idle" && current.slot.expiresAtMs <= now;
+}
+async function reapLegacyOrphanWorktrees(deps, input, worktrees, retainedSessionDirs, retainedWorkspacePaths, result) {
+	if (!input.mainWorktree) return;
+	const workspaceRoot = resolve(input.mainWorktree, ".worktrees");
+	if (!existsSync(workspaceRoot)) return;
+	let entries;
+	try {
+		entries = readdirSync(workspaceRoot, { withFileTypes: true });
+	} catch (err) {
+		recordFailure(deps, result, null, workspaceRoot, workspaceRoot, err);
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.startsWith("session-agent%3A")) continue;
+		const workspacePath = resolve(workspaceRoot, entry.name);
+		if (retainedWorkspacePaths.has(workspacePath)) continue;
+		const sessionDir = resolve(input.sessionRootDir, entry.name.slice(8));
+		if (retainedSessionDirs.has(sessionDir) || existsSync(sessionDir)) continue;
+		await removeWorkspace(deps, result, worktrees, input.mainWorktree, null, workspacePath, workspaceRoot, false);
+	}
+}
+async function removeWorkspace(deps, result, worktrees, mainWorktree, slotId, workspacePath, workspaceRoot, scratch) {
+	if (!existsSync(workspacePath)) return;
+	if (!isRealPathInsideRoot(workspacePath, workspaceRoot)) {
+		recordUnsafePath(deps, result, slotId, workspacePath, workspaceRoot);
+		return;
+	}
+	if (scratch || !mainWorktree) {
+		try {
+			rmSync(workspacePath, {
+				force: true,
+				recursive: true
+			});
+			result.removedWorkspaces++;
+		} catch (err) {
+			recordFailure(deps, result, slotId, workspacePath, workspaceRoot, err);
+		}
+		return;
+	}
+	if (worktrees.kind === "unavailable") {
+		recordFailure(deps, result, slotId, workspacePath, workspaceRoot, new Error(worktrees.reason));
+		return;
+	}
+	try {
+		const canonical = realpathSync(workspacePath);
+		if (worktrees.paths.has(canonical)) {
+			await execFileText("git", [
+				"-C",
+				mainWorktree,
+				"worktree",
+				"remove",
+				"--force",
+				workspacePath
+			]);
+			worktrees.paths.delete(canonical);
+		} else rmSync(workspacePath, {
+			force: true,
+			recursive: true
+		});
+		result.removedWorkspaces++;
+	} catch (err) {
+		recordFailure(deps, result, slotId, workspacePath, workspaceRoot, err);
+	}
+}
+async function listRegisteredWorktrees(mainWorktree) {
+	try {
+		const list = await execFileText("git", [
+			"-C",
+			mainWorktree,
+			"worktree",
+			"list",
+			"--porcelain"
+		]);
+		return {
+			kind: "ready",
+			paths: new Set(list.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => canonicalPath(line.slice(9))))
+		};
+	} catch (err) {
+		return {
+			kind: "unavailable",
+			reason: errorMessage(err)
+		};
+	}
+}
+function isRealPathInsideRoot(path, root) {
+	try {
+		return isResolvedPathInsideRoot$1(realpathSync(path), realpathSync(root));
+	} catch {
+		return false;
+	}
+}
+function isResolvedPathInsideRoot$1(path, root) {
+	const rel = relative(root, path);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
+function recordUnsafePath(deps, result, slotId, path, root) {
+	const issue = {
+		kind: "unsafe_path",
+		path,
+		reason: root === null ? "No daemon-owned root was available for this workspace." : "Candidate or root could not be resolved inside the daemon-owned root.",
+		root,
+		slotId
+	};
+	result.unsafePaths++;
+	result.unsafePathDetails.push(issue);
+	emitIssue(deps, issue);
+}
+function recordFailure(deps, result, slotId, path, root, err) {
+	const issue = {
+		kind: "failure",
+		path,
+		reason: errorMessage(err),
+		root,
+		slotId
+	};
+	result.failed++;
+	result.failures.push(issue);
+	emitIssue(deps, issue);
+}
+function emitIssue(deps, issue) {
+	try {
+		deps.onIssue?.(issue);
+	} catch {}
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+async function execFileText(file, args) {
+	return new Promise((resolvePromise, reject) => {
+		execFile(file, args, {
+			encoding: "utf8",
+			maxBuffer: 10 * 1024 * 1024
+		}, (err, stdout) => {
+			if (err) reject(err instanceof Error ? err : /* @__PURE__ */ new Error("Child process failed without an Error instance."));
+			else resolvePromise(stdout);
+		});
+	});
+}
+async function mapWithConcurrency(items, concurrency, worker) {
+	for (let index = 0; index < items.length; index += concurrency) await Promise.all(items.slice(index, index + concurrency).map(worker));
+}
+//#endregion
 //#region src/lib/runtime-sessions.ts
 function resolveRuntimeSessionKind(claimedTask) {
 	const continueFrom = resolveContinueFrom(claimedTask);
@@ -11031,6 +11326,8 @@ function createApiRuntimeSlotStore(args) {
 					lastAttemptN: resolved.slot.lastAttemptN,
 					lastTaskId: resolved.slot.lastTaskId,
 					runtimeProfileId: resolved.slot.runtimeProfileId,
+					slotKey: resolved.slot.slotKey,
+					state: resolved.slot.state,
 					taskType: resolved.slot.taskType
 				},
 				session: resolved.slot.sessionDir ? {
@@ -11202,12 +11499,13 @@ async function runPolling(opts) {
 		agent: ctx.agent,
 		profiles: profileValues,
 		teamId,
-		cwd: process.cwd()
+		cwd: ctx.agentRootDir
 	});
 	for (const profile of profiles) validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
+	const runtimeInstanceId = createRuntimeInstanceId();
 	const runtimes = /* @__PURE__ */ new Map();
 	for (const profile of profiles) {
 		const common = parseCommonOptions(values, { runtimeDefaults: {
@@ -11227,7 +11525,8 @@ async function runPolling(opts) {
 		const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 		const slotIdentity = {
 			agentName: common.agent,
-			runtimeProfileId: profile.id
+			runtimeProfileId: profile.id,
+			runtimeInstanceId
 		};
 		const executionPlans = createExecutionPlanCache({
 			stateDirs,
@@ -11335,6 +11634,47 @@ async function runPolling(opts) {
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
+	let reaperRunning = false;
+	const reapRuntimeResources = async () => {
+		if (reaperRunning) return;
+		reaperRunning = true;
+		try {
+			for (const profile of profiles) {
+				const selected = requireRuntime(runtimes, profile.id);
+				const result = await reapRuntimeSlotResources({
+					onIssue: (issue) => {
+						rootLogger.warn({
+							...issue,
+							runtimeProfileId: profile.id
+						}, "agent-daemon.runtime_resource_reap_issue");
+					},
+					runtimeSlotStore: slotRegistry,
+					taskReader: ctx.agent.tasks
+				}, {
+					agentName: selected.common.agent,
+					mainWorktree: resolveMainWorktree$1(selected.sandbox.rootDir),
+					runtimeInstanceId,
+					runtimeProfileId: profile.id,
+					sessionRootDir: selected.stateDirs.piSessionsDir,
+					scratchRootDir: join(selected.stateDirs.rootDir, "task-workspaces"),
+					teamId
+				});
+				if (result.removedSessions > 0 || result.removedWorkspaces > 0 || result.failed > 0 || result.unsafePaths > 0 || result.truncated) rootLogger.info({
+					...result,
+					runtimeProfileId: profile.id
+				}, "agent-daemon.runtime_resources_reaped");
+			}
+		} catch (err) {
+			rootLogger.warn({ err }, "agent-daemon.runtime_resource_reap_failed");
+		} finally {
+			reaperRunning = false;
+		}
+	};
+	await reapRuntimeResources();
+	const reaperTimer = setInterval(() => {
+		reapRuntimeResources();
+	}, 6e4);
+	reaperTimer.unref();
 	const outputs = [];
 	try {
 		runtime = new AgentRuntime({
@@ -11512,7 +11852,7 @@ async function runPolling(opts) {
 					sessionDir: executionPlan.sessionPersistence.sessionDir,
 					sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 					workspaceId: executionPlan.workspaceId,
-					worktreePath: resolveRecordedWorkspacePath$1(stateDirs.rootDir, executionPlan),
+					worktreePath: resolveRecordedWorkspacePath$1(stateDirs.rootDir, sandbox.rootDir, executionPlan),
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
@@ -11568,15 +11908,23 @@ async function runPolling(opts) {
 		rootLogger.info({ processed: drained.length }, "agent-daemon.drained");
 		return drained.some((o) => o.status !== "completed") ? 1 : 0;
 	} finally {
+		clearInterval(reaperTimer);
 		signalHandlers.dispose();
 		await slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath$1(stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath$1(stateRootDir, mountPath, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(mountPath), ".worktrees", executionPlan.workspaceId);
+}
+function resolveMainWorktree$1(mountPath) {
+	try {
+		return findMainWorktree(mountPath);
+	} catch {
+		return null;
+	}
 }
 function runtimeForClaimedTask(runtimes, claimedTask) {
 	if (!claimedTask.profileId) throw new Error(`Claimed task ${claimedTask.task.id} did not include a selected runtime profile`);
@@ -11668,7 +12016,7 @@ async function runOnce(argv) {
 		agent: ctx.agent,
 		profile: values.profile,
 		teamId: values.team,
-		cwd: process.cwd()
+		cwd: ctx.agentRootDir
 	});
 	validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
 	opts = parseCommonOptions(values, { runtimeDefaults: {
@@ -11690,9 +12038,11 @@ async function runOnce(argv) {
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
+	const runtimeInstanceId = createRuntimeInstanceId();
 	const slotIdentity = {
 		agentName: opts.agent,
-		runtimeProfileId: profile.id
+		runtimeProfileId: profile.id,
+		runtimeInstanceId
 	};
 	const executionPlans = createExecutionPlanCache({
 		stateDirs,
@@ -11754,6 +12104,26 @@ async function runOnce(argv) {
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
+	try {
+		const reaped = await reapRuntimeSlotResources({
+			onIssue: (issue) => {
+				rootLogger.warn(issue, "agent-daemon.runtime_resource_reap_issue");
+			},
+			runtimeSlotStore: slotRegistry,
+			taskReader: ctx.agent.tasks
+		}, {
+			agentName: opts.agent,
+			mainWorktree: resolveMainWorktree(sandbox.rootDir),
+			runtimeInstanceId,
+			runtimeProfileId: profile.id,
+			sessionRootDir: stateDirs.piSessionsDir,
+			scratchRootDir: join(stateDirs.rootDir, "task-workspaces"),
+			teamId: profile.teamId
+		});
+		if (reaped.removedSessions > 0 || reaped.removedWorkspaces > 0 || reaped.failed > 0 || reaped.unsafePaths > 0 || reaped.truncated) rootLogger.info(reaped, "agent-daemon.runtime_resources_reaped");
+	} catch (err) {
+		rootLogger.warn({ err }, "agent-daemon.runtime_resource_reap_failed");
+	}
 	let runtime = null;
 	let activeAttemptN = null;
 	const signalHandlers = installShutdownSignalHandlers({
@@ -11843,7 +12213,7 @@ async function runOnce(argv) {
 				sessionDir: executionPlan.sessionPersistence.sessionDir,
 				sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 				workspaceId: executionPlan.workspaceId,
-				worktreePath: resolveRecordedWorkspacePath(stateDirs.rootDir, executionPlan),
+				worktreePath: resolveRecordedWorkspacePath(stateDirs.rootDir, sandbox.rootDir, executionPlan),
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
@@ -11939,9 +12309,16 @@ async function runOnce(argv) {
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath(stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath(stateRootDir, mountPath, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(mountPath), ".worktrees", executionPlan.workspaceId);
+}
+function resolveMainWorktree(mountPath) {
+	try {
+		return findMainWorktree(mountPath);
+	} catch {
+		return null;
+	}
 }
 //#endregion
 //#region src/cli/poll.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "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.",
@@ -52,8 +52,8 @@
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "@themoltnet/agent-runtime": "0.36.6",
-    "@themoltnet/pi-extension": "0.36.0",
-    "@themoltnet/sdk": "0.127.0"
+    "@themoltnet/sdk": "0.127.0",
+    "@themoltnet/pi-extension": "0.36.1"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
@@ -62,8 +62,8 @@
     "vitest": "^3.0.0",
     "@moltnet/bootstrap": "0.1.0",
     "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/observability": "0.1.0",
-    "@moltnet/tasks": "0.1.0"
+    "@moltnet/tasks": "0.1.0",
+    "@moltnet/observability": "0.1.0"
   },
   "nx": {
     "projectType": "application",