@themoltnet/agent-daemon 0.26.0 → 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
 /**
@@ -9235,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.
 
@@ -9325,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");
 }
@@ -10120,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,
@@ -10165,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));
@@ -10306,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() {}
 	};
 }
@@ -10569,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,
@@ -10662,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 {
@@ -10763,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),
@@ -10778,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;
@@ -10935,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
 		}
 	});
@@ -10947,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
 	});
@@ -10997,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 }),
@@ -11055,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;
@@ -11145,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;
@@ -11152,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.26.0",
+  "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,19 +45,19 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "@themoltnet/pi-extension": "0.27.3",
-    "@themoltnet/sdk": "0.113.1",
-    "@themoltnet/agent-runtime": "0.31.0"
+    "@themoltnet/agent-runtime": "0.31.1",
+    "@themoltnet/pi-extension": "0.28.0",
+    "@themoltnet/sdk": "0.114.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
     "typescript": "~5.9.2",
     "vite": "^8.0.0",
     "vitest": "^3.0.0",
+    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/observability": "0.1.0",
     "@moltnet/tasks": "0.1.0",
-    "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/bootstrap": "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"