@themoltnet/agent-daemon 0.19.1 → 0.20.0

package/README.md

@@ -181,9 +181,9 @@ workspace shape in `input.execution.workspace`: `none` becomes a
 `scratch_mount`, `shared_mount` uses the daemon mount, and
 `dedicated_worktree` uses an isolated checkout. Downstream
 `judge_eval_attempt` tasks only resolve against a still-live producer
-session/workspace slot. If the producer slot has already expired and been
-reaped, the judge fails with `producer_context_missing`. When the judge does
-claim in time, it immediately forks the producer session and copies the
+session/workspace slot. If the producer slot or its local session/workspace
+files cannot be resolved, the judge fails with `producer_context_missing`.
+When the judge does claim in time, it immediately forks the producer session and copies the
 producer workspace into judge-owned scratch state so the running judge no
 longer depends on the producer slot after claim time. Repo-specific
 `resumeCommands` that should not run in scratch mode must still be guarded

package/dist/main.js

@@ -9,11 +9,10 @@ import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import crypto from "crypto";
 import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { parseArgs, promisify } from "node:util";
-import { DaemonSlotRegistry, resolveDaemonStateStorageConfig, resolveLatestPiSessionPath } from "@themoltnet/agent-daemon-state";
 import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource } from "@themoltnet/agent-runtime";
 import { createPiTaskExecutor, findMainWorktree } from "@themoltnet/pi-extension";
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { MoltNetError, connect } from "@themoltnet/sdk";
 import { once } from "node:events";
 import { pino, transport } from "pino";
@@ -4547,6 +4546,117 @@ _Object_({
 	additionalProperties: false
 });
 //#endregion
