@themoltnet/agent-daemon 0.25.1 → 0.27.0

package/README.md

@@ -19,17 +19,19 @@ Run commands through the published package:
 
 ## Modes
 
-| Mode    | Purpose                                                                       |
-| ------- | ----------------------------------------------------------------------------- |
-| `once`  | Claim a single task by id and exit. Use this in CI.                           |
-| `poll`  | Long-running loop that claims tasks as they appear. Local/long-running hosts. |
-| `drain` | Finalize any tasks already claimed by this agent and exit.                    |
+| Mode            | Purpose                                                                       |
+| --------------- | ----------------------------------------------------------------------------- |
+| `once`          | Claim a single task by id and exit. Use this in CI.                           |
+| `poll`          | Long-running loop that claims tasks as they appear. Local/long-running hosts. |
+| `drain`         | Finalize any tasks already claimed by this agent and exit.                    |
+| `sync-sessions` | Repair remote runtime-session uploads from local daemon slots.                |
 
 ```bash
 npx @themoltnet/agent-daemon once --task-id <uuid>
 npx @themoltnet/agent-daemon poll  --task-types fulfill_brief,assess_brief
 npx @themoltnet/agent-daemon poll  --task-types freeform
 npx @themoltnet/agent-daemon drain
+npx @themoltnet/agent-daemon sync-sessions --team <uuid> --agent <name> --dry-run
 ```
 
 ## Configuration

package/dist/main.js

@@ -7,7 +7,7 @@ import { PgInstrumentation } from "@opentelemetry/instrumentation-pg";
 import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
 import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import crypto from "crypto";
-import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { parseArgs, promisify } from "node:util";
 import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource } from "@themoltnet/agent-runtime";
 import { createPiTaskExecutor, findMainWorktree } from "@themoltnet/pi-extension";
