@themoltnet/agent-daemon 0.18.0 → 0.19.0

package/dist/main.js

@@ -8,12 +8,13 @@ import { PgInstrumentation } from "@opentelemetry/instrumentation-pg";
 import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
 import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import crypto$1, { createHash } from "crypto";
-import { createHash as createHash$1 } from "node:crypto";
+import crypto$2, { createHash as createHash$1 } from "node:crypto";
 import path, { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs, parseEnv, promisify } from "node:util";
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import fs, { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
+import { fileURLToPath } from "node:url";
 import { ROOT_CONTEXT, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { pino, transport } from "pino";
 import { readFile } from "node:fs/promises";
@@ -4375,6 +4376,54 @@ function validateRubricWeights(rubric) {
 	return null;
 }
 //#endregion
+//#region ../../libs/tasks/src/runtime-models.ts
+/**
+* Runtime model catalog: a list of supported provider/model couples that
+* MoltNet daemons can target. Backed by the `runtime_models` table.
+*
+* Scope is intrinsic to the row:
+*   - `teamId == null`  => global entry (MoltNet-seeded, read-only to most callers)
+*   - `teamId != null`  => team-owned custom entry
+*
+* The REST API exposes a single shape regardless of scope; the team header
+* gates which rows are returned.
+*/
+var RuntimeModelProvider = String$1({
+	minLength: 1,
+	maxLength: 100,
+	pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$"
+});
+var RuntimeModelName = String$1({
+	minLength: 1,
+	maxLength: 200,
+	pattern: "^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$"
+});
+var RuntimeModelCapabilities = Record(String$1({
+	minLength: 1,
+	maxLength: 64
+}), Union([
+	Boolean$1(),
+	Number$1(),
+	String$1({ maxLength: 256 })
+]));
+_Object_({
+	id: String$1({ format: "uuid" }),
+	teamId: Union([String$1({ format: "uuid" }), Null()]),
+	provider: RuntimeModelProvider,
+	model: RuntimeModelName,
+	displayName: Union([String$1({ maxLength: 200 }), Null()]),
+	description: Union([String$1({ maxLength: 4096 }), Null()]),
+	capabilities: RuntimeModelCapabilities,
+	isActive: Boolean$1(),
+	createdByAgentId: Union([String$1({ format: "uuid" }), Null()]),
+	createdByHumanId: Union([String$1({ format: "uuid" }), Null()]),
+	createdAt: String$1({ format: "date-time" }),
+	updatedAt: String$1({ format: "date-time" })
+}, {
+	$id: "RuntimeModel",
+	additionalProperties: false
+});
+//#endregion
 //#region ../../libs/tasks/src/runtime-profiles.ts
 var RuntimeProfileName = String$1({
 	minLength: 1,
@@ -5756,20 +5805,17 @@ var FreeformOutput = _Object_({
 *  3. `freeform.sourceAttemptNotCompleted` — named attempt is missing
 *     or not in `completed` state; warm continuation only makes sense
 *     once the parent has produced a terminal output.
-*  4. `freeform.forkModeNotImplemented` — `mode: 'fork'` is the wire
-*     surface for copy-on-write continuation tracked in #1293; v1
-*     rejects it server-side so daemons never have to branch.
-*  5. `freeform.executionWorkspaceNotInheritable` — caller set
+*  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.
-*  6. `freeform.sourceNotResumeEligible` — `daemonState` is null or
+*  5. `freeform.sourceNotResumeEligible` — `daemonState` is null or
 *     `slotResumableUntil` is null. Older completions (pre-#1287) and
 *     daemons that opt out fall here.
-*  7. `freeform.sourceResumeExpired` — `slotResumableUntil` is in the
+*  6. `freeform.sourceResumeExpired` — `slotResumableUntil` is in the
 *     past; the warm slot's TTL has elapsed and no daemon is
 *     guaranteed to still hold it.
 *
@@ -5790,11 +5836,6 @@ async function validateFreeformInputAsync(input, ctx) {
 		message: `Source task type '${source.taskType}' is not continuable; only freeform → freeform is supported in v1`,
 		code: "freeform.sourceTaskTypeNotSupported"
 	}];
-	if (cf.mode === "fork") return [{
-		field: "input/continueFrom/mode",
-		message: "fork mode not yet implemented; see https://github.com/getlarge/themoltnet/issues/1293",
-		code: "freeform.forkModeNotImplemented"
-	}];
 	if (input.execution?.workspace) return [{
 		field: "input/execution/workspace",
 		message: "execution.workspace is inherited from the parent slot when continueFrom is set; omit it",
@@ -8041,7 +8082,7 @@ function Errors$1(...args) {
 //#endregion
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/schema/check.mjs
 /** Checks a value against the provided schema */
-function Check$1(...args) {
+function Check$3(...args) {
 	const [context, schema, value] = Match$3(args, {
 		3: (context, schema, value) => [
 			context,
@@ -8059,7 +8100,7 @@ function Check$1(...args) {
 //#endregion
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/value/check/check.mjs
 /** Checks a value matches the provided type. */
-function Check(...args) {
+function Check$2(...args) {
 	const [context, type, value] = Match$3(args, {
 		3: (context, type, value) => [
 			context,
@@ -8072,7 +8113,7 @@ function Check(...args) {
 			value
 		]
 	});
-	return Check$1(context, type, value);
+	return Check$3(context, type, value);
 }
 //#endregion
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/value/errors/errors.mjs
@@ -8159,7 +8200,7 @@ function FromObject$4(context, type, value) {
 			value[key] = FromType$3(context, type.properties[key], value[key]);
 			continue;
 		}
-		if (IsBoolean$2(additionalProperties) && IsEqual(additionalProperties, true) || IsSchema$1(additionalProperties) && Check(context, additionalProperties, value[key])) {
+		if (IsBoolean$2(additionalProperties) && IsEqual(additionalProperties, true) || IsSchema$1(additionalProperties) && Check$2(context, additionalProperties, value[key])) {
 			value[key] = FromType$3(context, additionalProperties, value[key]);
 			continue;
 		}
@@ -8178,7 +8219,7 @@ function FromRecord$3(context, type, value) {
 			value[key] = FromType$3(context, recordValue, value[key]);
 			continue;
 		}
-		if (IsBoolean$2(additionalProperties) && IsEqual(additionalProperties, true) || IsSchema$1(additionalProperties) && Check(context, additionalProperties, value[key])) {
+		if (IsBoolean$2(additionalProperties) && IsEqual(additionalProperties, true) || IsSchema$1(additionalProperties) && Check$2(context, additionalProperties, value[key])) {
 			value[key] = FromType$3(context, additionalProperties, value[key]);
 			continue;
 		}
@@ -8261,7 +8302,7 @@ function UnionPrioritySort(types, order = 1) {
 function FromUnion$3(context, type, value) {
 	for (const schema of UnionPrioritySort(type.anyOf)) {
 		const clean = FromType$3(context, schema, Clone(value));
-		if (Check(context, schema, clean)) return clean;
+		if (Check$2(context, schema, clean)) return clean;
 	}
 	return value;
 }
@@ -8562,8 +8603,8 @@ function FromUndefined(_context, _type, value) {
 //#endregion
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/value/convert/from_union.mjs
 function FromUnion$2(context, type, value) {
-	if (type.anyOf.some((type) => Check(context, type, value))) return value;
-	const selected = type.anyOf.map((type) => FromType$2(context, type, Clone(value))).find((value) => Check(context, type, value));
+	if (type.anyOf.some((type) => Check$2(context, type, value))) return value;
+	const selected = type.anyOf.map((type) => FromType$2(context, type, Clone(value))).find((value) => Check$2(context, type, value));
 	return IsUndefined$1(selected) ? value : selected;
 }
 //#endregion
@@ -8680,7 +8721,7 @@ function FromTuple$1(context, schema, value) {
 function FromUnion$1(context, schema, value) {
 	for (const inner of schema.anyOf) {
 		const result = FromType$1(context, inner, Clone(value));
-		if (Check(context, inner, result)) return result;
+		if (Check$2(context, inner, result)) return result;
 	}
 	return value;
 }
@@ -8870,7 +8911,7 @@ function FromTuple(direction, context, type, value) {
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/value/codec/from_union.mjs
 function Decode(direction, context, type, value) {
 	for (const schema of UnionPrioritySort(type.anyOf, 1)) {
-		if (!Check(context, schema, value)) continue;
+		if (!Check$2(context, schema, value)) continue;
 		return Callback(direction, context, type, FromType(direction, context, schema, value));
 	}
 	return value;
@@ -8879,7 +8920,7 @@ function Encode(direction, context, type, value) {
 	const exterior = Callback(direction, context, type, value);
 	for (const schema of UnionPrioritySort(type.anyOf, -1)) {
 		const variant = FromType(direction, context, schema, Clone(exterior));
-		if (!Check(context, schema, variant)) continue;
+		if (!Check$2(context, schema, variant)) continue;
 		return variant;
 	}
 	return exterior;
@@ -8900,7 +8941,7 @@ var DecodeError = class extends AssertError {
 	}
 };
 function Assert$2(context, type, value) {
-	if (!Check(context, type, value)) throw new DecodeError(value, Errors(context, type, value));
+	if (!Check$2(context, type, value)) throw new DecodeError(value, Errors(context, type, value));
 	return value;
 }
 /** Executes Decode callbacks only */
@@ -8923,7 +8964,7 @@ var EncodeError = class extends AssertError {
 	}
 };
 function Assert$1(context, type, value) {
-	if (!Check(context, type, value)) throw new EncodeError(value, Errors(context, type, value));
+	if (!Check$2(context, type, value)) throw new EncodeError(value, Errors(context, type, value));
 	return value;
 }
 /** Executes Encode callbacks only */
@@ -8946,7 +8987,7 @@ var ParseError = class extends AssertError {
 	}
 };
 function Assert(context, type, value) {
-	if (!Check(context, type, value)) throw new ParseError(value, Errors(context, type, value));
+	if (!Check$2(context, type, value)) throw new ParseError(value, Errors(context, type, value));
 	return value;
 }
 Pipeline([
@@ -9763,6 +9804,17 @@ var ForeignKey$1 = class {
 		return name ?? `${chunks.join("_")}_fk`;
 	}
 };
+function foreignKey$1(config) {
+	function mappedConfig() {
+		const { name, columns, foreignColumns } = config;
+		return {
+			name,
+			columns,
+			foreignColumns
+		};
+	}
+	return new ForeignKeyBuilder$1(mappedConfig);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/tracing-utils.js
 function iife(fn, ...args) {
@@ -15270,12 +15322,12 @@ var require_helper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js
 var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	__require("path");
-	var fs = __require("fs"), helper = require_helper();
+	var fs$1 = __require("fs"), helper = require_helper();
 	module.exports = function(connInfo, cb) {
 		var file = helper.getFileName();
-		fs.stat(file, function(err, stat) {
+		fs$1.stat(file, function(err, stat) {
 			if (err || !helper.usePgPass(stat, file)) return cb(void 0);
-			var st = fs.createReadStream(file);
+			var st = fs$1.createReadStream(file);
 			helper.getPassword(connInfo, st, cb);
 		});
 	};
@@ -16534,6 +16586,33 @@ var SelectionProxyHandler = class SelectionProxyHandler {
 	}
 };
 //#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/pg-core/checks.js
+var CheckBuilder$1 = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+	static [entityKind] = "PgCheckBuilder";
+	brand;
+	/** @internal */
+	build(table) {
+		return new Check$1(table, this);
+	}
+};
+var Check$1 = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+	static [entityKind] = "PgCheck";
+	name;
+	value;
+};
+function check$1(name, value) {
+	return new CheckBuilder$1(name, value);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/pg-core/indexes.js
 var IndexBuilderOn$1 = class {
 	constructor(unique, name) {
@@ -19335,6 +19414,20 @@ var ForeignKey = class {
 		return name ?? `${chunks.join("_")}_fk`;
 	}
 };
+function foreignKey(config) {
+	function mappedConfig() {
+		if (typeof config === "function") {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignColumns
+			};
+		}
+		return config;
+	}
+	return new ForeignKeyBuilder(mappedConfig);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
 function uniqueKeyName(table, columns) {
@@ -19787,6 +19880,32 @@ var sqliteTable = (name, columns, extraConfig) => {
 	return sqliteTableBase(name, columns, extraConfig);
 };
 //#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/sqlite-core/checks.js
+var CheckBuilder = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+	static [entityKind] = "SQLiteCheckBuilder";
+	brand;
+	build(table) {
+		return new Check(table, this);
+	}
+};
+var Check = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+	static [entityKind] = "SQLiteCheck";
+	name;
+	value;
+};
+function check(name, value) {
+	return new CheckBuilder(name, value);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/sqlite-core/indexes.js
 var IndexBuilderOn = class {
 	constructor(name, unique) {
@@ -22188,7 +22307,136 @@ function drizzle(callback, batchCallback, config) {
 	return db;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/migrator.js
+function readMigrationFiles(config) {
+	const migrationFolderTo = config.migrationsFolder;
+	const migrationQueries = [];
+	const journalPath = `${migrationFolderTo}/meta/_journal.json`;
+	if (!fs.existsSync(journalPath)) throw new Error(`Can't find meta/_journal.json file`);
+	const journalAsString = fs.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
+	const journal = JSON.parse(journalAsString);
+	for (const journalEntry of journal.entries) {
+		const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
+		try {
+			const query = fs.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
+			const result = query.split("--> statement-breakpoint").map((it) => {
+				return it;
+			});
+			migrationQueries.push({
+				sql: result,
+				bps: journalEntry.breakpoints,
+				folderMillis: journalEntry.when,
+				hash: crypto$2.createHash("sha256").update(query).digest("hex")
+			});
+		} catch {
+			throw new Error(`No file ${migrationPath} found in ${migrationFolderTo} folder`);
+		}
+	}
+	return migrationQueries;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_@types+pg@8.16_374a03c8dde600dcef5a1d8002afafad/node_modules/drizzle-orm/node-postgres/migrator.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+//#region ../../libs/agent-daemon-state/src/migrate.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+* Walk up from this file to find a generated drizzle migrations folder.
+* Works from both `src/` (tsx dev) and `dist/src/` (compiled).
+*/
+function findMigrationsFolder(folderName) {
+	let dir = __dirname;
+	for (let i = 0; i < 5; i++) {
+		const candidate = resolve(dir, folderName);
+		if (existsSync(candidate)) return candidate;
+		dir = dirname(dir);
+	}
+	return resolve(__dirname, "..", folderName);
+}
+/** Statements in a generated drizzle SQL file are joined by this marker. */
+var STATEMENT_BREAKPOINT = "--> statement-breakpoint";
+function readMigrationStatements(folder) {
+	const files = readdirSync(folder).filter((name) => name.endsWith(".sql")).sort();
+	const statements = [];
+	for (const file of files) {
+		const raw = readFileSync(resolve(folder, file), "utf8");
+		for (const chunk of raw.split(STATEMENT_BREAKPOINT)) {
+			const trimmed = chunk.trim();
+			if (trimmed.length > 0) statements.push(trimmed);
+		}
+	}
+	return statements;
+}
+/**
+* Apply the SQLite baseline synchronously via the driver's `exec`.
+*
+* Fresh-start contract: the baseline is authored to run against an EMPTY
+* database. The daemon-state DB is a local warm-slot cache, and this migrator
+* does not adopt schemas created by the previous inline `CREATE TABLE IF NOT
+* EXISTS` bootstrap — upgrading from that path requires deleting the local
+* `daemon-state.sqlite` first (or dropping the Postgres tables). This is a
+* deliberate scope decision: there is no durable data to preserve, so in-place
+* adoption of legacy schemas is intentionally not implemented.
+*
+* The daemon-state SQLite store is constructed synchronously (callers do not
+* await it), and the runtime driver is a `node:sqlite` `DatabaseSync` wrapped
+* in drizzle's sqlite-proxy — which has no file-based migrator. We therefore
+* apply the drizzle-kit-generated SQL ourselves: the generated file stays the
+* single source of truth, we just run it synchronously. Idempotent via a
+* tracking table so re-opening an existing DB is a no-op.
+*/
+function applySqliteMigrations(client, migrationsFolder = findMigrationsFolder("drizzle-sqlite")) {
+	client.exec(`
+    CREATE TABLE IF NOT EXISTS __daemon_state_migrations (
+      statement_index INTEGER PRIMARY KEY,
+      applied_at_ms INTEGER NOT NULL
+    )
+  `);
+	const alreadyApplied = client.prepare(`SELECT COALESCE(MAX(statement_index), -1) AS last FROM __daemon_state_migrations`).get().last;
+	const statements = readMigrationStatements(migrationsFolder);
+	if (statements.length <= alreadyApplied + 1) return;
+	client.exec("BEGIN IMMEDIATE");
+	try {
+		for (let i = alreadyApplied + 1; i < statements.length; i++) {
+			client.exec(statements[i]);
+			client.prepare(`INSERT INTO __daemon_state_migrations (statement_index, applied_at_ms)
+             VALUES (?, ?)`).run(i, Date.now());
+		}
+		client.exec("COMMIT");
+	} catch (error) {
+		try {
+			client.exec("ROLLBACK");
+		} catch {}
+		throw error;
+	}
+}
+/**
+* Run the Postgres baseline via the standard node-postgres migrator (tracked,
+* transactional, idempotent). Mirrors `libs/database/src/migrate.ts`. Used when
+* the daemon points at a shared Postgres instance instead of a local SQLite
+* file.
+*/
+async function runPgMigrations(pool) {
+	await migrate(drizzle$1(pool), { migrationsFolder: findMigrationsFolder("drizzle-pg") });
+}
+//#endregion
 //#region ../../libs/agent-daemon-state/src/pg-schema.ts
+var pgDaemonWorkspaces = pgTable("daemon_workspaces", {
+	workspaceId: text$1("workspace_id").primaryKey(),
+	worktreePath: text$1("worktree_path").notNull(),
+	worktreeBranch: text$1("worktree_branch"),
+	kind: text$1("kind", { enum: [
+		"origin",
+		"fork",
+		"scratch"
+	] }).notNull(),
+	refcount: integer$1("refcount").notNull().default(0),
+	createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+	lastUsedAtMs: bigint("last_used_at_ms", { mode: "number" }).notNull()
+}, (table) => [check$1("daemon_workspaces_kind_check", sql`${table.kind} IN ('origin', 'fork', 'scratch')`)]);
 var pgDaemonSlots = pgTable("daemon_slots", {
 	agentName: text$1("agent_name").notNull(),
 	provider: text$1("provider").notNull(),
@@ -22198,6 +22446,7 @@ var pgDaemonSlots = pgTable("daemon_slots", {
 	state: text$1("state", { enum: ["active", "idle"] }).notNull(),
 	lastTaskId: text$1("last_task_id").notNull(),
 	lastAttemptN: integer$1("last_attempt_n").notNull(),
+	workspaceId: text$1("workspace_id").references(() => pgDaemonWorkspaces.workspaceId, { onDelete: "set null" }),
 	createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
 	lastUsedAtMs: bigint("last_used_at_ms", { mode: "number" }).notNull(),
 	expiresAtMs: bigint("expires_at_ms", { mode: "number" }).notNull()
@@ -22208,8 +22457,9 @@ var pgDaemonSlots = pgTable("daemon_slots", {
 		table.model,
 		table.slotKey
 	] }),
+	check$1("daemon_slots_state_check", sql`${table.state} IN ('active', 'idle')`),
 	index$1("daemon_slots_expires_idx").on(table.expiresAtMs),
-	index$1("daemon_slots_task_attempt_idx").on(table.lastTaskId, table.lastAttemptN, table.lastUsedAtMs)
+	index$1("daemon_slots_task_attempt_idx").on(table.lastTaskId, table.lastAttemptN, table.lastUsedAtMs.desc())
 ]);
 var pgDaemonSlotSessions = pgTable("daemon_slot_sessions", {
 	agentName: text$1("agent_name").notNull(),
@@ -22223,28 +22473,40 @@ var pgDaemonSlotSessions = pgTable("daemon_slot_sessions", {
 	table.provider,
 	table.model,
 	table.slotKey
-] })]);
-var pgDaemonSlotWorkspaces = pgTable("daemon_slot_workspaces", {
-	agentName: text$1("agent_name").notNull(),
-	provider: text$1("provider").notNull(),
-	model: text$1("model").notNull(),
-	slotKey: text$1("slot_key").notNull(),
-	workspaceId: text$1("workspace_id").notNull().unique(),
-	worktreePath: text$1("worktree_path").notNull(),
-	worktreeBranch: text$1("worktree_branch")
-}, (table) => [primaryKey$1({ columns: [
-	table.agentName,
-	table.provider,
-	table.model,
-	table.slotKey
-] })]);
+] }), foreignKey$1({
+	columns: [
+		table.agentName,
+		table.provider,
+		table.model,
+		table.slotKey
+	],
+	foreignColumns: [
+		pgDaemonSlots.agentName,
+		pgDaemonSlots.provider,
+		pgDaemonSlots.model,
+		pgDaemonSlots.slotKey
+	]
+}).onDelete("cascade")]);
 var pgAgentDaemonStateSchema = {
 	daemonSlotSessions: pgDaemonSlotSessions,
-	daemonSlotWorkspaces: pgDaemonSlotWorkspaces,
+	daemonWorkspaces: pgDaemonWorkspaces,
 	daemonSlots: pgDaemonSlots
 };
 //#endregion
 //#region ../../libs/agent-daemon-state/src/schema.ts
+var daemonWorkspaces = sqliteTable("daemon_workspaces", {
+	workspaceId: text("workspace_id").primaryKey(),
+	worktreePath: text("worktree_path").notNull(),
+	worktreeBranch: text("worktree_branch"),
+	kind: text("kind", { enum: [
+		"origin",
+		"fork",
+		"scratch"
+	] }).notNull(),
+	refcount: integer("refcount").notNull().default(0),
+	createdAtMs: integer("created_at_ms").notNull(),
+	lastUsedAtMs: integer("last_used_at_ms").notNull()
+}, (table) => [check("daemon_workspaces_kind_check", sql`${table.kind} IN ('origin', 'fork', 'scratch')`)]);
 var daemonSlots = sqliteTable("daemon_slots", {
 	agentName: text("agent_name").notNull(),
 	provider: text("provider").notNull(),
@@ -22254,6 +22516,7 @@ var daemonSlots = sqliteTable("daemon_slots", {
 	state: text("state", { enum: ["active", "idle"] }).notNull(),
 	lastTaskId: text("last_task_id").notNull(),
 	lastAttemptN: integer("last_attempt_n").notNull(),
+	workspaceId: text("workspace_id").references(() => daemonWorkspaces.workspaceId, { onDelete: "set null" }),
 	createdAtMs: integer("created_at_ms").notNull(),
 	lastUsedAtMs: integer("last_used_at_ms").notNull(),
 	expiresAtMs: integer("expires_at_ms").notNull()
@@ -22264,8 +22527,9 @@ var daemonSlots = sqliteTable("daemon_slots", {
 		table.model,
 		table.slotKey
 	] }),
+	check("daemon_slots_state_check", sql`${table.state} IN ('active', 'idle')`),
 	index("daemon_slots_expires_idx").on(table.expiresAtMs),
-	index("daemon_slots_task_attempt_idx").on(table.lastTaskId, table.lastAttemptN, table.lastUsedAtMs)
+	index("daemon_slots_task_attempt_idx").on(table.lastTaskId, table.lastAttemptN, sql`${table.lastUsedAtMs} DESC`)
 ]);
 var daemonSlotSessions = sqliteTable("daemon_slot_sessions", {
 	agentName: text("agent_name").notNull(),
@@ -22279,24 +22543,23 @@ var daemonSlotSessions = sqliteTable("daemon_slot_sessions", {
 	table.provider,
 	table.model,
 	table.slotKey
-] })]);
-var daemonSlotWorkspaces = sqliteTable("daemon_slot_workspaces", {
-	agentName: text("agent_name").notNull(),
-	provider: text("provider").notNull(),
-	model: text("model").notNull(),
-	slotKey: text("slot_key").notNull(),
-	workspaceId: text("workspace_id").notNull().unique(),
-	worktreePath: text("worktree_path").notNull(),
-	worktreeBranch: text("worktree_branch")
-}, (table) => [primaryKey({ columns: [
-	table.agentName,
-	table.provider,
-	table.model,
-	table.slotKey
-] })]);
+] }), foreignKey({
+	columns: [
+		table.agentName,
+		table.provider,
+		table.model,
+		table.slotKey
+	],
+	foreignColumns: [
+		daemonSlots.agentName,
+		daemonSlots.provider,
+		daemonSlots.model,
+		daemonSlots.slotKey
+	]
+}).onDelete("cascade")]);
 var agentDaemonStateSchema = {
 	daemonSlotSessions,
-	daemonSlotWorkspaces,
+	daemonWorkspaces,
 	daemonSlots
 };
 //#endregion
@@ -22339,59 +22602,7 @@ var SqliteDaemonSlotStore = class {
 			this.withSyncDb("initialize sqlite schema", () => {
 				this.client.exec("PRAGMA journal_mode = WAL");
 				this.client.exec("PRAGMA foreign_keys = ON");
-				this.client.exec(`
-          CREATE TABLE IF NOT EXISTS daemon_slots (
-            agent_name TEXT NOT NULL,
-            provider TEXT NOT NULL,
-            model TEXT NOT NULL,
-            slot_key TEXT NOT NULL,
-            task_type TEXT NOT NULL,
-            state TEXT NOT NULL CHECK (state IN ('active', 'idle')),
-            last_task_id TEXT NOT NULL,
-            last_attempt_n INTEGER NOT NULL,
-            created_at_ms INTEGER NOT NULL,
-            last_used_at_ms INTEGER NOT NULL,
-            expires_at_ms INTEGER NOT NULL,
-            PRIMARY KEY (agent_name, provider, model, slot_key)
-          );
-
-          CREATE TABLE IF NOT EXISTS daemon_slot_sessions (
-            agent_name TEXT NOT NULL,
-            provider TEXT NOT NULL,
-            model TEXT NOT NULL,
-            slot_key TEXT NOT NULL,
-            session_dir TEXT NOT NULL UNIQUE,
-            session_path TEXT,
-            PRIMARY KEY (agent_name, provider, model, slot_key),
-            FOREIGN KEY (agent_name, provider, model, slot_key)
-              REFERENCES daemon_slots(agent_name, provider, model, slot_key)
-              ON DELETE CASCADE
-          );
-
-          CREATE TABLE IF NOT EXISTS daemon_slot_workspaces (
-            agent_name TEXT NOT NULL,
-            provider TEXT NOT NULL,
-            model TEXT NOT NULL,
-            slot_key TEXT NOT NULL,
-            workspace_id TEXT NOT NULL UNIQUE,
-            worktree_path TEXT NOT NULL,
-            worktree_branch TEXT,
-            PRIMARY KEY (agent_name, provider, model, slot_key),
-            FOREIGN KEY (agent_name, provider, model, slot_key)
-              REFERENCES daemon_slots(agent_name, provider, model, slot_key)
-              ON DELETE CASCADE
-          );
-
-          CREATE INDEX IF NOT EXISTS daemon_slots_expires_idx
-            ON daemon_slots (expires_at_ms);
-
-          CREATE INDEX IF NOT EXISTS daemon_slots_task_attempt_idx
-            ON daemon_slots (
-              last_task_id,
-              last_attempt_n,
-              last_used_at_ms DESC
-            );
-        `);
+				applySqliteMigrations(this.client);
 			});
 		} catch (error) {
 			throw new DaemonSlotRegistryError("open sqlite database", error);
@@ -22403,34 +22614,45 @@ var SqliteDaemonSlotStore = class {
 	async beginSlot(input) {
 		const now = Date.now();
 		const expiresAtMs = now + input.ttlSec * 1e3;
-		await this.withDb("upsert sqlite slot", () => this.db.insert(daemonSlots).values({
-			agentName: input.agentName,
-			createdAtMs: now,
-			expiresAtMs,
-			lastAttemptN: input.lastAttemptN,
-			lastTaskId: input.lastTaskId,
-			lastUsedAtMs: now,
-			model: input.model,
-			provider: input.provider,
-			slotKey: input.slotKey,
-			state: "active",
-			taskType: input.taskType
-		}).onConflictDoUpdate({
-			set: {
-				expiresAtMs: sql`excluded.expires_at_ms`,
-				lastAttemptN: sql`excluded.last_attempt_n`,
-				lastTaskId: sql`excluded.last_task_id`,
-				lastUsedAtMs: sql`excluded.last_used_at_ms`,
-				state: "active",
-				taskType: sql`excluded.task_type`
-			},
-			target: [
-				daemonSlots.agentName,
-				daemonSlots.provider,
-				daemonSlots.model,
-				daemonSlots.slotKey
-			]
-		}).run());
+		const workspaceId = input.workspaceId !== null && input.worktreePath !== null ? input.workspaceId : null;
+		this.withSyncDb("upsert sqlite slot + workspace", () => {
+			this.client.exec("BEGIN IMMEDIATE");
+			try {
+				const priorWorkspaceId = this.priorSlotWorkspaceId(input);
+				if (workspaceId !== null) this.client.prepare(`INSERT INTO daemon_workspaces
+                 (workspace_id, worktree_path, worktree_branch, kind,
+                  refcount, created_at_ms, last_used_at_ms)
+               VALUES (?, ?, ?, ?, 0, ?, ?)
+               ON CONFLICT(workspace_id) DO UPDATE SET
+                 worktree_path = excluded.worktree_path,
+                 worktree_branch = excluded.worktree_branch,
+                 last_used_at_ms = excluded.last_used_at_ms`).run(workspaceId, input.worktreePath, input.worktreeBranch, input.workspaceKind ?? "origin", now, now);
+				this.client.prepare(`INSERT INTO daemon_slots
+               (agent_name, provider, model, slot_key, task_type, state,
+                last_task_id, last_attempt_n, workspace_id, created_at_ms,
+                last_used_at_ms, expires_at_ms)
+             VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(agent_name, provider, model, slot_key) DO UPDATE SET
+               task_type = excluded.task_type,
+               state = 'active',
+               last_task_id = excluded.last_task_id,
+               last_attempt_n = excluded.last_attempt_n,
+               workspace_id = excluded.workspace_id,
+               last_used_at_ms = excluded.last_used_at_ms,
+               expires_at_ms = excluded.expires_at_ms`).run(input.agentName, input.provider, input.model, input.slotKey, input.taskType, input.lastTaskId, input.lastAttemptN, workspaceId, now, now, expiresAtMs);
+				if (priorWorkspaceId !== workspaceId) {
+					if (priorWorkspaceId !== null) this.decrementWorkspaceRefcount(priorWorkspaceId);
+					if (workspaceId !== null) this.client.prepare(`UPDATE daemon_workspaces SET refcount = refcount + 1
+                   WHERE workspace_id = ?`).run(workspaceId);
+				}
+				this.client.exec("COMMIT");
+			} catch (error) {
+				try {
+					this.client.exec("ROLLBACK");
+				} catch {}
+				throw error;
+			}
+		});
 		const sessionDir = input.sessionDir;
 		if (sessionDir !== null) await this.withDb("upsert sqlite slot session", () => this.db.insert(daemonSlotSessions).values({
 			agentName: input.agentName,
@@ -22451,29 +22673,17 @@ var SqliteDaemonSlotStore = class {
 				daemonSlotSessions.slotKey
 			]
 		}).run());
-		const workspaceId = input.workspaceId;
-		const worktreePath = input.worktreePath;
-		if (workspaceId !== null && worktreePath !== null) await this.withDb("upsert sqlite slot workspace", () => this.db.insert(daemonSlotWorkspaces).values({
-			agentName: input.agentName,
-			model: input.model,
-			provider: input.provider,
-			slotKey: input.slotKey,
-			workspaceId,
-			worktreeBranch: input.worktreeBranch,
-			worktreePath
-		}).onConflictDoUpdate({
-			set: {
-				workspaceId: sql`excluded.workspace_id`,
-				worktreeBranch: sql`excluded.worktree_branch`,
-				worktreePath: sql`excluded.worktree_path`
-			},
-			target: [
-				daemonSlotWorkspaces.agentName,
-				daemonSlotWorkspaces.provider,
-				daemonSlotWorkspaces.model,
-				daemonSlotWorkspaces.slotKey
-			]
-		}).run());
+	}
+	/** The workspace_id the slot referenced before this begin, or null. */
+	priorSlotWorkspaceId(slot) {
+		return this.client.prepare(`SELECT workspace_id AS workspaceId FROM daemon_slots
+           WHERE agent_name = ? AND provider = ? AND model = ? AND slot_key = ?`).get(slot.agentName, slot.provider, slot.model, slot.slotKey)?.workspaceId ?? null;
+	}
+	/** Decrement a workspace refcount; delete the row when it reaches 0. */
+	decrementWorkspaceRefcount(workspaceId) {
+		this.client.prepare(`UPDATE daemon_workspaces SET refcount = refcount - 1
+           WHERE workspace_id = ?`).run(workspaceId);
+		this.client.prepare(`DELETE FROM daemon_workspaces WHERE workspace_id = ? AND refcount <= 0`).run(workspaceId);
 	}
 	async finishSlot(identity, slotKey, ttlSec, sessionPath) {
 		const now = Date.now();
@@ -22502,13 +22712,27 @@ var SqliteDaemonSlotStore = class {
 				slot,
 				workspace: await this.lookupWorkspace(slot)
 			});
-			this.withSyncDb("delete expired sqlite slots", () => {
+			const releasable = this.withSyncDb("delete expired sqlite slots", () => {
 				this.client.exec("BEGIN IMMEDIATE");
 				try {
-					for (const slot of slots) this.client.prepare(`DELETE FROM daemon_slots
-                 WHERE agent_name = ? AND provider = ? AND model = ?
-                   AND slot_key = ?`).run(slot.agentName, slot.provider, slot.model, slot.slotKey);
+					const orphaned = [];
+					for (const reaped of out) {
+						this.client.prepare(`DELETE FROM daemon_slots
+                   WHERE agent_name = ? AND provider = ? AND model = ?
+                     AND slot_key = ?`).run(reaped.slot.agentName, reaped.slot.provider, reaped.slot.model, reaped.slot.slotKey);
+						const ws = reaped.workspace;
+						if (ws) {
+							this.client.prepare(`UPDATE daemon_workspaces SET refcount = refcount - 1
+                       WHERE workspace_id = ?`).run(ws.workspaceId);
+							const row = this.client.prepare(`SELECT refcount FROM daemon_workspaces WHERE workspace_id = ?`).get(ws.workspaceId);
+							if (!row || row.refcount <= 0) {
+								this.client.prepare(`DELETE FROM daemon_workspaces WHERE workspace_id = ?`).run(ws.workspaceId);
+								orphaned.push(ws);
+							}
+						}
+					}
 					this.client.exec("COMMIT");
+					return orphaned;
 				} catch (error) {
 					try {
 						this.client.exec("ROLLBACK");
@@ -22516,7 +22740,9 @@ var SqliteDaemonSlotStore = class {
 					throw error;
 				}
 			});
-			return cleanupReapedSlots(out);
+			cleanupReapedSessions(out);
+			cleanupReleasableWorkspaces(releasable);
+			return out;
 		} catch (error) {
 			throw error instanceof DaemonSlotRegistryError ? error : new DaemonSlotRegistryError("reap expired sqlite slots", error);
 		}
@@ -22525,7 +22751,8 @@ var SqliteDaemonSlotStore = class {
 		return this.withDb("select sqlite slot session", async () => await this.db.select().from(daemonSlotSessions).where(sqliteSlotSessionIdentityWhere(slot, slot.slotKey)).get() ?? null);
 	}
 	async lookupWorkspace(slot) {
-		return this.withDb("select sqlite slot workspace", async () => await this.db.select().from(daemonSlotWorkspaces).where(sqliteSlotWorkspaceIdentityWhere(slot, slot.slotKey)).get() ?? null);
+		if (!slot.workspaceId) return null;
+		return this.withDb("select sqlite workspace", async () => await this.db.select().from(daemonWorkspaces).where(eq(daemonWorkspaces.workspaceId, slot.workspaceId)).get() ?? null);
 	}
 	executeProxyQuery(query, params, method) {
 		return Promise.resolve(this.withSyncDb("execute sqlite proxy query", () => {
@@ -22575,34 +22802,64 @@ var PgDaemonSlotStore = class {
 		await this.ready;
 		const now = Date.now();
 		const expiresAtMs = now + input.ttlSec * 1e3;
-		await this.withDb("upsert postgres slot", () => this.db.insert(pgDaemonSlots).values({
-			agentName: input.agentName,
-			createdAtMs: now,
-			expiresAtMs,
-			lastAttemptN: input.lastAttemptN,
-			lastTaskId: input.lastTaskId,
-			lastUsedAtMs: now,
-			model: input.model,
-			provider: input.provider,
-			slotKey: input.slotKey,
-			state: "active",
-			taskType: input.taskType
-		}).onConflictDoUpdate({
-			set: {
-				expiresAtMs: sql`excluded.expires_at_ms`,
-				lastAttemptN: sql`excluded.last_attempt_n`,
-				lastTaskId: sql`excluded.last_task_id`,
-				lastUsedAtMs: sql`excluded.last_used_at_ms`,
+		const beginWorkspaceId = input.workspaceId !== null && input.worktreePath !== null ? input.workspaceId : null;
+		await this.withDb("upsert postgres slot + workspace", () => this.db.transaction(async (tx) => {
+			const [priorRow] = await tx.select({ workspaceId: pgDaemonSlots.workspaceId }).from(pgDaemonSlots).where(pgSlotIdentityWhere(input, input.slotKey)).limit(1).execute();
+			const priorWorkspaceId = priorRow?.workspaceId ?? null;
+			if (beginWorkspaceId !== null) await tx.insert(pgDaemonWorkspaces).values({
+				workspaceId: beginWorkspaceId,
+				worktreePath: input.worktreePath,
+				worktreeBranch: input.worktreeBranch,
+				kind: input.workspaceKind ?? "origin",
+				refcount: 0,
+				createdAtMs: now,
+				lastUsedAtMs: now
+			}).onConflictDoUpdate({
+				set: {
+					worktreePath: sql`excluded.worktree_path`,
+					worktreeBranch: sql`excluded.worktree_branch`,
+					lastUsedAtMs: sql`excluded.last_used_at_ms`
+				},
+				target: [pgDaemonWorkspaces.workspaceId]
+			}).execute();
+			await tx.insert(pgDaemonSlots).values({
+				agentName: input.agentName,
+				createdAtMs: now,
+				expiresAtMs,
+				lastAttemptN: input.lastAttemptN,
+				lastTaskId: input.lastTaskId,
+				lastUsedAtMs: now,
+				model: input.model,
+				provider: input.provider,
+				slotKey: input.slotKey,
 				state: "active",
-				taskType: sql`excluded.task_type`
-			},
-			target: [
-				pgDaemonSlots.agentName,
-				pgDaemonSlots.provider,
-				pgDaemonSlots.model,
-				pgDaemonSlots.slotKey
-			]
-		}).execute());
+				taskType: input.taskType,
+				workspaceId: beginWorkspaceId
+			}).onConflictDoUpdate({
+				set: {
+					expiresAtMs: sql`excluded.expires_at_ms`,
+					lastAttemptN: sql`excluded.last_attempt_n`,
+					lastTaskId: sql`excluded.last_task_id`,
+					lastUsedAtMs: sql`excluded.last_used_at_ms`,
+					state: "active",
+					taskType: sql`excluded.task_type`,
+					workspaceId: sql`excluded.workspace_id`
+				},
+				target: [
+					pgDaemonSlots.agentName,
+					pgDaemonSlots.provider,
+					pgDaemonSlots.model,
+					pgDaemonSlots.slotKey
+				]
+			}).execute();
+			if (priorWorkspaceId !== beginWorkspaceId) {
+				if (priorWorkspaceId !== null) {
+					await tx.update(pgDaemonWorkspaces).set({ refcount: sql`${pgDaemonWorkspaces.refcount} - 1` }).where(eq(pgDaemonWorkspaces.workspaceId, priorWorkspaceId)).execute();
+					await tx.delete(pgDaemonWorkspaces).where(and(eq(pgDaemonWorkspaces.workspaceId, priorWorkspaceId), lte(pgDaemonWorkspaces.refcount, 0))).execute();
+				}
+				if (beginWorkspaceId !== null) await tx.update(pgDaemonWorkspaces).set({ refcount: sql`${pgDaemonWorkspaces.refcount} + 1` }).where(eq(pgDaemonWorkspaces.workspaceId, beginWorkspaceId)).execute();
+			}
+		}));
 		const sessionDir = input.sessionDir;
 		if (sessionDir !== null) await this.withDb("upsert postgres slot session", () => this.db.insert(pgDaemonSlotSessions).values({
 			agentName: input.agentName,
@@ -22623,29 +22880,6 @@ var PgDaemonSlotStore = class {
 				pgDaemonSlotSessions.slotKey
 			]
 		}).execute());
-		const workspaceId = input.workspaceId;
-		const worktreePath = input.worktreePath;
-		if (workspaceId !== null && worktreePath !== null) await this.withDb("upsert postgres slot workspace", () => this.db.insert(pgDaemonSlotWorkspaces).values({
-			agentName: input.agentName,
-			model: input.model,
-			provider: input.provider,
-			slotKey: input.slotKey,
-			workspaceId,
-			worktreeBranch: input.worktreeBranch,
-			worktreePath
-		}).onConflictDoUpdate({
-			set: {
-				workspaceId: sql`excluded.workspace_id`,
-				worktreeBranch: sql`excluded.worktree_branch`,
-				worktreePath: sql`excluded.worktree_path`
-			},
-			target: [
-				pgDaemonSlotWorkspaces.agentName,
-				pgDaemonSlotWorkspaces.provider,
-				pgDaemonSlotWorkspaces.model,
-				pgDaemonSlotWorkspaces.slotKey
-			]
-		}).execute());
 	}
 	async finishSlot(identity, slotKey, ttlSec, sessionPath) {
 		await this.ready;
@@ -22670,91 +22904,50 @@ var PgDaemonSlotStore = class {
 	async reapExpiredSlots(now = Date.now()) {
 		await this.ready;
 		try {
-			return cleanupReapedSlots(await this.db.transaction(async (tx) => {
+			const { out, releasable } = await this.db.transaction(async (tx) => {
 				const slots = await tx.select().from(pgDaemonSlots).where(lte(pgDaemonSlots.expiresAtMs, now)).execute();
 				const reaped = [];
+				const orphaned = [];
 				for (const slot of slots) {
 					const [session = null] = await tx.select().from(pgDaemonSlotSessions).where(pgSlotSessionIdentityWhere(slot, slot.slotKey)).limit(1).execute();
-					const [workspace = null] = await tx.select().from(pgDaemonSlotWorkspaces).where(pgSlotWorkspaceIdentityWhere(slot, slot.slotKey)).limit(1).execute();
+					const workspace = slot.workspaceId ? (await tx.select().from(pgDaemonWorkspaces).where(eq(pgDaemonWorkspaces.workspaceId, slot.workspaceId)).limit(1).execute())[0] ?? null : null;
 					reaped.push({
 						session,
 						slot,
 						workspace
 					});
 					await tx.delete(pgDaemonSlots).where(pgSlotIdentityWhere(slot, slot.slotKey)).execute();
+					if (workspace) {
+						await tx.update(pgDaemonWorkspaces).set({ refcount: sql`${pgDaemonWorkspaces.refcount} - 1` }).where(eq(pgDaemonWorkspaces.workspaceId, workspace.workspaceId)).execute();
+						const [after] = await tx.select({ refcount: pgDaemonWorkspaces.refcount }).from(pgDaemonWorkspaces).where(eq(pgDaemonWorkspaces.workspaceId, workspace.workspaceId)).limit(1).execute();
+						if (!after || after.refcount <= 0) {
+							await tx.delete(pgDaemonWorkspaces).where(eq(pgDaemonWorkspaces.workspaceId, workspace.workspaceId)).execute();
+							orphaned.push(workspace);
+						}
+					}
 				}
-				return reaped;
-			}));
+				return {
+					out: reaped,
+					releasable: orphaned
+				};
+			});
+			cleanupReapedSessions(out);
+			cleanupReleasableWorkspaces(releasable);
+			return out;
 		} catch (error) {
 			throw error instanceof DaemonSlotRegistryError ? error : new DaemonSlotRegistryError("reap expired postgres slots", error);
 		}
 	}
 	async initialize() {
-		await this.withDb("initialize postgres schema", () => this.pool.query(`
-        CREATE TABLE IF NOT EXISTS daemon_slots (
-          agent_name TEXT NOT NULL,
-          provider TEXT NOT NULL,
-          model TEXT NOT NULL,
-          slot_key TEXT NOT NULL,
-          task_type TEXT NOT NULL,
-          state TEXT NOT NULL CHECK (state IN ('active', 'idle')),
-          last_task_id TEXT NOT NULL,
-          last_attempt_n INTEGER NOT NULL,
-          created_at_ms BIGINT NOT NULL,
-          last_used_at_ms BIGINT NOT NULL,
-          expires_at_ms BIGINT NOT NULL,
-          PRIMARY KEY (agent_name, provider, model, slot_key)
-        );
-
-        CREATE TABLE IF NOT EXISTS daemon_slot_sessions (
-          agent_name TEXT NOT NULL,
-          provider TEXT NOT NULL,
-          model TEXT NOT NULL,
-          slot_key TEXT NOT NULL,
-          session_dir TEXT NOT NULL UNIQUE,
-          session_path TEXT,
-          PRIMARY KEY (agent_name, provider, model, slot_key),
-          FOREIGN KEY (agent_name, provider, model, slot_key)
-            REFERENCES daemon_slots(agent_name, provider, model, slot_key)
-            ON DELETE CASCADE
-        );
-
-        CREATE TABLE IF NOT EXISTS daemon_slot_workspaces (
-          agent_name TEXT NOT NULL,
-          provider TEXT NOT NULL,
-          model TEXT NOT NULL,
-          slot_key TEXT NOT NULL,
-          workspace_id TEXT NOT NULL UNIQUE,
-          worktree_path TEXT NOT NULL,
-          worktree_branch TEXT,
-          PRIMARY KEY (agent_name, provider, model, slot_key),
-          FOREIGN KEY (agent_name, provider, model, slot_key)
-            REFERENCES daemon_slots(agent_name, provider, model, slot_key)
-            ON DELETE CASCADE
-        );
-
-        CREATE INDEX IF NOT EXISTS daemon_slots_expires_idx
-          ON daemon_slots (expires_at_ms);
-
-        CREATE INDEX IF NOT EXISTS daemon_slots_task_attempt_idx
-          ON daemon_slots (
-            last_task_id,
-            last_attempt_n,
-            last_used_at_ms DESC
-          );
-
-        ALTER TABLE daemon_slots
-          ALTER COLUMN created_at_ms TYPE BIGINT,
-          ALTER COLUMN last_used_at_ms TYPE BIGINT,
-          ALTER COLUMN expires_at_ms TYPE BIGINT;
-      `));
+		await this.withDb("initialize postgres schema", () => runPgMigrations(this.pool));
 	}
 	async lookupSession(slot) {
 		const [session] = await this.withDb("select postgres slot session", () => this.db.select().from(pgDaemonSlotSessions).where(pgSlotSessionIdentityWhere(slot, slot.slotKey)).limit(1).execute());
 		return session ?? null;
 	}
 	async lookupWorkspace(slot) {
-		const [workspace] = await this.withDb("select postgres slot workspace", () => this.db.select().from(pgDaemonSlotWorkspaces).where(pgSlotWorkspaceIdentityWhere(slot, slot.slotKey)).limit(1).execute());
+		if (!slot.workspaceId) return null;
+		const [workspace] = await this.withDb("select postgres workspace", () => this.db.select().from(pgDaemonWorkspaces).where(eq(pgDaemonWorkspaces.workspaceId, slot.workspaceId)).limit(1).execute());
 		return workspace ?? null;
 	}
 	async withDb(operation, fn) {
@@ -22794,24 +22987,27 @@ function sqliteSlotIdentityWhere(identity, slotKey) {
 function sqliteSlotSessionIdentityWhere(identity, slotKey) {
 	return and(eq(daemonSlotSessions.agentName, identity.agentName), eq(daemonSlotSessions.provider, identity.provider), eq(daemonSlotSessions.model, identity.model), eq(daemonSlotSessions.slotKey, slotKey));
 }
-function sqliteSlotWorkspaceIdentityWhere(identity, slotKey) {
-	return and(eq(daemonSlotWorkspaces.agentName, identity.agentName), eq(daemonSlotWorkspaces.provider, identity.provider), eq(daemonSlotWorkspaces.model, identity.model), eq(daemonSlotWorkspaces.slotKey, slotKey));
-}
 function pgSlotIdentityWhere(identity, slotKey) {
 	return and(eq(pgDaemonSlots.agentName, identity.agentName), eq(pgDaemonSlots.provider, identity.provider), eq(pgDaemonSlots.model, identity.model), eq(pgDaemonSlots.slotKey, slotKey));
 }
 function pgSlotSessionIdentityWhere(identity, slotKey) {
 	return and(eq(pgDaemonSlotSessions.agentName, identity.agentName), eq(pgDaemonSlotSessions.provider, identity.provider), eq(pgDaemonSlotSessions.model, identity.model), eq(pgDaemonSlotSessions.slotKey, slotKey));
 }
-function pgSlotWorkspaceIdentityWhere(identity, slotKey) {
-	return and(eq(pgDaemonSlotWorkspaces.agentName, identity.agentName), eq(pgDaemonSlotWorkspaces.provider, identity.provider), eq(pgDaemonSlotWorkspaces.model, identity.model), eq(pgDaemonSlotWorkspaces.slotKey, slotKey));
+/** Remove the persisted Pi session dir for each reaped slot. */
+function cleanupReapedSessions(slots) {
+	for (const item of slots) if (item.session) cleanupPiSessionDir(item.session.sessionDir);
 }
-function cleanupReapedSlots(slots) {
-	for (const item of slots) {
-		if (item.session) cleanupPiSessionDir(item.session.sessionDir);
-		if (item.workspace) cleanupReusableWorktree(item.workspace.worktreePath);
-	}
-	return slots;
+/**
+* Remove on-disk artifacts for workspaces whose refcount reached 0. Worktrees
+* (origin/fork) are removed via `git worktree remove`; scratch workspaces are
+* plain directories removed via rm.
+*/
+function cleanupReleasableWorkspaces(workspaces) {
+	for (const ws of workspaces) if (ws.kind === "scratch") rmSync(ws.worktreePath, {
+		recursive: true,
+		force: true
+	});
+	else cleanupReusableWorktree(ws.worktreePath);
 }
 function cleanupPiSessionDir(sessionDir) {
 	rmSync(sessionDir, {
@@ -24323,7 +24519,7 @@ function buildRunEvalUserPrompt(input, ctx) {
 function buildTaskUserPrompt(task, ctx) {
 	switch (task.taskType) {
 		case FREEFORM_TYPE:
-			if (!Check(FreeformInput, task.input)) {
+			if (!Check$2(FreeformInput, task.input)) {
 				const errors = [...Errors(FreeformInput, task.input)];
 				throw new Error(`freeform input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24332,7 +24528,7 @@ function buildTaskUserPrompt(task, ctx) {
 				priorContext: ctx.priorContext
 			});
 		case FULFILL_BRIEF_TYPE:
-			if (!Check(FulfillBriefInput, task.input)) {
+			if (!Check$2(FulfillBriefInput, task.input)) {
 				const errors = [...Errors(FulfillBriefInput, task.input)];
 				throw new Error(`fulfill_brief input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24343,7 +24539,7 @@ function buildTaskUserPrompt(task, ctx) {
 				workspace: ctx.workspace
 			});
 		case ASSESS_BRIEF_TYPE:
-			if (!Check(AssessBriefInput, task.input)) {
+			if (!Check$2(AssessBriefInput, task.input)) {
 				const errors = [...Errors(AssessBriefInput, task.input)];
 				throw new Error(`assess_brief input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24353,7 +24549,7 @@ function buildTaskUserPrompt(task, ctx) {
 				workspace: ctx.workspace
 			});
 		case CURATE_PACK_TYPE:
-			if (!Check(CuratePackInput, task.input)) {
+			if (!Check$2(CuratePackInput, task.input)) {
 				const errors = [...Errors(CuratePackInput, task.input)];
 				throw new Error(`curate_pack input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24362,7 +24558,7 @@ function buildTaskUserPrompt(task, ctx) {
 				taskId: ctx.taskId
 			});
 		case RENDER_PACK_TYPE:
-			if (!Check(RenderPackInput, task.input)) {
+			if (!Check$2(RenderPackInput, task.input)) {
 				const errors = [...Errors(RenderPackInput, task.input)];
 				throw new Error(`render_pack input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24371,7 +24567,7 @@ function buildTaskUserPrompt(task, ctx) {
 				taskId: ctx.taskId
 			});
 		case JUDGE_PACK_TYPE:
-			if (!Check(JudgePackInput, task.input)) {
+			if (!Check$2(JudgePackInput, task.input)) {
 				const errors = [...Errors(JudgePackInput, task.input)];
 				throw new Error(`judge_pack input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24380,7 +24576,7 @@ function buildTaskUserPrompt(task, ctx) {
 				taskId: ctx.taskId
 			});
 		case JUDGE_EVAL_ATTEMPT_TYPE:
-			if (!Check(JudgeEvalAttemptInput, task.input)) {
+			if (!Check$2(JudgeEvalAttemptInput, task.input)) {
 				const errors = [...Errors(JudgeEvalAttemptInput, task.input)];
 				throw new Error(`judge_eval_attempt input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24390,7 +24586,7 @@ function buildTaskUserPrompt(task, ctx) {
 				workspace: ctx.workspace
 			});
 		case PR_REVIEW_TYPE:
-			if (!Check(PrReviewInput, task.input)) {
+			if (!Check$2(PrReviewInput, task.input)) {
 				const errors = [...Errors(PrReviewInput, task.input)];
 				throw new Error(`pr_review input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -24400,7 +24596,7 @@ function buildTaskUserPrompt(task, ctx) {
 				workspace: ctx.workspace
 			});
 		case RUN_EVAL_TYPE:
-			if (!Check(RunEvalInput, task.input)) {
+			if (!Check$2(RunEvalInput, task.input)) {
 				const errors = [...Errors(RunEvalInput, task.input)];
 				throw new Error(`run_eval input failed validation: ${JSON.stringify(errors.slice(0, 3))}`);
 			}
@@ -32845,8 +33041,7 @@ async function resumeVm(config) {
 			signal: config.signal
 		});
 		if (creds.gitconfig) {
-			const vmSigningKey = `${vmSshDir}/id_ed25519`;
-			const vmGitconfig = creds.gitconfig.replace(/signingKey\s*=\s*.+/g, `signingKey = ${vmSigningKey}`);
+			const vmGitconfig = rewriteGitconfigPaths(creds.gitconfig, vmSshDir, vmAgentDir);
 			await vm.fs.writeFile(`${vmAgentDir}/gitconfig`, vmGitconfig, {
 				mode: 420,
 				signal: config.signal
@@ -32869,17 +33064,6 @@ async function resumeVm(config) {
 			signal: config.signal
 		});
 		await vm.exec("chown -R agent:agent /home/agent/.pi /home/agent/.moltnet", { signal: config.signal });
-		const gitCredHelperPath = `${vmSshDir}/git-credential-moltnet`;
-		const credHelperScript = `#!/bin/sh
-echo "username=x-access-token"
-echo "password=$(moltnet github token --credentials ${vmSshDir}/moltnet.json)"
-`;
-		await vm.fs.writeFile(gitCredHelperPath, credHelperScript, {
-			mode: 493,
-			signal: config.signal
-		});
-		await vmRun(vm, "git credential helper", `git config --global credential.helper ${gitCredHelperPath} && \
-       git config --global url."https://github.com/".insteadOf "git@github.com:"`, config.signal);
 		return {
 			vm,
 			credentials: creds,
@@ -32898,6 +33082,30 @@ echo "password=$(moltnet github token --credentials ${vmSshDir}/moltnet.json)"
 	}
 }
 /**
+* Rewrite host-absolute paths inside an agent gitconfig to VM-local
+* equivalents before injecting it into the guest.
+*
+* Two rewrites:
+*   - `signingKey = <host path>`  → `<vmSshDir>/id_ed25519`
+*   - `... credential-helper --credentials <host moltnet.json>`
+*                                 → `<vmAgentDir>/moltnet.json`
+*
+* The credential-helper line is generated host-side by `moltnet github setup`
+* with a host-absolute `--credentials` path; inside the guest that path is
+* invalid, so it must point at the VM-side moltnet.json. The `insteadOf`
+* rewrite rule and every other line are workspace-independent and pass through
+* unchanged. A gitconfig without a credential helper is rewritten only for
+* `signingKey`.
+*
+* This is the single source of truth for git push auth in the guest: the
+* injected gitconfig carries the tokenless mint-on-demand helper, so the VM
+* no longer hand-rolls a credential-helper script or runs an imperative
+* `git config --global ... insteadOf` against the guest $HOME.
+*/
+function rewriteGitconfigPaths(gitconfig, vmSshDir, vmAgentDir) {
+	return gitconfig.replace(/signingKey\s*=\s*.+/g, `signingKey = ${vmSshDir}/id_ed25519`).replace(/(moltnet github credential-helper --credentials )\S+/g, `$1${vmAgentDir}/moltnet.json`);
+}
+/**
 * Rewrite host-absolute paths inside moltnet.json to VM-local equivalents.
 *
 * Fields rewritten:
@@ -33458,7 +33666,7 @@ function createSubagentTool(args) {
 			description: subagentToolDescription(),
 			parameters: SubagentToolParameters,
 			async execute(_id, params) {
-				if (!Check(SubagentToolParameters, params)) return toolError(`subagent: invalid parameters: ${JSON.stringify([...Errors(SubagentToolParameters, params)].slice(0, 3))}`);
+				if (!Check$2(SubagentToolParameters, params)) return toolError(`subagent: invalid parameters: ${JSON.stringify([...Errors(SubagentToolParameters, params)].slice(0, 3))}`);
 				const { task, output_schema } = params;
 				const contract = contractRegistry.get(output_schema);
 				if (!contract) return toolError(`subagent: unknown output_schema "${output_schema}". Registered contracts: [${contractRegistry.list().map((c) => c.name).join(", ")}]`);
@@ -33471,7 +33679,7 @@ function createSubagentTool(args) {
 					description: `Submit your structured output for this subagent task. Call exactly once when done. Args MUST match the ${output_schema} contract; mismatches return a tool error you can recover from in the same session.`,
 					parameters: contract.parametersSchema,
 					async execute(_innerId, innerParams) {
-						if (!Check(contract.parametersSchema, innerParams)) return toolError(`submit_subagent_output: schema validation failed: ${[...Errors(contract.parametersSchema, innerParams)].slice(0, 3).map((e) => `${e.instancePath}: ${e.message}`).join("; ")}. Re-call with a corrected payload.`);
+						if (!Check$2(contract.parametersSchema, innerParams)) return toolError(`submit_subagent_output: schema validation failed: ${[...Errors(contract.parametersSchema, innerParams)].slice(0, 3).map((e) => `${e.instancePath}: ${e.message}`).join("; ")}. Re-call with a corrected payload.`);
 						captured = innerParams;
 						return {
 							content: [{
@@ -33877,10 +34085,11 @@ function prepareTaskWorkspace(task, requestedMountPath, executionPlan) {
 	const relMount = relative(mainRepo, requestedMountPath);
 	const cwdPath = relMount === "" || relMount.startsWith("..") ? worktreeDir : join(worktreeDir, relMount);
 	const keepWorkspace = executionPlan?.workspaceScope === "session" && executionPlan.sessionKey !== null;
-	if (keepWorkspace) ensureReusableTaskWorktree(mainRepo, worktreeDir, branch);
+	const baseRefOverride = executionPlan?.worktreeBaseRef ?? null;
+	if (keepWorkspace) ensureReusableTaskWorktree(mainRepo, worktreeDir, branch, baseRefOverride);
 	else {
 		removeExistingTaskWorktree(mainRepo, worktreeDir);
-		addTaskWorktree(mainRepo, worktreeDir, branch);
+		addTaskWorktree(mainRepo, worktreeDir, branch, baseRefOverride);
 	}
 	return {
 		mountPath: mainRepo,
@@ -33905,14 +34114,15 @@ function resolveTaskWorktreePath(mainRepo, workspaceId) {
 function resolveTaskScratchPath(mainRepo, workspaceId) {
 	return join(mainRepo, ".moltnet", "d", "task-workspaces", workspaceId);
 }
-function ensureReusableTaskWorktree(mainRepo, worktreeDir, branch) {
+function ensureReusableTaskWorktree(mainRepo, worktreeDir, branch, baseRefOverride = null) {
 	if (isRegisteredWorktree(mainRepo, worktreeDir)) return;
 	if (existsSync(worktreeDir)) throw new Error(`Expected reusable worktree ${worktreeDir} to be git-managed, but it exists outside git worktree metadata.`);
-	addTaskWorktree(mainRepo, worktreeDir, branch);
+	addTaskWorktree(mainRepo, worktreeDir, branch, baseRefOverride);
 }
-function addTaskWorktree(mainRepo, worktreeDir, branch) {
-	const baseRef = resolveWorktreeBaseRef(mainRepo);
-	execFileSync("git", gitRefExists(mainRepo, `refs/heads/${branch}`) ? [
+function addTaskWorktree(mainRepo, worktreeDir, branch, baseRefOverride = null) {
+	const branchExists = gitRefExists(mainRepo, `refs/heads/${branch}`);
+	const baseRef = baseRefOverride ?? resolveWorktreeBaseRef(mainRepo);
+	execFileSync("git", branchExists ? [
 		"-C",
 		mainRepo,
 		"worktree",
@@ -34295,7 +34505,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 		let injectedContext;
 		try {
 			const contextArray = rawContext === void 0 ? [] : rawContext;
-			if (!Check(TaskContext, contextArray)) throw new Error(`task.input.context failed TaskContext validation: ${JSON.stringify([...Errors(TaskContext, contextArray)].slice(0, 3))}`);
+			if (!Check$2(TaskContext, contextArray)) throw new Error(`task.input.context failed TaskContext validation: ${JSON.stringify([...Errors(TaskContext, contextArray)].slice(0, 3))}`);
 			injectedContext = await injectTaskContext({
 				context: contextArray,
 				fs: managed.vm.fs,
@@ -35074,13 +35284,32 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		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`);
 		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;
+		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}`;
+			return {
+				...basePlan,
+				workspaceMode: "dedicated_worktree",
+				workspaceId: forkWorkspaceId,
+				worktreeBranch: forkBranch,
+				worktreeBaseRef: parentBranch,
+				workspaceKind: "fork",
+				sessionPersistence: {
+					sessionDir,
+					forkFromSessionPath: resolution.sessionPath
+				}
+			};
+		}
 		return {
 			...basePlan,
 			workspaceMode: "dedicated_worktree",
 			workspaceId: resolution.producerSlot.workspace?.workspaceId ?? null,
-			worktreeBranch: resolution.producerSlot.workspace?.worktreeBranch ?? null,
+			worktreeBranch: parentBranch,
 			sessionPersistence: {
-				sessionDir: `${stateDirs.piSessionsDir}/continue-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`,
+				sessionDir,
 				forkFromSessionPath: resolution.sessionPath
 			}
 		};
@@ -35096,6 +35325,7 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 		...basePlan,
 		workspaceMode: "scratch_mount",
 		worktreeBranch: null,
+		workspaceKind: "scratch",
 		workspaceSeed: {
 			copyFromPath: resolution.workspacePath,
 			source: "producer"
@@ -35900,6 +36130,7 @@ async function runPolling(opts) {
 					workspaceId: executionPlan.workspaceId,
 					worktreePath: resolveRecordedWorkspacePath$1(mainRepo, stateDirs.rootDir, executionPlan),
 					worktreeBranch: executionPlan.worktreeBranch,
+					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
 					lastAttemptN: claimedTask.attemptN,
 					ttlSec: common.warmSessionTtlSec
@@ -36158,6 +36389,7 @@ async function runOnce(argv) {
 				workspaceId: executionPlan.workspaceId,
 				worktreePath: resolveRecordedWorkspacePath(mainRepo, stateDirs.rootDir, executionPlan),
 				worktreeBranch: executionPlan.worktreeBranch,
+				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
 				lastAttemptN: claimedTask.attemptN,
 				ttlSec: opts.warmSessionTtlSec