+//#region ../../libs/tasks/src/runtime-slots.ts
+var RuntimeWorkspaceKind = Union([
+	Literal("origin"),
+	Literal("fork"),
+	Literal("scratch")
+]);
+var RuntimeSlotState = Union([Literal("active"), Literal("idle")]);
+var RuntimeWorkspace = _Object_({
+	id: String$1({ format: "uuid" }),
+	teamId: String$1({ format: "uuid" }),
+	workspaceId: String$1({ minLength: 1 }),
+	worktreePath: String$1({ minLength: 1 }),
+	worktreeBranch: Union([String$1({ minLength: 1 }), Null()]),
+	kind: RuntimeWorkspaceKind,
+	createdAtMs: Integer({ minimum: 0 }),
+	lastUsedAtMs: Integer({ minimum: 0 })
+}, { $id: "RuntimeWorkspace" });
+_Object_({
+	slot: _Object_({
+		id: String$1({ format: "uuid" }),
+		teamId: String$1({ format: "uuid" }),
+		agentName: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		daemonProfileId: Union([String$1({ format: "uuid" }), Null()]),
+		provider: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		model: String$1({
+			minLength: 1,
+			maxLength: 200
+		}),
+		slotKey: String$1({ minLength: 1 }),
+		taskType: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		state: RuntimeSlotState,
+		lastTaskId: String$1({ format: "uuid" }),
+		lastAttemptN: Integer({ minimum: 1 }),
+		sessionDir: Union([String$1({ minLength: 1 }), Null()]),
+		sessionPath: Union([String$1({ minLength: 1 }), Null()]),
+		workspaceRowId: Union([String$1({ format: "uuid" }), Null()]),
+		createdAtMs: Integer({ minimum: 0 }),
+		lastUsedAtMs: Integer({ minimum: 0 }),
+		expiresAtMs: Integer({ minimum: 0 })
+	}, { $id: "RuntimeSlot" }),
+	workspace: Union([RuntimeWorkspace, Null()])
+}, { $id: "ResolvedRuntimeSlot" });
+_Object_({
+	agentName: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	daemonProfileId: Optional(String$1({ format: "uuid" })),
+	provider: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	model: String$1({
+		minLength: 1,
+		maxLength: 200
+	}),
+	slotKey: String$1({ minLength: 1 }),
+	taskType: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	sessionDir: Optional(String$1({ minLength: 1 })),
+	sessionPath: Optional(String$1({ minLength: 1 })),
+	workspaceId: Optional(String$1({ minLength: 1 })),
+	worktreePath: Optional(String$1({ minLength: 1 })),
+	worktreeBranch: Optional(String$1({ minLength: 1 })),
+	workspaceKind: Optional(RuntimeWorkspaceKind),
+	lastTaskId: String$1({ format: "uuid" }),
+	lastAttemptN: Integer({ minimum: 1 })
+}, {
+	$id: "BeginRuntimeSlotBody",
+	additionalProperties: false
+});
+_Object_({
+	agentName: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	provider: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	model: String$1({
+		minLength: 1,
+		maxLength: 200
+	}),
+	slotKey: String$1({ minLength: 1 }),
+	taskId: String$1({ format: "uuid" }),
+	attemptN: Integer({ minimum: 1 }),
+	sessionPath: Optional(String$1({ minLength: 1 }))
+}, {
+	$id: "FinishRuntimeSlotBody",
+	additionalProperties: false
+});
+_Object_({
+	taskId: String$1({ format: "uuid" }),
+	attemptN: Integer({ minimum: 1 })
+}, {
+	$id: "FindLatestRuntimeSlotForAttemptQuery",
+	additionalProperties: false
+});
+//#endregion
 //#region ../../libs/tasks/src/success-criteria.ts
 /**
 * SuccessCriteria — proposer-stated acceptance criteria, evaluated in two
@@ -9042,9 +9152,8 @@ var COMMON_OPTIONAL_FLAGS = `\
                               this, the pi session aborts and the attempt
                               fails with code 'max_bash_timeouts_exceeded'.
                               0 = disabled. Default: 3.
-  --warm-session-ttl-sec <n>  Retain resumable daemon slots (Pi sessions +
-                              reusable worktrees) in local daemon state for
-                              this many seconds after use. 0 = disable reuse.
+  --warm-session-ttl-sec <n>  Resumability window for runtime slots
+                              (Pi sessions + reusable worktrees) after use.
                               Default: 1800, or min(profile session/workspace
                               TTL) when --profile is set.
   --debug                     Verbose logging: also log successful list/claim
@@ -9166,7 +9275,6 @@ function isHelpFlag(args) {
 //#region src/config.ts
 function loadConfig() {
 	return {
-		agentDaemonStateDatabaseUrl: process.env["MOLTNET_AGENT_DAEMON_STATE_DATABASE_URL"] ?? "",
 		otelEndpoint: process.env["MOLTNET_OTEL_ENDPOINT"] ?? "",
 		logLevel: process.env["LOG_LEVEL"] ?? "",
 		profilePrerequisiteEnv: process.env,
@@ -9265,6 +9373,16 @@ function createGhCliClient() {
 	};
 }
 //#endregion
+//#region src/lib/session-files.ts
+function resolveLatestPiSessionPath(sessionDir) {
+	try {
+		const latestEntry = readdirSync(sessionDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort().at(-1);
+		return latestEntry ? join(sessionDir, latestEntry) : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/lib/slugify.ts
 function slugifyAsciiLower(input, maxLen, preserveChars = []) {
 	const preserved = new Set(preserveChars.map((char) => char.toLowerCase()));
@@ -9419,8 +9537,8 @@ function createExecutionPlanCache(args) {
 function buildClaimedTaskKey(task) {
 	return `${task.task.id}:${task.attemptN}`;
 }
-async function resolveWarmSlot(slotRegistry, sourceTaskId, sourceAttemptN, stateDirs) {
-	const producerContext = await slotRegistry.findLatestProducerSlotByTaskAttempt(sourceTaskId, sourceAttemptN);
+async function resolveWarmSlot(slotRegistry, teamId, sourceTaskId, sourceAttemptN, stateDirs) {
+	const producerContext = await slotRegistry.findLatestSlotByTaskAttempt(teamId, sourceTaskId, sourceAttemptN);
 	if (!producerContext) return { kind: "missing" };
 	const sourceSessionPath = resolveProducerSessionPath(producerContext);
 	if (!sourceSessionPath) return { kind: "no-session-path" };
@@ -9435,8 +9553,8 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 	if (claimedTask.task.taskType === "freeform") {
 		const continueFrom = claimedTask.task.input.continueFrom;
 		if (!continueFrom) return basePlan;
-		const resolution = await resolveWarmSlot(slotRegistry, continueFrom.taskId, continueFrom.attemptN, stateDirs);
-		if (resolution.kind === "missing") throw new ProducerContextResolutionError(`Continuation source task ${continueFrom.taskId} attempt ${continueFrom.attemptN} has no live daemon slot on this daemon — claim affinity filter should have prevented this claim`);
+		const resolution = await resolveWarmSlot(slotRegistry, 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 === "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}`;
 		const parentBranch = resolution.producerSlot.workspace?.worktreeBranch ?? null;
@@ -9472,8 +9590,8 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 	const targetTaskId = typeof claimedTask.task.input.targetTaskId === "string" ? claimedTask.task.input.targetTaskId : null;
 	const targetAttemptN = typeof claimedTask.task.input.targetAttemptN === "number" ? claimedTask.task.input.targetAttemptN : null;
 	if (!targetTaskId || !targetAttemptN) throw new ProducerContextResolutionError("judge_eval_attempt is missing targetTaskId/targetAttemptN");
-	const resolution = await resolveWarmSlot(slotRegistry, targetTaskId, targetAttemptN, stateDirs);
-	if (resolution.kind === "missing") throw new ProducerContextResolutionError(`No live producer daemon slot found for task ${targetTaskId} attempt ${targetAttemptN}`);
+	const resolution = await resolveWarmSlot(slotRegistry, 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`);
 	return {
 		...basePlan,
@@ -9520,7 +9638,7 @@ function recoverScratchWorkspacePath(producer, stateDirs) {
 //#region src/lib/finalize.ts
 /**
 * Build the `daemonState` payload for a `/complete` call. Only freeform
-* attempts that ran with a warm slot are eligible for continuation
+* 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
@@ -9866,6 +9984,63 @@ function isExecutable(path) {
 	}
 }
 //#endregion
+//#region src/lib/runtime-slots.ts
+function createApiRuntimeSlotStore(args) {
+	const { agent, daemonProfileId } = args;
+	return {
+		async beginSlot(input) {
+			await agent.runtimeSlots.begin({
+				agentName: input.agentName,
+				daemonProfileId: daemonProfileId ?? void 0,
+				lastAttemptN: input.lastAttemptN,
+				lastTaskId: input.lastTaskId,
+				model: input.model,
+				provider: input.provider,
+				sessionDir: input.sessionDir ?? void 0,
+				sessionPath: input.sessionPath ?? void 0,
+				slotKey: input.slotKey,
+				taskType: input.taskType,
+				workspaceId: input.workspaceId ?? void 0,
+				workspaceKind: input.workspaceKind,
+				worktreeBranch: input.worktreeBranch ?? void 0,
+				worktreePath: input.worktreePath ?? void 0
+			}, { teamId: input.teamId });
+		},
+		async finishSlot(teamId, taskId, attemptN, identity, slotKey, sessionPath) {
+			await agent.runtimeSlots.finish({
+				agentName: identity.agentName,
+				attemptN,
+				model: identity.model,
+				provider: identity.provider,
+				sessionPath: sessionPath ?? void 0,
+				slotKey,
+				taskId
+			}, { teamId });
+		},
+		async findLatestSlotByTaskAttempt(teamId, taskId, attemptN) {
+			const resolved = await agent.runtimeSlots.findLatestForAttempt({
+				attemptN,
+				taskId
+			}, { teamId });
+			if (!resolved) return null;
+			return {
+				slot: { expiresAtMs: resolved.slot.expiresAtMs },
+				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() {}
+	};
+}
+//#endregion
 //#region src/lib/sandbox.ts
 function resolveSandbox(startDir, explicitPath) {
 	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(startDir, explicitPath) : findUp(startDir, "sandbox.json");
@@ -9933,8 +10108,7 @@ function ensureDaemonStateDirs(mountPath) {
 	mkdirSync(piSessionsDir, { recursive: true });
 	return {
 		rootDir,
-		piSessionsDir,
-		registryDbPath: join(rootDir, "daemon-state.sqlite")
+		piSessionsDir
 	};
 }
 //#endregion
@@ -10044,7 +10218,10 @@ async function runPolling(opts) {
 	const piAgentDir = ensurePiAgentDir(sandbox.rootDir, cfg.piCodingAgentDir);
 	activatePiCodingAgentDir(piAgentDir.path);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
-	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
+	const slotRegistry = createApiRuntimeSlotStore({
+		agent: ctx.agent,
+		daemonProfileId: profile?.id ?? null
+	});
 	const slotIdentity = {
 		agentName: common.agent,
 		provider,
@@ -10174,7 +10351,7 @@ async function runPolling(opts) {
 				flushIntervalMs: common.flushIntervalMs
 			}),
 			onTaskFinished: async (output, claimedTask) => {
-				const resolved = await slotRegistry.findLatestProducerSlotByTaskAttempt(claimedTask.task.id, claimedTask.attemptN);
+				const resolved = await slotRegistry.findLatestSlotByTaskAttempt(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN);
 				return finalizeTask(ctx.agent, output, {
 					task: claimedTask.task,
 					slot: resolved ? { expiresAtMs: resolved.slot.expiresAtMs } : null,
@@ -10215,19 +10392,6 @@ async function runPolling(opts) {
 					};
 				}
 				const sessionDescriptor = executionPlan.descriptor;
-				let expired;
-				try {
-					expired = await slotRegistry.reapExpiredSlots();
-					if (expired.length > 0) rootLogger.info({
-						expiredCount: expired.length,
-						slotKeys: expired.map((item) => item.slot.slotKey)
-					}, "agent-daemon.daemon_slots_reaped");
-				} catch (err) {
-					rootLogger.error({
-						phase: "daemon_slot_reap",
-						err: err instanceof Error ? err.message : String(err)
-					}, "agent-daemon.daemon_slot_reap_failed");
-				}
 				rootLogger.debug({
 					taskId: claimedTask.task.id,
 					taskType: claimedTask.task.taskType,
@@ -10277,6 +10441,7 @@ async function runPolling(opts) {
 				};
 				if (executionPlan.slotKey && executionPlan.sessionPersistence) await slotRegistry.beginSlot({
 					...slotIdentity,
+					teamId: claimedTask.task.teamId,
 					slotKey: executionPlan.slotKey,
 					taskType: claimedTask.task.taskType,
 					sessionDir: executionPlan.sessionPersistence.sessionDir,
@@ -10286,14 +10451,13 @@ async function runPolling(opts) {
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
-					lastAttemptN: claimedTask.attemptN,
-					ttlSec: common.warmSessionTtlSec
+					lastAttemptN: claimedTask.attemptN
 				});
 				try {
 					return await executeTask(claimedTask, reporter);
 				} finally {
 					executionPlans.delete(claimedTask);
-					if (executionPlan.slotKey) await slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, common.warmSessionTtlSec, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+					if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
 				}
 			}
 		});
@@ -10402,7 +10566,10 @@ async function runOnce(argv) {
 	const piAgentDir = ensurePiAgentDir(sandbox.rootDir, cfg.piCodingAgentDir);
 	activatePiCodingAgentDir(piAgentDir.path);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
-	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
+	const slotRegistry = createApiRuntimeSlotStore({
+		agent: ctx.agent,
+		daemonProfileId: profile?.id ?? null
+	});
 	const slotIdentity = {
 		agentName: opts.agent,
 		provider,
@@ -10494,18 +10661,6 @@ async function runOnce(argv) {
 			maxBashTimeouts: opts.maxBashTimeouts
 		});
 		const executeTask = async (claimedTask, reporter) => {
-			try {
-				const expired = await slotRegistry.reapExpiredSlots();
-				if (expired.length > 0) rootLogger.info({
-					expiredCount: expired.length,
-					slotKeys: expired.map((item) => item.slot.slotKey)
-				}, "agent-daemon.daemon_slots_reaped");
-			} catch (err) {
-				rootLogger.error({
-					phase: "daemon_slot_reap",
-					err: err instanceof Error ? err.message : String(err)
-				}, "agent-daemon.daemon_slot_reap_failed");
-			}
 			let executionPlan;
 			try {
 				executionPlan = await executionPlans.getOrCreate(claimedTask);
@@ -10536,6 +10691,7 @@ async function runOnce(argv) {
 			}
 			if (executionPlan.slotKey && executionPlan.sessionPersistence) await slotRegistry.beginSlot({
 				...slotIdentity,
+				teamId: claimedTask.task.teamId,
 				slotKey: executionPlan.slotKey,
 				taskType: claimedTask.task.taskType,
 				sessionDir: executionPlan.sessionPersistence.sessionDir,
@@ -10545,8 +10701,7 @@ async function runOnce(argv) {
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
-				lastAttemptN: claimedTask.attemptN,
-				ttlSec: opts.warmSessionTtlSec
+				lastAttemptN: claimedTask.attemptN
 			});
 			activeAttemptN = claimedTask.attemptN;
 			try {
@@ -10554,7 +10709,7 @@ async function runOnce(argv) {
 			} finally {
 				activeAttemptN = null;
 				executionPlans.delete(claimedTask);
-				if (executionPlan.slotKey) await slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, opts.warmSessionTtlSec, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+				if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
 			}
 		};
 		const writeCorrelationAnchors = makePrBodyAnchorWriter({
@@ -10577,7 +10732,7 @@ async function runOnce(argv) {
 				flushIntervalMs: opts.flushIntervalMs
 			}),
 			onTaskFinished: async (output, claimedTask) => {
-				const resolved = await slotRegistry.findLatestProducerSlotByTaskAttempt(claimedTask.task.id, claimedTask.attemptN);
+				const resolved = await slotRegistry.findLatestSlotByTaskAttempt(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN);
 				return finalizeTask(ctx.agent, output, {
 					task: claimedTask.task,
 					slot: resolved ? { expiresAtMs: resolved.slot.expiresAtMs } : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.19.1",
+  "version": "0.20.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,20 +45,19 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "@themoltnet/agent-daemon-state": "0.3.0",
-    "@themoltnet/sdk": "0.108.0",
-    "@themoltnet/agent-runtime": "0.26.0",
-    "@themoltnet/pi-extension": "0.26.0"
+    "@themoltnet/agent-runtime": "0.27.0",
+    "@themoltnet/pi-extension": "0.26.1",
+    "@themoltnet/sdk": "0.109.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
     "typescript": "~5.9.2",
     "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/bootstrap": "0.1.0"
+    "@moltnet/tasks": "0.1.0"
   },
   "nx": {
     "tags": [
@@ -94,8 +93,7 @@
     "dev": "tsx watch src/main.ts",
     "start": "node dist/main.js",
     "build": "vite build",
-    "check:pack": "tsx ../../tools/src/check-pack.ts --package . && pnpm run smoke:pack && pnpm run smoke:pack:state",
-    "smoke:pack": "tsx ../../tools/src/smoke-pack.ts --package . --bin moltnet-agent --args --help --expect \"long-running task worker for MoltNet\"",
-    "smoke:pack:state": "tsx ../../tools/src/smoke-agent-daemon-state-pack.ts"
+    "check:pack": "tsx ../../tools/src/check-pack.ts --package . && pnpm run smoke:pack",
+    "smoke:pack": "tsx ../../tools/src/smoke-pack.ts --package . --bin moltnet-agent --args --help --expect \"long-running task worker for MoltNet\""
   }
 }