@@ -22,8 +22,11 @@ import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { mkdir } from "node:fs/promises";
+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
 /**
 * Register OTel auto-instrumentation for common Node.js modules.
@@ -4411,6 +4414,32 @@ var RuntimeProfileAllowedWorkspaceModes = _Array_(RuntimeProfileWorkspaceMode, {
 	maxItems: 3,
 	uniqueItems: true
 });
+var RuntimeProfileThinkingLevelOptions = [
+	Literal("off"),
+	Literal("minimal"),
+	Literal("low"),
+	Literal("medium"),
+	Literal("high"),
+	Literal("xhigh")
+];
+Union([...RuntimeProfileThinkingLevelOptions]);
+var RuntimeProfileNullableThinkingLevel = Union([...RuntimeProfileThinkingLevelOptions, Null()]);
+var RuntimeProfileNullableTemperature = Union([Null(), Number$1({
+	minimum: 0,
+	maximum: 2
+})]);
+var RuntimeProfileNullableTopP = Union([Null(), Number$1({
+	minimum: 0,
+	maximum: 1
+})]);
+var RuntimeProfileNullableTopK = Union([Integer({
+	minimum: 1,
+	maximum: 1e4
+}), Null()]);
+var RuntimeProfileNullableMaxOutputTokens = Union([Integer({
+	minimum: 1,
+	maximum: 1e6
+}), Null()]);
 var SandboxResumeCommandWhenSchema = _Object_({ workspaceMode: Optional(_Array_(Union([
 	Literal("shared_mount"),
 	Literal("dedicated_worktree"),
@@ -4535,6 +4564,11 @@ _Object_({
 		minLength: 1,
 		maxLength: 200
 	}),
+	thinkingLevel: RuntimeProfileNullableThinkingLevel,
+	temperature: RuntimeProfileNullableTemperature,
+	topP: RuntimeProfileNullableTopP,
+	topK: RuntimeProfileNullableTopK,
+	maxOutputTokens: RuntimeProfileNullableMaxOutputTokens,
 	runtimeKind: Literal("gondolin_pi"),
 	sandbox: RuntimeProfileSandbox,
 	sessionStorageMode: Literal("local"),
@@ -4646,7 +4680,7 @@ var RuntimeWorkspace = _Object_({
 	createdAtMs: Integer({ minimum: 0 }),
 	lastUsedAtMs: Integer({ minimum: 0 })
 }, { $id: "RuntimeWorkspace" });
-_Object_({
+_Object_({ items: _Array_(_Object_({
 	slot: _Object_({
 		id: String$1({ format: "uuid" }),
 		teamId: String$1({ format: "uuid" }),
@@ -4679,7 +4713,7 @@ _Object_({
 		expiresAtMs: Integer({ minimum: 0 })
 	}, { $id: "RuntimeSlot" }),
 	workspace: Union([RuntimeWorkspace, Null()])
-}, { $id: "ResolvedRuntimeSlot" });
+}, { $id: "ResolvedRuntimeSlot" })) }, { $id: "RuntimeSlotListResponse" });
 _Object_({
 	agentName: String$1({
 		minLength: 1,
@@ -4740,6 +4774,21 @@ _Object_({
 	$id: "FindLatestRuntimeSlotForAttemptQuery",
 	additionalProperties: false
 });
+_Object_({
+	agentName: Optional(String$1({
+		minLength: 1,
+		maxLength: 100
+	})),
+	runtimeProfileId: Optional(String$1({ format: "uuid" })),
+	state: Optional(RuntimeSlotState),
+	limit: Optional(Integer({
+		minimum: 1,
+		maximum: 200
+	}))
+}, {
+	$id: "ListRuntimeSlotsQuery",
+	additionalProperties: false
+});
 //#endregion
 //#region ../../libs/tasks/src/success-criteria.ts
 /**
@@ -5613,6 +5662,7 @@ var FreeformArtifact = _Object_({
 });
 var FreeformOutput = _Object_({
 	summary: String$1({ minLength: 1 }),
+	branch: Optional(String$1({ minLength: 1 })),
 	artifacts: Optional(_Array_(FreeformArtifact, { maxItems: 20 })),
 	proposedTaskType: Optional(FreeformTaskTypeProposal),
 	diaryEntryIds: Optional(_Array_(String$1({ format: "uuid" }))),
@@ -5625,7 +5675,7 @@ var FreeformOutput = _Object_({
 * Server-side preflight for `freeform` task-create. Runs after the
 * sync TypeBox check passes and only kicks in when
 * `input.continueFrom` is set — i.e. the proposer is asking to
-* resume a prior freeform attempt's warm slot (#1287).
+* continue from a prior freeform attempt (#1287).
 *
 * Failure modes, in evaluation order:
 *  1. `freeform.sourceTaskNotFound` — source task id does not resolve
@@ -5633,23 +5683,17 @@ var FreeformOutput = _Object_({
 *  2. `freeform.sourceTaskTypeNotSupported` — source isn't `freeform`.
 *     v1 only supports freeform → freeform continuation.
 *  3. `freeform.sourceAttemptNotCompleted` — named attempt is missing
-*     or not in `completed` state; warm continuation only makes sense
+*     or not in `completed` state; continuation only makes sense
 *     once the parent has produced a terminal output.
 *  4. `freeform.executionWorkspaceNotInheritable` — caller set
 *     `execution.workspace` together with `continueFrom`. Workspace
-*     mode for a continuation is inherited from the parent slot
-*     (`maybeAttachWarmSlotContext` forces `dedicated_worktree` +
-*     the parent's worktreeBranch), so any caller-supplied override
-*     is silently dropped at the daemon plan stage. Reject explicitly
-*     so misconfiguration surfaces at create time.
-*  5. `freeform.sourceNotResumeEligible` — `daemonState` is null or
-*     `slotResumableUntil` is null. Older completions (pre-#1287) and
-*     daemons that opt out fall here.
-*  6. `freeform.sourceResumeExpired` — `slotResumableUntil` is in the
-*     past; the warm slot's TTL has elapsed and no daemon is
-*     guaranteed to still hold it.
+*     mode for a continuation is derived by the daemon from parent runtime
+*     context (local slot first, durable session + source attempt branch
+*     second), so any caller-supplied override is silently dropped at the
+*     daemon plan stage. Reject explicitly so misconfiguration surfaces at
+*     create time.
 *
-* Returns on the first failure (no "report all six") — the checks
+* Returns on the first failure — the checks
 * are sequential preconditions, later ones presume earlier ones hold.
 */
 async function validateFreeformInputAsync(input, ctx) {
@@ -5668,7 +5712,7 @@ async function validateFreeformInputAsync(input, ctx) {
 	}];
 	if (input.execution?.workspace) return [{
 		field: "input/execution/workspace",
-		message: "execution.workspace is inherited from the parent slot when continueFrom is set; omit it",
+		message: "execution.workspace is derived from parent runtime context when continueFrom is set; omit it",
 		code: "freeform.executionWorkspaceNotInheritable"
 	}];
 	if (ctx.deferReadinessChecks) return [];
@@ -5678,17 +5722,6 @@ async function validateFreeformInputAsync(input, ctx) {
 		message: `Source attempt ${cf.attemptN} on task ${cf.taskId} is not in 'completed' state`,
 		code: "freeform.sourceAttemptNotCompleted"
 	}];
-	if (!attempt.daemonState || attempt.daemonState.slotResumableUntil === null) return [{
-		field: "input/continueFrom",
-		message: "Source attempt did not report continuation eligibility (older completion or daemon opted out)",
-		code: "freeform.sourceNotResumeEligible"
-	}];
-	const expiresAt = new Date(attempt.daemonState.slotResumableUntil).getTime();
-	if (Number.isNaN(expiresAt) || expiresAt <= Date.now()) return [{
-		field: "input/continueFrom",
-		message: `Source attempt's warm slot expired at ${attempt.daemonState.slotResumableUntil} (reported at ${attempt.daemonState.reportedAt})`,
-		code: "freeform.sourceResumeExpired"
-	}];
 	return [];
 }
 //#endregion
@@ -8982,11 +9015,12 @@ var MAX_CLAIM_CONDITION_STATUSES = 8;
 /**
 * Daemon-asserted runtime state stamped onto a `TaskAttemptSummary` at
 * attempt-completion time. The server persists this block verbatim and
-* reads `slotResumableUntil` for `tasks_continue` create-time
-* eligibility; the daemon-side claim-affinity filter is the runtime
-* truth. The block carries its own `reportedAt` so consumers can reason
-* about staleness without reading documentation. All daemon-asserted
-* state lives here — top-level attempt fields stay server-authoritative.
+* exposes `slotResumableUntil` as a legacy/local warm-slot hint; task
+* continuation eligibility is based on the completed source attempt and
+* daemon-side claim-affinity/runtime-session recovery. The block carries
+* its own `reportedAt` so consumers can reason about staleness without
+* reading documentation. All daemon-asserted state lives here —
+* top-level attempt fields stay server-authoritative.
 *
 * Adding new fields requires explicit design review (intentional
 * boundary; see docs/superpowers/specs/2026-06-04-tasks-continue-design.md).
@@ -9250,6 +9284,8 @@ Commands:
   once      Claim and execute one specific queued task by id, then exit.
   drain     Poll until the queue has nothing claimable, then exit.
             Useful for batch eval runs and demos.
+  sync-sessions
+            Repair durable runtime-session checkpoints from local slot files.
 
 Run \`agent-daemon <command> --help\` for command-specific flags.
 
@@ -9340,6 +9376,34 @@ Example:
     --task-types judge_pack \\
     --agent legreffier \\
     --profile eval-judge`;
+var SYNC_SESSIONS_HELP = `\
+agent-daemon sync-sessions — repair durable runtime-session checkpoints.
+
+Usage:
+  agent-daemon sync-sessions --team <uuid> --agent <name> [...]
+
+Scans this daemon's team-scoped runtime slots, compares local Pi session files
+with durable runtime-session metadata, and uploads missing or stale checkpoints.
+
+Required:
+  --team <uuid>               Team whose runtime slots to inspect.
+  -a, --agent <name>          MoltNet agent identity. Reads credentials
+                              from <agent-root>/.moltnet/<name>/moltnet.json.
+
+Optional:
+  --runtime-profile-id <uuid> Limit repair to one runtime profile.
+  --state <active|idle>       Limit scanned slots by state. Default: all.
+  --limit <n>                 Max slots to scan, 1..200. Default: 100.
+  --dry-run                   Report missing/stale sessions without uploading.
+  --agent-root <path>         Directory that owns .moltnet/<agent>. Default:
+                              CWD, with git root fallback when available.
+  --debug                     Accepted for consistency; no extra output yet.
+
+Example:
+  agent-daemon sync-sessions \\
+    --team 6743b4b1-6b93-46e2-a048-19490f04f91a \\
+    --agent legreffier \\
+    --state idle`;
 function isHelpFlag(args) {
 	return args.includes("--help") || args.includes("-h");
 }
@@ -9633,12 +9697,13 @@ var ProducerContextResolutionError = class extends Error {
 function createExecutionPlanCache(args) {
 	const cache = /* @__PURE__ */ new Map();
 	const runtimeSessionStore = args.runtimeSessionStore ?? createNullRuntimeSessionStore();
+	const sourceAttemptResolver = args.sourceAttemptResolver ?? createNullSourceAttemptResolver();
 	return {
 		async getOrCreate(claimedTask) {
 			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);
+			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
 			assertPlanAllowedByWorkspacePolicy(plan, args.workspacePolicy);
 			cache.set(key, plan);
 			return plan;
@@ -9648,13 +9713,18 @@ function createExecutionPlanCache(args) {
 		}
 	};
 }
+function createNullSourceAttemptResolver() {
+	return { findOutputBranch() {
+		return Promise.resolve(null);
+	} };
+}
 function createNullRuntimeSessionStore() {
 	return {
-		async findRuntimeSessionByTaskAttempt() {
-			return null;
+		findRuntimeSessionByTaskAttempt() {
+			return Promise.resolve(null);
 		},
-		async hydrateSession() {
-			throw new ProducerContextResolutionError("Cannot hydrate runtime session: no runtime session store configured");
+		hydrateSession() {
+			return Promise.reject(new ProducerContextResolutionError("Cannot hydrate runtime session: no runtime session store configured"));
 		},
 		async uploadAttemptFinal() {}
 	};
@@ -9676,17 +9746,26 @@ function planToRuntimeProfileWorkspaceMode(plan) {
 function buildClaimedTaskKey(task) {
 	return `${task.task.id}:${task.attemptN}`;
 }
-async function resolveWarmSlot(slotRegistry, runtimeSessionStore, teamId, sourceTaskId, sourceAttemptN, stateDirs) {
-	const producerContext = await slotRegistry.findLatestSlotByTaskAttempt(teamId, sourceTaskId, sourceAttemptN);
-	if (!producerContext) return { kind: "missing" };
-	const localSessionPath = resolveProducerSessionPath(producerContext);
-	const remoteSession = localSessionPath ? null : await runtimeSessionStore.findRuntimeSessionByTaskAttempt(teamId, sourceTaskId, sourceAttemptN);
-	const sourceSessionPath = localSessionPath ? localSessionPath : remoteSession ? await runtimeSessionStore.hydrateSession({
+async function hydrateRemoteRuntimeSession(runtimeSessionStore, teamId, sourceTaskId, sourceAttemptN, stateDirs) {
+	if (!await runtimeSessionStore.findRuntimeSessionByTaskAttempt(teamId, sourceTaskId, sourceAttemptN)) return null;
+	return runtimeSessionStore.hydrateSession({
 		attemptN: sourceAttemptN,
 		destinationDir: `${stateDirs.piSessionsDir}/remote-${sourceTaskId}-attempt-${sourceAttemptN}`,
 		taskId: sourceTaskId,
 		teamId
-	}) : null;
+	});
+}
+async function resolveWarmSlot(slotRegistry, runtimeSessionStore, teamId, sourceTaskId, sourceAttemptN, stateDirs) {
+	const producerContext = await slotRegistry.findLatestSlotByTaskAttempt(teamId, sourceTaskId, sourceAttemptN);
+	if (!producerContext) {
+		const remoteSessionPath = await hydrateRemoteRuntimeSession(runtimeSessionStore, teamId, sourceTaskId, sourceAttemptN, stateDirs);
+		return remoteSessionPath ? {
+			kind: "remote-session",
+			sessionPath: remoteSessionPath
+		} : { kind: "missing" };
+	}
+	const localSessionPath = resolveProducerSessionPath(producerContext);
+	const sourceSessionPath = localSessionPath ? localSessionPath : await hydrateRemoteRuntimeSession(runtimeSessionStore, teamId, sourceTaskId, sourceAttemptN, stateDirs);
 	if (!sourceSessionPath) return { kind: "no-session-path" };
 	return {
 		kind: "found",
@@ -9695,19 +9774,54 @@ async function resolveWarmSlot(slotRegistry, runtimeSessionStore, teamId, source
 		workspacePath: resolveProducerWorkspaceCopySource(producerContext, stateDirs)
 	};
 }
-async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore) {
+async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slotRegistry, runtimeSessionStore, sourceAttemptResolver) {
 	if (claimedTask.task.taskType === "freeform") {
 		const continueFrom = claimedTask.task.input.continueFrom;
 		if (!continueFrom) return basePlan;
 		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 live runtime slot on this daemon — claim affinity filter should have prevented this claim`);
+		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`);
 		const sessionDir = `${stateDirs.piSessionsDir}/continue-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
+		if (resolution.kind === "remote-session") {
+			const recoveredBranch = await sourceAttemptResolver.findOutputBranch({
+				attemptN: continueFrom.attemptN,
+				taskId: continueFrom.taskId
+			});
+			if (continueFrom.mode === "fork") {
+				if (recoveredBranch) {
+					const forkWorkspaceId = `fork-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
+					const forkBranch = buildForkBranch(recoveredBranch, claimedTask.task.id, claimedTask.attemptN);
+					return {
+						...basePlan,
+						workspaceMode: "dedicated_worktree",
+						workspaceId: forkWorkspaceId,
+						worktreeBranch: forkBranch,
+						worktreeBaseRef: recoveredBranch,
+						workspaceKind: "fork",
+						sessionPersistence: {
+							sessionDir,
+							forkFromSessionPath: resolution.sessionPath
+						}
+					};
+				}
+				throw new ProducerContextResolutionError(`Cannot fork continuation of ${continueFrom.taskId}/${continueFrom.attemptN}: durable runtime session is available but the source attempt output did not report a branch`);
+			}
+			return {
+				...basePlan,
+				workspaceMode: "dedicated_worktree",
+				workspaceId: recoveredBranch ? `extend-${continueFrom.taskId}-attempt-${continueFrom.attemptN}` : null,
+				worktreeBranch: recoveredBranch,
+				sessionPersistence: {
+					sessionDir,
+					forkFromSessionPath: resolution.sessionPath
+				}
+			};
+		}
 		const parentBranch = resolution.producerSlot.workspace?.worktreeBranch ?? null;
 		if (continueFrom.mode === "fork") {
 			if (!parentBranch) throw new ProducerContextResolutionError(`Cannot fork continuation of ${continueFrom.taskId}/${continueFrom.attemptN}: producer slot has no worktree branch to fork from`);
 			const forkWorkspaceId = `fork-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
-			const forkBranch = `${parentBranch}-fork-${claimedTask.task.id.slice(0, 8)}-${claimedTask.attemptN}`;
+			const forkBranch = buildForkBranch(parentBranch, claimedTask.task.id, claimedTask.attemptN);
 			return {
 				...basePlan,
 				workspaceMode: "dedicated_worktree",
@@ -9739,6 +9853,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 	const resolution = await resolveWarmSlot(slotRegistry, runtimeSessionStore, claimedTask.task.teamId, targetTaskId, targetAttemptN, stateDirs);
 	if (resolution.kind === "missing") throw new ProducerContextResolutionError(`No live producer runtime slot found for task ${targetTaskId} attempt ${targetAttemptN}`);
 	if (resolution.kind === "no-session-path") throw new ProducerContextResolutionError(`Producer task ${targetTaskId} attempt ${targetAttemptN} has no persisted Pi session path`);
+	if (resolution.kind === "remote-session") throw new ProducerContextResolutionError(`Producer task ${targetTaskId} attempt ${targetAttemptN} has a durable runtime session but no workspace metadata to copy`);
 	return {
 		...basePlan,
 		workspaceMode: "scratch_mount",
@@ -9754,6 +9869,9 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		}
 	};
 }
+function buildForkBranch(parentBranch, childTaskId, childAttemptN) {
+	return `${parentBranch}-fork-${childTaskId.slice(0, 8)}-${childAttemptN}`;
+}
 function resolveProducerSessionPath(producer) {
 	const explicit = producer.session?.sessionPath ?? null;
 	if (explicit && existsSync(explicit)) return explicit;
@@ -9783,12 +9901,11 @@ function recoverScratchWorkspacePath(producer, stateDirs) {
 //#endregion
 //#region src/lib/finalize.ts
 /**
-* Build the `daemonState` payload for a `/complete` call. Only freeform
-* attempts that ran with a runtime slot are eligible for continuation
-* (`tasks_continue`, see issue #1287). Other task types and slot-less
-* freeform completions report `null` for `slotResumableUntil`, which
-* the server persists verbatim — continuations against such attempts
-* fail validation with `freeform.sourceNotResumeEligible`.
+* Build the `daemonState` payload for a `/complete` call. Freeform
+* attempts report the local warm-slot hint when one exists; slot-less
+* freeform completions report `null` for `slotResumableUntil`. The server
+* persists this verbatim as diagnostic/runtime metadata, not as the
+* continuation eligibility gate.
 *
 * Returns `null` for non-freeform task types so the field is omitted
 * from the request body (the server treats null and absent the same).
@@ -10082,6 +10199,11 @@ async function resolveRuntimeProfile(options) {
 		teamId: profile.teamId,
 		provider: profile.provider,
 		model: profile.model,
+		thinkingLevel: profile.thinkingLevel ?? null,
+		temperature: profile.temperature ?? null,
+		topP: profile.topP ?? null,
+		topK: profile.topK ?? null,
+		maxOutputTokens: profile.maxOutputTokens ?? null,
 		leaseTtlSec: profile.leaseTtlSec,
 		heartbeatIntervalMs: profile.heartbeatIntervalMs,
 		maxBatchSize: profile.maxBatchSize,
@@ -10127,7 +10249,15 @@ async function resolveProfileByName(options) {
 	const matches = (await options.agent.runtimeProfiles.list({ teamId: options.teamId })).items.filter((item) => item.name === options.profile);
 	if (matches.length === 0) throw new Error(`Runtime profile "${options.profile}" was not found in team ${options.teamId}.`);
 	if (matches.length > 1) throw new Error(`Runtime profile name "${options.profile}" is ambiguous in team ${options.teamId}. Use the profile UUID instead.`);
-	return matches[0];
+	const profile = matches[0];
+	return {
+		...profile,
+		thinkingLevel: profile.thinkingLevel ?? null,
+		temperature: profile.temperature ?? null,
+		topP: profile.topP ?? null,
+		topK: profile.topK ?? null,
+		maxOutputTokens: profile.maxOutputTokens ?? null
+	};
 }
 function isExecutableOnPath(tool, pathValue) {
 	if (tool.includes("/")) return isExecutable(isAbsolute(tool) ? tool : resolve(process.cwd(), tool));
@@ -10268,6 +10398,34 @@ function createApiRuntimeSlotStore(args) {
 				} : null
 			};
 		},
+		async listSlots(input) {
+			const query = {
+				agentName: input.agentName,
+				...input.limit === void 0 ? {} : { limit: input.limit },
+				...input.runtimeProfileId === void 0 ? {} : { runtimeProfileId: input.runtimeProfileId },
+				...input.state === void 0 ? {} : { state: input.state }
+			};
+			return (await agent.runtimeSlots.list(query, { teamId: input.teamId })).map((resolved) => ({
+				slot: {
+					expiresAtMs: resolved.slot.expiresAtMs,
+					id: resolved.slot.id,
+					lastAttemptN: resolved.slot.lastAttemptN,
+					lastTaskId: resolved.slot.lastTaskId,
+					runtimeProfileId: resolved.slot.runtimeProfileId,
+					taskType: resolved.slot.taskType
+				},
+				session: resolved.slot.sessionDir ? {
+					sessionDir: resolved.slot.sessionDir,
+					sessionPath: resolved.slot.sessionPath
+				} : null,
+				workspace: resolved.workspace ? {
+					kind: resolved.workspace.kind,
+					workspaceId: resolved.workspace.workspaceId,
+					worktreeBranch: resolved.workspace.worktreeBranch,
+					worktreePath: resolved.workspace.worktreePath
+				} : null
+			}));
+		},
 		async close() {}
 	};
 }
@@ -10304,6 +10462,21 @@ function signalExitCode(signal) {
 	return signal === "SIGINT" ? 130 : 143;
 }
 //#endregion
+//#region src/lib/source-attempts.ts
+function createApiSourceAttemptResolver(args) {
+	const { agent } = args;
+	return { async findOutputBranch(input) {
+		const attempt = (await agent.tasks.listAttempts(input.taskId)).find((candidate) => candidate.attemptN === input.attemptN);
+		if (!attempt || attempt.status !== "completed") return null;
+		return resolveOutputBranch(attempt.output);
+	} };
+}
+function resolveOutputBranch(output) {
+	if (!output || typeof output !== "object") return null;
+	const branch = output.branch;
+	return typeof branch === "string" && branch.length > 0 ? branch : null;
+}
+//#endregion
 //#region src/lib/state-dir.ts
 function ensureDaemonStateDirs(mountPath) {
 	const rootDir = join(mountPath, ".moltnet", "d");
@@ -10411,6 +10584,7 @@ async function runPolling(opts) {
 	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 runtimes = /* @__PURE__ */ new Map();
 	for (const profile of profiles) {
 		const common = parseCommonOptions(values, { runtimeDefaults: {
@@ -10441,7 +10615,8 @@ async function runPolling(opts) {
 				allowedWorkspaceModes: profile.allowedWorkspaceModes
 			},
 			slotRegistry,
-			runtimeSessionStore
+			runtimeSessionStore,
+			sourceAttemptResolver
 		});
 		runtimes.set(profile.id, {
 			common,
@@ -10514,6 +10689,11 @@ async function runPolling(opts) {
 				name: profile.name,
 				provider: profile.provider,
 				model: profile.model,
+				thinkingLevel: profile.thinkingLevel,
+				temperature: profile.temperature,
+				topP: profile.topP,
+				topK: profile.topK,
+				maxOutputTokens: profile.maxOutputTokens,
 				sandbox: runtime.sandbox.path,
 				leaseTtlSec: runtime.common.leaseTtlSec,
 				heartbeatIntervalMs: runtime.common.heartbeatIntervalMs,
@@ -10551,7 +10731,8 @@ async function runPolling(opts) {
 				debug: baseCommon.debug,
 				logger: rootLogger,
 				slotRegistry,
-				sessionRegistry: runtimeSessionStore
+				sessionRegistry: runtimeSessionStore,
+				sourceAttemptResolver
 			}),
 			makeReporter: (claimedTask) => {
 				const selected = runtimeForClaimedTask(runtimes, claimedTask);
@@ -10606,7 +10787,12 @@ async function runPolling(opts) {
 					runtimeProfileId: profile.id,
 					runtimeProfileName: profile.name,
 					provider: profile.provider,
-					model: profile.model
+					model: profile.model,
+					thinkingLevel: profile.thinkingLevel,
+					temperature: profile.temperature,
+					topP: profile.topP,
+					topK: profile.topK,
+					maxOutputTokens: profile.maxOutputTokens
 				});
 				let executionPlan;
 				try {
@@ -10707,6 +10893,11 @@ async function runPolling(opts) {
 					mountPath: sandbox.rootDir,
 					provider: profile.provider,
 					model: profile.model,
+					thinkingLevel: profile.thinkingLevel,
+					temperature: profile.temperature,
+					topP: profile.topP,
+					topK: profile.topK,
+					maxOutputTokens: profile.maxOutputTokens,
 					sandboxConfig: sandbox.config,
 					makeExecutionPlan: (task) => executionPlans.getOrCreate(task),
 					makeOnTurnEvent: makeTurnEventHandlerFactory(taskLogger),
@@ -10722,7 +10913,12 @@ async function runPolling(opts) {
 						profileId: profile.id,
 						profileName: profile.name,
 						provider: profile.provider,
-						model: profile.model
+						model: profile.model,
+						thinkingLevel: profile.thinkingLevel,
+						temperature: profile.temperature,
+						topP: profile.topP,
+						topK: profile.topK,
+						maxOutputTokens: profile.maxOutputTokens
 					}, () => rawExecuteTask(claimedTask, reporter));
 				} finally {
 					active = null;
@@ -10853,6 +11049,7 @@ async function runOnce(argv) {
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({ agent: ctx.agent });
+	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
 	const slotIdentity = {
 		agentName: opts.agent,
 		runtimeProfileId: profile.id
@@ -10866,7 +11063,8 @@ async function runOnce(argv) {
 			allowedWorkspaceModes: profile.allowedWorkspaceModes
 		},
 		slotRegistry,
-		runtimeSessionStore
+		runtimeSessionStore,
+		sourceAttemptResolver
 	});
 	const otelShutdown = await initWorkerOtel({
 		serviceName: "moltnet.agent-daemon.once",
@@ -10877,6 +11075,11 @@ async function runOnce(argv) {
 			"moltnet.agent.name": opts.agent,
 			"moltnet.llm.provider": profile.provider,
 			"moltnet.llm.model": profile.model,
+			...profile.thinkingLevel ? { "moltnet.llm.thinking_level": profile.thinkingLevel } : {},
+			...profile.temperature !== null ? { "moltnet.llm.temperature": String(profile.temperature) } : {},
+			...profile.topP !== null ? { "moltnet.llm.top_p": String(profile.topP) } : {},
+			...profile.topK !== null ? { "moltnet.llm.top_k": String(profile.topK) } : {},
+			...profile.maxOutputTokens !== null ? { "moltnet.llm.max_output_tokens": String(profile.maxOutputTokens) } : {},
 			"moltnet.runtime_profile.id": profile.id
 		}
 	});
@@ -10889,6 +11092,11 @@ async function runOnce(argv) {
 		agent: opts.agent,
 		provider: profile.provider,
 		model: profile.model,
+		thinkingLevel: profile.thinkingLevel,
+		temperature: profile.temperature,
+		topP: profile.topP,
+		topK: profile.topK,
+		maxOutputTokens: profile.maxOutputTokens,
 		runtimeProfileId: profile.id,
 		runtimeProfileName: profile.name
 	});
@@ -10939,6 +11147,11 @@ async function runOnce(argv) {
 			mountPath: sandbox.rootDir,
 			provider: profile.provider,
 			model: profile.model,
+			thinkingLevel: profile.thinkingLevel,
+			temperature: profile.temperature,
+			topP: profile.topP,
+			topK: profile.topK,
+			maxOutputTokens: profile.maxOutputTokens,
 			sandboxConfig: sandbox.config,
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
@@ -10997,7 +11210,12 @@ async function runOnce(argv) {
 					profileId: profile.id,
 					profileName: profile.name,
 					provider: profile.provider,
-					model: profile.model
+					model: profile.model,
+					thinkingLevel: profile.thinkingLevel,
+					temperature: profile.temperature,
+					topP: profile.topP,
+					topK: profile.topK,
+					maxOutputTokens: profile.maxOutputTokens
 				}, () => rawExecuteTask(claimedTask, reporter));
 			} finally {
 				activeAttemptN = null;
@@ -11087,6 +11305,182 @@ function runPoll(argv) {
 	});
 }
 //#endregion
+//#region src/lib/runtime-session-sync.ts
+async function syncRuntimeSessions(deps, input) {
+	const result = {
+		alreadyCurrent: 0,
+		failedUpload: 0,
+		missingLocalFile: 0,
+		scanned: 0,
+		unsafeSessionPath: 0,
+		uploaded: 0,
+		wouldUpload: 0
+	};
+	const slots = await deps.runtimeSlotStore.listSlots({
+		agentName: input.agentName,
+		limit: input.limit,
+		runtimeProfileId: input.runtimeProfileId,
+		state: input.state,
+		teamId: input.teamId
+	});
+	for (const slot of slots) {
+		result.scanned++;
+		if (!slot.session?.sessionDir) {
+			result.missingLocalFile++;
+			continue;
+		}
+		if (input.sessionRootDir && !await isPathInsideRoot(slot.session.sessionDir, input.sessionRootDir)) {
+			result.unsafeSessionPath++;
+			continue;
+		}
+		const sessionPath = resolveLatestPiSessionPath(slot.session.sessionDir);
+		if (!sessionPath || !await fileExists(sessionPath)) {
+			result.missingLocalFile++;
+			continue;
+		}
+		const remote = await deps.runtimeSessionStore.findRuntimeSessionByTaskAttempt(input.teamId, slot.slot.lastTaskId, slot.slot.lastAttemptN);
+		if (remote) {
+			const local = await computeCompressedSessionFingerprint(sessionPath);
+			if (remote.sha256 === local.sha256 && remote.sizeBytes === local.bytes) {
+				result.alreadyCurrent++;
+				continue;
+			}
+		}
+		if (input.dryRun) {
+			result.wouldUpload++;
+			continue;
+		}
+		try {
+			const task = await deps.taskReader.get(slot.slot.lastTaskId);
+			const claim = {
+				attemptN: slot.slot.lastAttemptN,
+				task: {
+					id: task.id,
+					input: task.input,
+					teamId: input.teamId
+				}
+			};
+			const parent = await resolveParentRuntimeSession(deps.runtimeSessionStore, claim);
+			await deps.runtimeSessionStore.uploadAttemptFinal({
+				attemptN: slot.slot.lastAttemptN,
+				parentSessionId: parent?.id ?? null,
+				sessionDir: slot.session.sessionDir,
+				sessionKind: resolveRuntimeSessionKind(claim),
+				sourceRuntimeProfileId: slot.slot.runtimeProfileId,
+				sourceSlotId: slot.slot.id,
+				taskId: slot.slot.lastTaskId,
+				teamId: input.teamId
+			});
+			result.uploaded++;
+		} catch {
+			result.failedUpload++;
+		}
+	}
+	return result;
+}
+async function fileExists(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function isPathInsideRoot(path, root) {
+	if (!isResolvedPathInsideRoot(resolve(path), resolve(root))) return false;
+	let realResolvedPath;
+	let realResolvedRoot;
+	try {
+		[realResolvedPath, realResolvedRoot] = await Promise.all([realpath(path), realpath(root)]);
+	} catch {
+		return true;
+	}
+	return isResolvedPathInsideRoot(realResolvedPath, realResolvedRoot);
+}
+function isResolvedPathInsideRoot(path, root) {
+	const rel = relative(root, path);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function computeCompressedSessionFingerprint(path) {
+	const hash = createHash("sha256");
+	let bytes = 0;
+	const sink = new Writable({ write(chunk, _encoding, callback) {
+		bytes += chunk.byteLength;
+		hash.update(chunk);
+		callback();
+	} });
+	await pipeline(createReadStream(path), createGzip(), sink);
+	return {
+		bytes,
+		sha256: hash.digest("hex")
+	};
+}
+//#endregion
+//#region src/cli/sync-sessions.ts
+async function runSyncSessions(argv) {
+	if (isHelpFlag(argv)) {
+		console.log(SYNC_SESSIONS_HELP);
+		return 0;
+	}
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			...commonOptionDefs(),
+			team: { type: "string" },
+			"runtime-profile-id": { type: "string" },
+			state: { type: "string" },
+			limit: { type: "string" },
+			"dry-run": { type: "boolean" }
+		}
+	});
+	if (!values.team) {
+		console.error("Missing required flag: --team\n");
+		console.error(SYNC_SESSIONS_HELP);
+		return 1;
+	}
+	let opts;
+	try {
+		opts = parseCommonOptions(values);
+	} catch (err) {
+		if (err instanceof MissingRequiredOptionError) {
+			console.error(`${err.message}\n`);
+			console.error(SYNC_SESSIONS_HELP);
+			return 1;
+		}
+		throw err;
+	}
+	const state = parseState(values.state);
+	const limit = parseLimit(values.limit);
+	const agentRootDir = resolve(process.cwd(), values["agent-root"] ?? process.cwd());
+	const ctx = await resolveAgentContext(opts.agent, { agentRootDir });
+	const stateDirs = ensureDaemonStateDirs(agentRootDir);
+	const result = await syncRuntimeSessions({
+		runtimeSessionStore: createApiRuntimeSessionStore({ agent: ctx.agent }),
+		runtimeSlotStore: createApiRuntimeSlotStore({ agent: ctx.agent }),
+		taskReader: ctx.agent.tasks
+	}, {
+		agentName: opts.agent,
+		dryRun: values["dry-run"] === true,
+		limit,
+		runtimeProfileId: values["runtime-profile-id"],
+		sessionRootDir: stateDirs.piSessionsDir,
+		state,
+		teamId: values.team
+	});
+	console.log(JSON.stringify(result, null, 2));
+	return result.failedUpload > 0 || result.unsafeSessionPath > 0 ? 1 : 0;
+}
+function parseState(raw) {
+	if (raw === void 0) return void 0;
+	if (raw === "active" || raw === "idle") return raw;
+	throw new Error(`Invalid --state "${raw}": expected active or idle`);
+}
+function parseLimit(raw) {
+	if (raw === void 0) return void 0;
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value < 1 || value > 200) throw new Error(`Invalid --limit "${raw}": expected integer 1..200`);
+	return value;
+}
+//#endregion
 //#region src/main.ts
 async function main() {
 	const [, , subcommand, ...rest] = process.argv;
@@ -11094,6 +11488,7 @@ async function main() {
 		case "poll": return runPoll(rest);
 		case "once": return runOnce(rest);
 		case "drain": return runDrain(rest);
+		case "sync-sessions": return runSyncSessions(rest);
 		case "-h":
 		case "--help":
 			console.log(ROOT_USAGE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.25.1",
+  "version": "0.27.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.",
@@ -45,9 +45,9 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "@themoltnet/pi-extension": "0.27.2",
-    "@themoltnet/sdk": "0.113.1",
-    "@themoltnet/agent-runtime": "0.30.1"
+    "@themoltnet/agent-runtime": "0.31.1",
+    "@themoltnet/pi-extension": "0.28.0",
+    "@themoltnet/sdk": "0.114.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
@@ -55,9 +55,9 @@
     "vite": "^8.0.0",
     "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/crypto-service": "0.1.0"
   },
   "nx": {
     "tags": [
@@ -74,6 +74,9 @@
           "^production",
           "{projectRoot}/vitest.config.e2e.ts",
           "{projectRoot}/e2e/**/*",
+          {
+            "env": "MOLTNET_AGENT_DAEMON_LIVE_LLM_E2E"
+          },
           {
             "externalDependencies": [
               "vitest"