@themoltnet/pi-extension 0.3.0 → 0.5.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } fr
 import path, { join } from "node:path";
 import { DefaultResourceLoader, SessionManager, createAgentSession, createBashTool, createBashToolDefinition, createEditTool, createEditToolDefinition, createReadTool, createReadToolDefinition, createWriteTool, createWriteToolDefinition, defineTool } from "@mariozechner/pi-coding-agent";
 import { createHash, randomUUID } from "node:crypto";
-import { createHash as createHash$1 } from "crypto";
+import crypto, { createHash as createHash$1 } from "crypto";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { Type, complete, getModel } from "@mariozechner/pi-ai";
@@ -13,7 +13,6 @@ import { RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, crea
 import { parseEnv } from "node:util";
 import { FormatRegistry, Type as Type$1 } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
 //#region ../api-client/src/generated/core/bodySerializer.gen.ts
 var jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
 Object.entries({
@@ -2039,6 +2038,276 @@ var getLegreffierOnboardingStatus = (options) => (options.client ?? client).get(
 	...options
 });
 /**
+* List tasks for a team with optional filters.
+*/
+var listTasks = (options) => (options.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks",
+	...options
+});
+/**
+* Create and enqueue a new task.
+*/
+var createTask = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get a task by ID.
+*/
+var getTask = (options) => (options.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}",
+	...options
+});
+/**
+* Claim a queued task and start an attempt.
+*/
+var claimTask = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/claim",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Send a heartbeat to keep the attempt lease alive.
+*/
+var taskHeartbeat = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/heartbeat",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Mark an attempt as completed with output.
+*/
+var completeTask = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/complete",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Mark an attempt as failed with error details.
+*/
+var failTask = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/fail",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Cancel a task.
+*/
+var cancelTask = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/cancel",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List all attempts for a task.
+*/
+var listTaskAttempts = (options) => (options.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts",
+	...options
+});
+/**
+* List messages for a task attempt.
+*/
+var listTaskMessages = (options) => (options.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/messages",
+	...options
+});
+/**
+* Append messages to a task attempt.
+*/
+var appendTaskMessages = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/messages",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * List all problem types used in API error responses (RFC 9457).
 */
 var listProblemTypes = (options) => (options?.client ?? client).get({
@@ -2810,7 +3079,7 @@ K512[1];
 * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
 * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
 */
-var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+var sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
 //#endregion
 //#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
 function equals$1(aa, bb) {
@@ -3027,12 +3296,12 @@ var Codec = class {
 		return this.decoder.decode(input);
 	}
 };
-function from({ name, prefix, encode, decode }) {
+function from$1({ name, prefix, encode, decode }) {
 	return new Codec(name, prefix, encode, decode);
 }
 function baseX({ name, prefix, alphabet }) {
 	const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-	return from({
+	return from$1({
 		prefix,
 		name,
 		encode,
@@ -3059,7 +3328,7 @@ function decode$3(string, alphabetIdx, bitsPerChar, name) {
 	if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) throw new SyntaxError("Unexpected end of data");
 	return out;
 }
-function encode$1(data, alphabet, bitsPerChar) {
+function encode$2(data, alphabet, bitsPerChar) {
 	const pad = alphabet[alphabet.length - 1] === "=";
 	const mask = (1 << bitsPerChar) - 1;
 	let out = "";
@@ -3087,11 +3356,11 @@ function createAlphabetIdx(alphabet) {
 */
 function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
 	const alphabetIdx = createAlphabetIdx(alphabet);
-	return from({
+	return from$1({
 		prefix,
 		name,
 		encode(input) {
-			return encode$1(input, alphabet, bitsPerChar);
+			return encode$2(input, alphabet, bitsPerChar);
 		},
 		decode(input) {
 			return decode$3(input, alphabetIdx, bitsPerChar, name);
@@ -3180,14 +3449,14 @@ baseX({
 });
 //#endregion
 //#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/varint.js
-var encode_1 = encode;
+var encode_1 = encode$1;
 var MSB = 128, MSBALL = -128, INT = Math.pow(2, 31);
 /**
 * @param {number} num
 * @param {number[]} out
 * @param {number} offset
 */
-function encode(num, out, offset) {
+function encode$1(num, out, offset) {
 	out = out || [];
 	offset = offset || 0;
 	var oldOffset = offset;
@@ -3200,7 +3469,7 @@ function encode(num, out, offset) {
 		num >>>= 7;
 	}
 	out[offset] = num | 0;
-	encode.bytes = offset - oldOffset + 1;
+	encode$1.bytes = offset - oldOffset + 1;
 	return out;
 }
 var decode$2 = read;
@@ -3623,7 +3892,7 @@ function buildCanonicalInput(entryType, title, content, tags) {
 */
 function computeCanonicalHash(entryType, title, content, tags) {
 	const input = buildCanonicalInput(entryType, title, content, tags);
-	return sha256(new TextEncoder().encode(input));
+	return sha256$1(new TextEncoder().encode(input));
 }
 /**
 * Compute a CIDv1 content identifier for a diary entry.
@@ -4070,25 +4339,104 @@ etc.sha512Sync = (...m) => {
 	return hash.digest();
 };
 //#endregion
-//#region ../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/is.js
-var objectTypeNames = [
-	"Object",
-	"RegExp",
-	"Date",
-	"Error",
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"ArrayBuffer",
-	"SharedArrayBuffer",
-	"DataView",
-	"Promise",
-	"URL",
-	"HTMLElement",
-	"Int8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/codecs/json.js
+var textEncoder$1 = new TextEncoder();
+new TextDecoder();
+function encode(node) {
+	return textEncoder$1.encode(JSON.stringify(node));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/hasher.js
+var DEFAULT_MIN_DIGEST_LENGTH = 20;
+function from({ name, code, encode, minDigestLength, maxDigestLength }) {
+	return new Hasher(name, code, encode, minDigestLength, maxDigestLength);
+}
+/**
+* Hasher represents a hashing algorithm implementation that produces as
+* `MultihashDigest`.
+*/
+var Hasher = class {
+	name;
+	code;
+	encode;
+	minDigestLength;
+	maxDigestLength;
+	constructor(name, code, encode, minDigestLength, maxDigestLength) {
+		this.name = name;
+		this.code = code;
+		this.encode = encode;
+		this.minDigestLength = minDigestLength ?? DEFAULT_MIN_DIGEST_LENGTH;
+		this.maxDigestLength = maxDigestLength;
+	}
+	digest(input, options) {
+		if (options?.truncate != null) {
+			if (options.truncate < this.minDigestLength) throw new Error(`Invalid truncate option, must be greater than or equal to ${this.minDigestLength}`);
+			if (this.maxDigestLength != null && options.truncate > this.maxDigestLength) throw new Error(`Invalid truncate option, must be less than or equal to ${this.maxDigestLength}`);
+		}
+		if (input instanceof Uint8Array) {
+			const result = this.encode(input);
+			if (result instanceof Uint8Array) return createDigest(result, this.code, options?.truncate);
+			return result.then((digest) => createDigest(digest, this.code, options?.truncate));
+		} else throw Error("Unknown type, must be binary type");
+	}
+};
+/**
+* Create a Digest from the passed uint8array and code, optionally truncating it
+* first.
+*/
+function createDigest(digest, code, truncate) {
+	if (truncate != null && truncate !== digest.byteLength) {
+		if (truncate > digest.byteLength) throw new Error(`Invalid truncate option, must be less than or equal to ${digest.byteLength}`);
+		digest = digest.subarray(0, truncate);
+	}
+	return create(code, digest);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/sha2.js
+var sha256 = from({
+	name: "sha2-256",
+	code: 18,
+	encode: (input) => coerce(crypto.createHash("sha256").update(input).digest())
+});
+from({
+	name: "sha2-512",
+	code: 19,
+	encode: (input) => coerce(crypto.createHash("sha512").update(input).digest())
+});
+//#endregion
+//#region ../crypto-service/src/json-cid.ts
+/**
+* Generic JSON CID — CIDv1 for arbitrary JSON-serialisable values.
+*
+* Uses the dag-json codec and sha2-256, producing a base32lower CIDv1.
+* Suitable for content-addressing task inputs, schema objects, and other
+* JSON payloads that don't need diary-entry canonical normalisation.
+*/
+async function computeJsonCid(value) {
+	const bytes = encode(value);
+	const hash = await sha256.digest(bytes);
+	return CID.create(1, 512, hash).toString();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/is.js
+var objectTypeNames = [
+	"Object",
+	"RegExp",
+	"Date",
+	"Error",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Promise",
+	"URL",
+	"HTMLElement",
+	"Int8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
 	"Uint16Array",
 	"Int32Array",
 	"Uint32Array",
@@ -6244,6 +6592,112 @@ function createSigningRequestsNamespace(context) {
 	};
 }
 //#endregion
+//#region ../sdk/src/namespaces/tasks.ts
+function createTasksNamespace(context) {
+	const { client, auth } = context;
+	return {
+		async list(query) {
+			return unwrapResult(await listTasks({
+				client,
+				auth,
+				query
+			}));
+		},
+		async create(body) {
+			return unwrapResult(await createTask({
+				client,
+				auth,
+				body
+			}));
+		},
+		async get(id) {
+			return unwrapResult(await getTask({
+				client,
+				auth,
+				path: { id }
+			}));
+		},
+		async claim(id, body) {
+			return unwrapResult(await claimTask({
+				client,
+				auth,
+				path: { id },
+				body
+			}));
+		},
+		async heartbeat(id, n, body) {
+			return unwrapResult(await taskHeartbeat({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				body
+			}));
+		},
+		async complete(id, n, body) {
+			return unwrapResult(await completeTask({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				body
+			}));
+		},
+		async fail(id, n, body) {
+			return unwrapResult(await failTask({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				body
+			}));
+		},
+		async cancel(id, body) {
+			return unwrapResult(await cancelTask({
+				client,
+				auth,
+				path: { id },
+				body
+			}));
+		},
+		async listAttempts(id) {
+			return unwrapResult(await listTaskAttempts({
+				client,
+				auth,
+				path: { id }
+			}));
+		},
+		async listMessages(id, n, query) {
+			return unwrapResult(await listTaskMessages({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				query
+			}));
+		},
+		async appendMessages(id, n, body) {
+			return unwrapResult(await appendTaskMessages({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				body
+			}));
+		}
+	};
+}
+//#endregion
 //#region ../sdk/src/namespaces/teams.ts
 function createTeamsNamespace(context) {
 	const { client, auth } = context;
@@ -6375,6 +6829,7 @@ function createAgent(options) {
 		legreffier: createLegreffierNamespace(context),
 		problems: createProblemsNamespace(context),
 		teams: createTeamsNamespace(context),
+		tasks: createTasksNamespace(context),
 		client,
 		getToken: () => tokenManager.getToken()
 	};
@@ -7113,6 +7568,24 @@ function renderPhase6Markdown(pack) {
 * These tools run on the host (not in the VM) via the MoltNet SDK,
 * so agent credentials never touch the VM filesystem.
 */
+/**
+* Baseline env keys forwarded to host-exec child processes.
+* Callers can extend this set at sandbox startup via `MoltNetToolsConfig.hostExecBaseEnv`.
+*/
+var HOST_EXEC_DEFAULT_BASE_ENV = new Set([
+	"PATH",
+	"HOME",
+	"LANG",
+	"LC_ALL",
+	"TMPDIR",
+	"GIT_CONFIG_GLOBAL",
+	"MOLTNET_CREDENTIALS_PATH",
+	"GIT_AUTHOR_NAME",
+	"GIT_AUTHOR_EMAIL",
+	"GIT_COMMITTER_NAME",
+	"GIT_COMMITTER_EMAIL",
+	"SSH_AUTH_SOCK"
+]);
 function ensureConnected(config) {
 	const agent = config.getAgent();
 	const diaryId = config.getDiaryId();
@@ -7126,303 +7599,548 @@ function ensureConnected(config) {
 * Create all MoltNet tool definitions, ready to pass to `pi.registerTool()`.
 */
 function createMoltNetTools(config) {
-	return [
-		defineTool({
-			name: "moltnet_pack_get",
-			label: "Get MoltNet Pack",
-			description: "Get a context pack by ID. Optionally expand included entries.",
-			parameters: Type.Object({
-				packId: Type.String({ description: "Context pack ID" }),
-				expandEntries: Type.Optional(Type.Boolean({ description: "Include full expanded entries" }))
-			}),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
-				const pack = await agent.packs.get(params.packId, { expand: params.expandEntries ? "entries" : void 0 });
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(pack, null, 2)
-					}],
-					details: {}
-				};
-			}
+	const getPack = defineTool({
+		name: "moltnet_pack_get",
+		label: "Get MoltNet Pack",
+		description: "Get a context pack by ID. Optionally expand included entries.",
+		parameters: Type.Object({
+			packId: Type.String({ description: "Context pack ID" }),
+			expandEntries: Type.Optional(Type.Boolean({ description: "Include full expanded entries" }))
 		}),
-		defineTool({
-			name: "moltnet_pack_create",
-			label: "Create MoltNet Pack",
-			description: "Persist a curated context pack. Entries are caller-ranked (lower rank = more prominent). Recipe/prompt/selection_rationale belong in params. Defaults to pinned=false — packs in the attribution pipeline are ephemeral unless the caller explicitly opts in.",
-			parameters: Type.Object({
-				entries: Type.Array(Type.Object({
-					entryId: Type.String({ description: "Diary entry UUID" }),
-					rank: Type.Number({ description: "Rank (1..N, lower = more prominent)" })
-				}), { description: "Selected entries with their ranks" }),
-				params: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Free-form recipe parameters (recipe name, prompt, selection rationale, etc.)" })),
-				tokenBudget: Type.Optional(Type.Number({ description: "Soft token budget recorded on the pack (optional)" })),
-				pinned: Type.Optional(Type.Boolean({ description: "Pin the pack against retention policy (default false)" }))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const pack = await agent.packs.create(diaryId, {
-					packType: "custom",
-					params: params.params ?? {},
-					entries: params.entries,
-					tokenBudget: params.tokenBudget,
-					pinned: params.pinned ?? false
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(pack, null, 2)
-					}],
-					details: {}
-				};
-			}
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			const pack = await agent.packs.get(params.packId, { expand: params.expandEntries ? "entries" : void 0 });
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(pack, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const createPack = defineTool({
+		name: "moltnet_pack_create",
+		label: "Create MoltNet Pack",
+		description: "Persist a curated context pack. Entries are caller-ranked (lower rank = more prominent). Recipe/prompt/selection_rationale belong in params. Defaults to pinned=false — packs in the attribution pipeline are ephemeral unless the caller explicitly opts in.",
+		parameters: Type.Object({
+			entries: Type.Array(Type.Object({
+				entryId: Type.String({ description: "Diary entry UUID" }),
+				rank: Type.Number({ description: "Rank (1..N, lower = more prominent)" })
+			}), { description: "Selected entries with their ranks" }),
+			params: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Free-form recipe parameters (recipe name, prompt, selection rationale, etc.)" })),
+			tokenBudget: Type.Optional(Type.Number({ description: "Soft token budget recorded on the pack (optional)" })),
+			pinned: Type.Optional(Type.Boolean({ description: "Pin the pack against retention policy (default false)" }))
 		}),
-		defineTool({
-			name: "moltnet_pack_provenance",
-			label: "Get MoltNet Pack Provenance",
-			description: "Get the provenance graph for a context pack by ID or CID.",
-			parameters: Type.Object({
-				packId: Type.Optional(Type.String({ description: "Context pack ID" })),
-				packCid: Type.Optional(Type.String({ description: "Context pack CID" })),
-				depth: Type.Optional(Type.Number({ description: "Supersession ancestry depth to include (default 2)" }))
-			}),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
-				if (!params.packId && !params.packCid) throw new Error("Provide either packId or packCid");
-				if (params.packId && params.packCid) throw new Error("Provide only one of packId or packCid");
-				const graph = params.packId ? await agent.packs.getProvenance(params.packId, { depth: params.depth ?? 2 }) : await agent.packs.getProvenanceByCid(params.packCid, { depth: params.depth ?? 2 });
-				const payload = {
-					metadata: graph.metadata,
-					counts: {
-						nodes: graph.nodes.length,
-						edges: graph.edges.length
-					},
-					graph
-				};
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(payload, null, 2)
-					}],
-					details: {}
-				};
-			}
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const pack = await agent.packs.create(diaryId, {
+				packType: "custom",
+				params: params.params ?? {},
+				entries: params.entries,
+				tokenBudget: params.tokenBudget,
+				pinned: params.pinned ?? false
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(pack, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const getPackProvenance = defineTool({
+		name: "moltnet_pack_provenance",
+		label: "Get MoltNet Pack Provenance",
+		description: "Get the provenance graph for a context pack by ID or CID.",
+		parameters: Type.Object({
+			packId: Type.Optional(Type.String({ description: "Context pack ID" })),
+			packCid: Type.Optional(Type.String({ description: "Context pack CID" })),
+			depth: Type.Optional(Type.Number({ description: "Supersession ancestry depth to include (default 2)" }))
 		}),
-		defineTool({
-			name: "moltnet_pack_render",
-			label: "Render MoltNet Pack",
-			description: "Fetch a pack with entries, transform it into docs, then preview or persist the rendered pack.",
-			parameters: Type.Object({
-				packId: Type.String({ description: "Context pack ID" }),
-				renderMethod: Type.Optional(Type.String({ description: "Render method label. Defaults to pi:pack-to-docs-v1" })),
-				markdown: Type.Optional(Type.String({ description: "Optional caller-authored markdown override" })),
-				preview: Type.Optional(Type.Boolean({ description: "Preview without persisting (default false)" })),
-				pinned: Type.Optional(Type.Boolean({ description: "Persist the rendered pack as pinned (default false)" }))
-			}),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
-				const renderMethod = params.renderMethod ?? "pi:pack-to-docs-v1";
-				let renderedMarkdown = params.markdown;
-				if (!renderedMarkdown && !renderMethod.startsWith("server:")) renderedMarkdown = renderPhase6Markdown(await agent.packs.get(params.packId, { expand: "entries" }));
-				const result = params.preview ?? false ? await agent.packs.previewRendered(params.packId, {
-					renderMethod,
-					renderedMarkdown
-				}) : await agent.packs.render(params.packId, {
-					renderMethod,
-					renderedMarkdown,
-					pinned: params.pinned
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(result, null, 2)
-					}],
-					details: {}
-				};
-			}
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			if (!params.packId && !params.packCid) throw new Error("Provide either packId or packCid");
+			if (params.packId && params.packCid) throw new Error("Provide only one of packId or packCid");
+			const graph = params.packId ? await agent.packs.getProvenance(params.packId, { depth: params.depth ?? 2 }) : await agent.packs.getProvenanceByCid(params.packCid, { depth: params.depth ?? 2 });
+			const payload = {
+				metadata: graph.metadata,
+				counts: {
+					nodes: graph.nodes.length,
+					edges: graph.edges.length
+				},
+				graph
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const renderPack = defineTool({
+		name: "moltnet_pack_render",
+		label: "Render MoltNet Pack",
+		description: "Fetch a pack with entries, transform it into docs, then preview or persist the rendered pack.",
+		parameters: Type.Object({
+			packId: Type.String({ description: "Context pack ID" }),
+			renderMethod: Type.Optional(Type.String({ description: "Render method label. Defaults to pi:pack-to-docs-v1" })),
+			markdown: Type.Optional(Type.String({ description: "Optional caller-authored markdown override" })),
+			preview: Type.Optional(Type.Boolean({ description: "Preview without persisting (default false)" })),
+			pinned: Type.Optional(Type.Boolean({ description: "Persist the rendered pack as pinned (default false)" }))
 		}),
-		defineTool({
-			name: "moltnet_rendered_pack_list",
-			label: "List MoltNet Rendered Packs",
-			description: "List rendered packs for the current MoltNet diary, optionally filtered by source pack or render method.",
-			parameters: Type.Object({
-				sourcePackId: Type.Optional(Type.String({ description: "Filter by source pack ID" })),
-				renderMethod: Type.Optional(Type.String({ description: "Filter by render method" })),
-				limit: Type.Optional(Type.Number({ description: "Max results (default 10)" })),
-				offset: Type.Optional(Type.Number({ description: "Offset for pagination (default 0)" }))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const rendered = await agent.packs.listRendered(diaryId, {
-					sourcePackId: params.sourcePackId,
-					renderMethod: params.renderMethod,
-					limit: params.limit ?? 10,
-					offset: params.offset ?? 0
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(rendered, null, 2)
-					}],
-					details: {}
-				};
-			}
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			const renderMethod = params.renderMethod ?? "pi:pack-to-docs-v1";
+			let renderedMarkdown = params.markdown;
+			if (!renderedMarkdown && !renderMethod.startsWith("server:")) renderedMarkdown = renderPhase6Markdown(await agent.packs.get(params.packId, { expand: "entries" }));
+			const result = params.preview ?? false ? await agent.packs.previewRendered(params.packId, {
+				renderMethod,
+				renderedMarkdown
+			}) : await agent.packs.render(params.packId, {
+				renderMethod,
+				renderedMarkdown,
+				pinned: params.pinned
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const listRenderedPacks = defineTool({
+		name: "moltnet_rendered_pack_list",
+		label: "List MoltNet Rendered Packs",
+		description: "List rendered packs for the current MoltNet diary, optionally filtered by source pack or render method.",
+		parameters: Type.Object({
+			sourcePackId: Type.Optional(Type.String({ description: "Filter by source pack ID" })),
+			renderMethod: Type.Optional(Type.String({ description: "Filter by render method" })),
+			limit: Type.Optional(Type.Number({ description: "Max results (default 10)" })),
+			offset: Type.Optional(Type.Number({ description: "Offset for pagination (default 0)" }))
 		}),
-		defineTool({
-			name: "moltnet_rendered_pack_get",
-			label: "Get MoltNet Rendered Pack",
-			description: "Get a rendered pack by ID.",
-			parameters: Type.Object({ renderedPackId: Type.String({ description: "Rendered pack ID" }) }),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const rendered = await agent.packs.listRendered(diaryId, {
+				sourcePackId: params.sourcePackId,
+				renderMethod: params.renderMethod,
+				limit: params.limit ?? 10,
+				offset: params.offset ?? 0
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(rendered, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const getRenderedPack = defineTool({
+		name: "moltnet_rendered_pack_get",
+		label: "Get MoltNet Rendered Pack",
+		description: "Get a rendered pack by ID.",
+		parameters: Type.Object({ renderedPackId: Type.String({ description: "Rendered pack ID" }) }),
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			const rendered = await agent.packs.getRendered(params.renderedPackId);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(rendered, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const verifyRenderedPack = defineTool({
+		name: "moltnet_rendered_pack_verify",
+		label: "Verify MoltNet Rendered Pack",
+		description: "Create a verification workflow for a rendered pack and return the verification ID and nonce.",
+		parameters: Type.Object({
+			renderedPackId: Type.String({ description: "Rendered pack ID" }),
+			nonce: Type.Optional(Type.String({ description: "Caller-supplied idempotency nonce. Generated automatically if omitted." }))
+		}),
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			const nonce = params.nonce ?? randomUUID();
+			const verification = await agent.packs.verifyRendered(params.renderedPackId, { nonce });
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						...verification,
+						nonce
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const judgeRenderedPack = defineTool({
+		name: "moltnet_rendered_pack_judge",
+		label: "Judge MoltNet Rendered Pack",
+		description: "Run the fidelity judge against a rendered pack. Local mode (no nonce): fetch the rendered pack + its source pack with entries, judge locally, return scores. Proctored mode (nonce): claim the verification payload from the API, judge, and submit scores with a Pi judge-recipe CID.",
+		parameters: Type.Object({
+			renderedPackId: Type.String({ description: "Rendered pack ID" }),
+			nonce: Type.Optional(Type.String({ description: "Verification nonce from moltnet_rendered_pack_verify. If set, runs proctored mode and submits scores. If omitted, runs local mode and does not submit." })),
+			rubric: Type.Optional(Type.String({ description: "Custom rubric override (local mode only). Defaults to the built-in rubric when omitted." }))
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const { agent } = ensureConnected(config);
+			const model = ctx?.model;
+			if (!model) throw new Error("No active model in pi session — cannot run the fidelity judge.");
+			let sourceEntriesMd;
+			let renderedContent;
+			let rubric;
+			if (params.nonce) {
+				if (params.rubric) throw new Error("`rubric` is only supported in local mode (omit `nonce`).");
+				const claim = await agent.packs.claimVerification(params.renderedPackId);
+				sourceEntriesMd = buildSourceEntriesMarkdown(claim.sourceEntries);
+				renderedContent = claim.renderedContent;
+				rubric = claim.rubric?.trim() ? claim.rubric : DEFAULT_RUBRIC;
+			} else {
 				const rendered = await agent.packs.getRendered(params.renderedPackId);
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(rendered, null, 2)
-					}],
-					details: {}
-				};
+				if (!rendered.content?.trim()) throw new Error(`rendered pack ${params.renderedPackId} has empty content`);
+				const sourcePack = await agent.packs.get(rendered.sourcePackId, { expand: "entries" });
+				if (!sourcePack.entries || sourcePack.entries.length === 0) throw new Error(`source pack ${rendered.sourcePackId} has no entries`);
+				sourceEntriesMd = buildSourceEntriesMarkdown(sourcePack.entries.map((entry) => ({
+					title: entry.entry.title,
+					content: entry.entry.content
+				})));
+				renderedContent = rendered.content;
+				rubric = params.rubric?.trim() ? params.rubric : DEFAULT_RUBRIC;
+			}
+			let scores;
+			try {
+				scores = await runFidelityJudge({
+					model,
+					sourceEntries: sourceEntriesMd,
+					renderedContent,
+					rubric
+				});
+			} catch (err) {
+				throw new Error(`judge failed: ${err.message ?? String(err)}`);
 			}
+			if (!params.nonce) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						mode: "local",
+						renderedPackId: params.renderedPackId,
+						scores
+					}, null, 2)
+				}],
+				details: {}
+			};
+			const recipe = computePiJudgeRecipeCid({
+				judgePrompt: JUDGE_SYSTEM_PROMPT,
+				rubric,
+				promptAsset: JUDGE_PROMPT_ASSET_PATH,
+				rubricAsset: RUBRIC_ASSET_PATH
+			});
+			const providerName = model.provider ?? "pi";
+			const modelId = model.id ?? "unknown";
+			const submit = await agent.packs.submitVerification(params.renderedPackId, {
+				nonce: params.nonce,
+				coverage: scores.coverage,
+				grounding: scores.grounding,
+				faithfulness: scores.faithfulness,
+				transcript: scores.reasoning,
+				judgeModel: modelId,
+				judgeProvider: providerName,
+				judgeBinaryCid: recipe.cid
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						mode: "proctored",
+						renderedPackId: params.renderedPackId,
+						scores,
+						submission: submit,
+						judgeRecipeCid: recipe.cid,
+						judgeRecipeManifest: recipe.manifest
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const diaryTags = defineTool({
+		name: "moltnet_diary_tags",
+		label: "List MoltNet Diary Tags",
+		description: "Inventory tags on the current diary with entry counts. Cheap reconnaissance before committing to a search or list — use it to discover scope prefixes and cluster sizes. Optional prefix/minCount/entryTypes filters narrow the result.",
+		parameters: Type.Object({
+			prefix: Type.Optional(Type.String({ description: "Filter to tags starting with this prefix (e.g. \"scope:\")" })),
+			minCount: Type.Optional(Type.Number({ description: "Exclude tags with fewer than this many entries" })),
+			entryTypes: Type.Optional(Type.Array(Type.Union([
+				Type.Literal("episodic"),
+				Type.Literal("semantic"),
+				Type.Literal("procedural"),
+				Type.Literal("reflection"),
+				Type.Literal("identity"),
+				Type.Literal("soul")
+			]), { description: "Scope the tag count to these entry types" }))
 		}),
-		defineTool({
-			name: "moltnet_rendered_pack_verify",
-			label: "Verify MoltNet Rendered Pack",
-			description: "Create a verification workflow for a rendered pack and return the verification ID and nonce.",
-			parameters: Type.Object({
-				renderedPackId: Type.String({ description: "Rendered pack ID" }),
-				nonce: Type.Optional(Type.String({ description: "Caller-supplied idempotency nonce. Generated automatically if omitted." }))
-			}),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
-				const nonce = params.nonce ?? randomUUID();
-				const verification = await agent.packs.verifyRendered(params.renderedPackId, { nonce });
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							...verification,
-							nonce
-						}, null, 2)
-					}],
-					details: {}
-				};
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const result = await agent.diaries.tags(diaryId, {
+				prefix: params.prefix,
+				minCount: params.minCount,
+				entryTypes: params.entryTypes
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const listEntries = defineTool({
+		name: "moltnet_list_entries",
+		label: "List MoltNet Diary Entries",
+		description: "List entries from the MoltNet diary. When `entryIds` is provided, batch-fetches those specific entries (max 50) and returns full fields including entryType, contentSignature, and contentHash for signature checks. Otherwise returns recent entries with a content preview.",
+		parameters: Type.Object({
+			limit: Type.Optional(Type.Number({ description: "Max entries to return (default 10)" })),
+			tag: Type.Optional(Type.String({ description: "Filter by tag (optional)" })),
+			entryIds: Type.Optional(Type.Array(Type.String(), {
+				description: "Batch-fetch specific entries by UUID (max 50). Overrides `limit` and `tag` for selection.",
+				maxItems: 50
+			}))
+		}),
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const query = {
+				orderBy: "createdAt",
+				order: "desc"
+			};
+			const batchMode = !!params.entryIds?.length;
+			if (batchMode) query.ids = params.entryIds;
+			else {
+				query.limit = params.limit ?? 10;
+				if (params.tag) query.tag = params.tag;
 			}
+			const entries = await agent.entries.list(diaryId, query);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(entries.items?.map((e) => batchMode ? {
+						id: e.id,
+						title: e.title,
+						entryType: e.entryType,
+						tags: e.tags,
+						importance: e.importance,
+						contentHash: e.contentHash,
+						contentSignature: e.contentSignature,
+						signingNonce: e.signingNonce,
+						createdAt: e.createdAt
+					} : {
+						id: e.id,
+						title: e.title,
+						tags: e.tags,
+						importance: e.importance,
+						createdAt: e.createdAt,
+						contentPreview: typeof e.content === "string" ? e.content.slice(0, 200) : void 0
+					}), null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const getEntry = defineTool({
+		name: "moltnet_get_entry",
+		label: "Get MoltNet Diary Entry",
+		description: "Get the full content of a specific diary entry by ID.",
+		parameters: Type.Object({ entryId: Type.String({ description: "The entry ID to fetch" }) }),
+		async execute(_id, params) {
+			const { agent } = ensureConnected(config);
+			const entry = await agent.entries.get(params.entryId);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						id: entry.id,
+						title: entry.title,
+						content: entry.content,
+						tags: entry.tags,
+						importance: entry.importance,
+						createdAt: entry.createdAt
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const searchEntries = defineTool({
+		name: "moltnet_search_entries",
+		label: "Search MoltNet Diary Entries",
+		description: "Search diary entries by semantic query. Uses vector similarity to find relevant entries.",
+		parameters: Type.Object({
+			query: Type.String({ description: "Natural language search query" }),
+			limit: Type.Optional(Type.Number({ description: "Max results (default 5)" }))
 		}),
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const results = await agent.entries.search({
+				diaryId,
+				query: params.query,
+				limit: params.limit ?? 5
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(results.results?.map((e) => ({
+						id: e.id,
+						title: e.title,
+						tags: e.tags,
+						importance: e.importance,
+						contentPreview: typeof e.content === "string" ? e.content.slice(0, 200) : void 0
+					})), null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const createEntry = defineTool({
+		name: "moltnet_create_entry",
+		label: "Create MoltNet Diary Entry",
+		description: "Create a new diary entry to record decisions, findings, incidents, or reflections.",
+		parameters: Type.Object({
+			title: Type.String({ description: "Entry title (concise, descriptive)" }),
+			content: Type.String({ description: "Entry content (markdown)" }),
+			tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for categorization" })),
+			importance: Type.Optional(Type.Number({ description: "Importance 1-10 (default 5)" }))
+		}),
+		async execute(_id, params) {
+			const { agent, diaryId } = ensureConnected(config);
+			const entry = await agent.entries.create(diaryId, {
+				title: params.title,
+				content: params.content,
+				tags: params.tags ?? [],
+				importance: params.importance ?? 5
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						id: entry.id,
+						title: entry.title,
+						createdAt: entry.createdAt
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const reviewSessionErrors = defineTool({
+		name: "moltnet_review_session_errors",
+		label: "Review Session Tool Errors",
+		description: "Review tool failures buffered during this session (isError=true results). Use this to decide whether any failures are worth persisting as a diary entry via moltnet_create_entry. Most failures are transient (denied prompts, empty greps, mid-iteration typecheck errors) and should NOT be written to the diary — only persist incidents that represent a real finding (root cause identified, non-obvious workaround, recurring pattern). Pass clear=true to drop the buffer after reviewing.",
+		parameters: Type.Object({ clear: Type.Optional(Type.Boolean({ description: "If true, empty the buffer after returning it. Use once you have decided whether to persist." })) }),
+		async execute(_id, params) {
+			const errors = config.getSessionErrors();
+			const payload = {
+				count: errors.length,
+				errors: errors.map((e) => ({
+					toolName: e.toolName,
+					toolCallId: e.toolCallId,
+					timestamp: new Date(e.timestamp).toISOString(),
+					input: e.input,
+					error: e.error
+				}))
+			};
+			if (params.clear) config.clearSessionErrors();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				details: {}
+			};
+		}
+	});
+	const HOST_EXEC_ALLOWED = new Set([
+		"git",
+		"gh",
+		"moltnet"
+	]);
+	const hostExecBaseEnv = config.hostExecBaseEnv ?? HOST_EXEC_DEFAULT_BASE_ENV;
+	const HOST_EXEC_TIMEOUT_MS = 6e4;
+	return [
+		getPack,
+		createPack,
+		getPackProvenance,
+		renderPack,
+		listRenderedPacks,
+		getRenderedPack,
+		verifyRenderedPack,
+		judgeRenderedPack,
+		diaryTags,
+		listEntries,
+		getEntry,
+		searchEntries,
+		createEntry,
+		reviewSessionErrors,
 		defineTool({
-			name: "moltnet_rendered_pack_judge",
-			label: "Judge MoltNet Rendered Pack",
-			description: "Run the fidelity judge against a rendered pack. Local mode (no nonce): fetch the rendered pack + its source pack with entries, judge locally, return scores. Proctored mode (nonce): claim the verification payload from the API, judge, and submit scores with a Pi judge-recipe CID.",
+			name: "moltnet_host_exec",
+			label: "Run command on host (escape hatch — requires user approval)",
+			description: "Runs a command on the HOST machine, outside the sandbox VM. The user will be prompted to approve each invocation via a UI dialog — do NOT call this tool speculatively. Use ONLY when a sandboxed operation is impossible — e.g. `git push`, `gh pr create`.\n\nAllowed executables: git, gh, moltnet. Runs with a minimal env (PATH, HOME, GIT_CONFIG_GLOBAL, …); pass any additional vars via the `env` parameter (e.g. GH_TOKEN). Every invocation is logged as an auditable host execution.",
 			parameters: Type.Object({
-				renderedPackId: Type.String({ description: "Rendered pack ID" }),
-				nonce: Type.Optional(Type.String({ description: "Verification nonce from moltnet_rendered_pack_verify. If set, runs proctored mode and submits scores. If omitted, runs local mode and does not submit." })),
-				rubric: Type.Optional(Type.String({ description: "Custom rubric override (local mode only). Defaults to the built-in rubric when omitted." }))
+				executable: Type.String({ description: "Executable to run (git | gh | moltnet)" }),
+				args: Type.Array(Type.String(), { description: "Arguments to pass to the executable" }),
+				env: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Additional environment variables for this invocation (e.g. { \"GH_TOKEN\": \"...\" }). Merged on top of the minimal base env." }))
 			}),
 			async execute(_id, params, _signal, _onUpdate, ctx) {
-				const { agent } = ensureConnected(config);
-				const model = ctx?.model;
-				if (!model) throw new Error("No active model in pi session — cannot run the fidelity judge.");
-				let sourceEntriesMd;
-				let renderedContent;
-				let rubric;
-				if (params.nonce) {
-					if (params.rubric) throw new Error("`rubric` is only supported in local mode (omit `nonce`).");
-					const claim = await agent.packs.claimVerification(params.renderedPackId);
-					sourceEntriesMd = buildSourceEntriesMarkdown(claim.sourceEntries);
-					renderedContent = claim.renderedContent;
-					rubric = claim.rubric?.trim() ? claim.rubric : DEFAULT_RUBRIC;
-				} else {
-					const rendered = await agent.packs.getRendered(params.renderedPackId);
-					if (!rendered.content?.trim()) throw new Error(`rendered pack ${params.renderedPackId} has empty content`);
-					const sourcePack = await agent.packs.get(rendered.sourcePackId, { expand: "entries" });
-					if (!sourcePack.entries || sourcePack.entries.length === 0) throw new Error(`source pack ${rendered.sourcePackId} has no entries`);
-					sourceEntriesMd = buildSourceEntriesMarkdown(sourcePack.entries.map((entry) => ({
-						title: entry.entry.title,
-						content: entry.entry.content
-					})));
-					renderedContent = rendered.content;
-					rubric = params.rubric?.trim() ? params.rubric : DEFAULT_RUBRIC;
+				if (!HOST_EXEC_ALLOWED.has(params.executable)) throw new Error(`host_exec: '${params.executable}' is not in the allowed list (${[...HOST_EXEC_ALLOWED].join(", ")}). Extend HOST_EXEC_ALLOWED only after explicit security review.`);
+				if (ctx?.ui) {
+					const cmdDisplay = [params.executable, ...params.args].join(" ");
+					if (!await ctx.ui.confirm("Allow host command?", `The agent wants to run on your machine:\n\n  ${cmdDisplay}\n\nAllow?`)) throw new Error(`host_exec: user declined approval for: ${cmdDisplay}`);
 				}
-				let scores;
+				const cwd = config.getHostCwd?.() ?? process.cwd();
+				const baseEnv = {};
+				for (const key of hostExecBaseEnv) {
+					const val = process.env[key];
+					if (val !== void 0) baseEnv[key] = val;
+				}
+				const mergedEnv = {
+					...baseEnv,
+					...params.env ?? {}
+				};
+				let stdout;
+				let stderr = "";
 				try {
-					scores = await runFidelityJudge({
-						model,
-						sourceEntries: sourceEntriesMd,
-						renderedContent,
-						rubric
+					stdout = execFileSync(params.executable, params.args, {
+						encoding: "utf8",
+						cwd,
+						env: mergedEnv,
+						stdio: [
+							"pipe",
+							"pipe",
+							"pipe"
+						],
+						timeout: HOST_EXEC_TIMEOUT_MS
 					});
 				} catch (err) {
-					throw new Error(`judge failed: ${err.message ?? String(err)}`);
+					const e = err;
+					stdout = e.stdout ?? "";
+					stderr = e.stderr ?? e.message ?? String(err);
 				}
-				if (!params.nonce) return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							mode: "local",
-							renderedPackId: params.renderedPackId,
-							scores
-						}, null, 2)
-					}],
-					details: {}
+				const result = {
+					host_exec: true,
+					executable: params.executable,
+					args: params.args,
+					cwd,
+					stdout: stdout.trimEnd(),
+					stderr: stderr.trimEnd() || void 0
 				};
-				const recipe = computePiJudgeRecipeCid({
-					judgePrompt: JUDGE_SYSTEM_PROMPT,
-					rubric,
-					promptAsset: JUDGE_PROMPT_ASSET_PATH,
-					rubricAsset: RUBRIC_ASSET_PATH
-				});
-				const providerName = model.provider ?? "pi";
-				const modelId = model.id ?? "unknown";
-				const submit = await agent.packs.submitVerification(params.renderedPackId, {
-					nonce: params.nonce,
-					coverage: scores.coverage,
-					grounding: scores.grounding,
-					faithfulness: scores.faithfulness,
-					transcript: scores.reasoning,
-					judgeModel: modelId,
-					judgeProvider: providerName,
-					judgeBinaryCid: recipe.cid
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							mode: "proctored",
-							renderedPackId: params.renderedPackId,
-							scores,
-							submission: submit,
-							judgeRecipeCid: recipe.cid,
-							judgeRecipeManifest: recipe.manifest
-						}, null, 2)
-					}],
-					details: {}
-				};
-			}
-		}),
-		defineTool({
-			name: "moltnet_diary_tags",
-			label: "List MoltNet Diary Tags",
-			description: "Inventory tags on the current diary with entry counts. Cheap reconnaissance before committing to a search or list — use it to discover scope prefixes and cluster sizes. Optional prefix/minCount/entryTypes filters narrow the result.",
-			parameters: Type.Object({
-				prefix: Type.Optional(Type.String({ description: "Filter to tags starting with this prefix (e.g. \"scope:\")" })),
-				minCount: Type.Optional(Type.Number({ description: "Exclude tags with fewer than this many entries" })),
-				entryTypes: Type.Optional(Type.Array(Type.Union([
-					Type.Literal("episodic"),
-					Type.Literal("semantic"),
-					Type.Literal("procedural"),
-					Type.Literal("reflection"),
-					Type.Literal("identity"),
-					Type.Literal("soul")
-				]), { description: "Scope the tag count to these entry types" }))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const result = await agent.diaries.tags(diaryId, {
-					prefix: params.prefix,
-					minCount: params.minCount,
-					entryTypes: params.entryTypes
-				});
 				return {
 					content: [{
 						type: "text",
@@ -7431,169 +8149,6 @@ function createMoltNetTools(config) {
 					details: {}
 				};
 			}
-		}),
-		defineTool({
-			name: "moltnet_list_entries",
-			label: "List MoltNet Diary Entries",
-			description: "List entries from the MoltNet diary. When `entryIds` is provided, batch-fetches those specific entries (max 50) and returns full fields including entryType, contentSignature, and contentHash for signature checks. Otherwise returns recent entries with a content preview.",
-			parameters: Type.Object({
-				limit: Type.Optional(Type.Number({ description: "Max entries to return (default 10)" })),
-				tag: Type.Optional(Type.String({ description: "Filter by tag (optional)" })),
-				entryIds: Type.Optional(Type.Array(Type.String(), {
-					description: "Batch-fetch specific entries by UUID (max 50). Overrides `limit` and `tag` for selection.",
-					maxItems: 50
-				}))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const query = {
-					orderBy: "createdAt",
-					order: "desc"
-				};
-				const batchMode = !!params.entryIds?.length;
-				if (batchMode) query.ids = params.entryIds;
-				else {
-					query.limit = params.limit ?? 10;
-					if (params.tag) query.tag = params.tag;
-				}
-				const entries = await agent.entries.list(diaryId, query);
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(entries.items?.map((e) => batchMode ? {
-							id: e.id,
-							title: e.title,
-							entryType: e.entryType,
-							tags: e.tags,
-							importance: e.importance,
-							contentHash: e.contentHash,
-							contentSignature: e.contentSignature,
-							signingNonce: e.signingNonce,
-							createdAt: e.createdAt
-						} : {
-							id: e.id,
-							title: e.title,
-							tags: e.tags,
-							importance: e.importance,
-							createdAt: e.createdAt,
-							contentPreview: typeof e.content === "string" ? e.content.slice(0, 200) : void 0
-						}), null, 2)
-					}],
-					details: {}
-				};
-			}
-		}),
-		defineTool({
-			name: "moltnet_get_entry",
-			label: "Get MoltNet Diary Entry",
-			description: "Get the full content of a specific diary entry by ID.",
-			parameters: Type.Object({ entryId: Type.String({ description: "The entry ID to fetch" }) }),
-			async execute(_id, params) {
-				const { agent } = ensureConnected(config);
-				const entry = await agent.entries.get(params.entryId);
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							id: entry.id,
-							title: entry.title,
-							content: entry.content,
-							tags: entry.tags,
-							importance: entry.importance,
-							createdAt: entry.createdAt
-						}, null, 2)
-					}],
-					details: {}
-				};
-			}
-		}),
-		defineTool({
-			name: "moltnet_search_entries",
-			label: "Search MoltNet Diary Entries",
-			description: "Search diary entries by semantic query. Uses vector similarity to find relevant entries.",
-			parameters: Type.Object({
-				query: Type.String({ description: "Natural language search query" }),
-				limit: Type.Optional(Type.Number({ description: "Max results (default 5)" }))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const results = await agent.entries.search({
-					diaryId,
-					query: params.query,
-					limit: params.limit ?? 5
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(results.results?.map((e) => ({
-							id: e.id,
-							title: e.title,
-							tags: e.tags,
-							importance: e.importance,
-							contentPreview: typeof e.content === "string" ? e.content.slice(0, 200) : void 0
-						})), null, 2)
-					}],
-					details: {}
-				};
-			}
-		}),
-		defineTool({
-			name: "moltnet_create_entry",
-			label: "Create MoltNet Diary Entry",
-			description: "Create a new diary entry to record decisions, findings, incidents, or reflections.",
-			parameters: Type.Object({
-				title: Type.String({ description: "Entry title (concise, descriptive)" }),
-				content: Type.String({ description: "Entry content (markdown)" }),
-				tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for categorization" })),
-				importance: Type.Optional(Type.Number({ description: "Importance 1-10 (default 5)" }))
-			}),
-			async execute(_id, params) {
-				const { agent, diaryId } = ensureConnected(config);
-				const entry = await agent.entries.create(diaryId, {
-					title: params.title,
-					content: params.content,
-					tags: params.tags ?? [],
-					importance: params.importance ?? 5
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							id: entry.id,
-							title: entry.title,
-							createdAt: entry.createdAt
-						}, null, 2)
-					}],
-					details: {}
-				};
-			}
-		}),
-		defineTool({
-			name: "moltnet_review_session_errors",
-			label: "Review Session Tool Errors",
-			description: "Review tool failures buffered during this session (isError=true results). Use this to decide whether any failures are worth persisting as a diary entry via moltnet_create_entry. Most failures are transient (denied prompts, empty greps, mid-iteration typecheck errors) and should NOT be written to the diary — only persist incidents that represent a real finding (root cause identified, non-obvious workaround, recurring pattern). Pass clear=true to drop the buffer after reviewing.",
-			parameters: Type.Object({ clear: Type.Optional(Type.Boolean({ description: "If true, empty the buffer after returning it. Use once you have decided whether to persist." })) }),
-			async execute(_id, params) {
-				const errors = config.getSessionErrors();
-				const payload = {
-					count: errors.length,
-					errors: errors.map((e) => ({
-						toolName: e.toolName,
-						toolCallId: e.toolCallId,
-						timestamp: new Date(e.timestamp).toISOString(),
-						input: e.input,
-						error: e.error
-					}))
-				};
-				if (params.clear) config.clearSessionErrors();
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(payload, null, 2)
-					}],
-					details: {}
-				};
-			}
 		})
 	];
 }
@@ -7929,10 +8484,6 @@ function createGondolinBashOps(vm, localCwd) {
 }
 //#endregion
 //#region src/vm-manager.ts
-/**
-* VM lifecycle manager: resume checkpoint, inject credentials, configure
-* egress, fix TLS, and provide clean shutdown.
-*/
 var GUEST_WORKSPACE$1 = "/workspace";
 /**
 * Resolve the main worktree root (where .moltnet/ lives — it's untracked,
@@ -7963,6 +8514,15 @@ function loadCredentials(agentDir) {
 	const sshPrivateKey = existsSync(path.join(sshDir, "id_ed25519")) ? readFileSync(path.join(sshDir, "id_ed25519"), "utf8") : null;
 	const sshPublicKey = existsSync(path.join(sshDir, "id_ed25519.pub")) ? readFileSync(path.join(sshDir, "id_ed25519.pub"), "utf8") : null;
 	const allowedSigners = existsSync(path.join(sshDir, "allowed_signers")) ? readFileSync(path.join(sshDir, "allowed_signers"), "utf8") : null;
+	let githubAppPem = null;
+	let githubAppPemFilename = null;
+	const pemPath = JSON.parse(moltnetJson).github?.private_key_path;
+	if (pemPath) if (!existsSync(pemPath)) process.stderr.write(`[pi-extension] Warning: github.private_key_path not found at ${pemPath} — moltnet github token will fail inside the guest
+`);
+	else {
+		githubAppPem = readFileSync(pemPath, "utf8");
+		githubAppPemFilename = path.basename(pemPath);
+	}
 	return {
 		moltnetJson,
 		agentEnvRaw,
@@ -7971,7 +8531,9 @@ function loadCredentials(agentDir) {
 		gitconfig,
 		sshPrivateKey,
 		sshPublicKey,
-		allowedSigners
+		allowedSigners,
+		githubAppPem,
+		githubAppPemFilename
 	};
 }
 /**
@@ -8018,13 +8580,15 @@ async function resumeVm(config) {
 		apiHost,
 		...config.extraAllowedHosts ?? []
 	] });
+	const vmAgentDir = `/home/agent/.moltnet/${config.agentName}`;
 	const vmAgentEnv = {};
 	for (const [k, v] of Object.entries(creds.agentEnv)) {
 		if (v === void 0 || v === "") continue;
-		if (k === "GIT_CONFIG_GLOBAL") vmAgentEnv[k] = `/home/agent/.moltnet/${config.agentName}/gitconfig`;
-		else if (k.endsWith("_PRIVATE_KEY_PATH")) vmAgentEnv[k] = `/home/agent/.moltnet/${config.agentName}/${path.basename(v)}`;
+		if (k === "GIT_CONFIG_GLOBAL") vmAgentEnv[k] = `${vmAgentDir}/gitconfig`;
+		else if (k.endsWith("_PRIVATE_KEY_PATH")) vmAgentEnv[k] = `${vmAgentDir}/${path.basename(v)}`;
 		else vmAgentEnv[k] = v;
 	}
+	vmAgentEnv.MOLTNET_CREDENTIALS_PATH = `${vmAgentDir}/moltnet.json`;
 	const vfsConfig = config.sandboxConfig?.vfs;
 	let workspaceProvider = new RealFSProvider(config.mountPath);
 	if (vfsConfig?.shadow?.length) {
@@ -8059,11 +8623,11 @@ async function resumeVm(config) {
   '`);
 	await vm.exec(`sh -c 'echo "nameserver 8.8.8.8
 nameserver 1.1.1.1" > /etc/resolv.conf'`);
-	const vmAgentDir = `/home/agent/.moltnet/${config.agentName}`;
 	const vmSshDir = `${vmAgentDir}/ssh`;
 	await vm.exec(`mkdir -p ${vmAgentDir}/ssh /home/agent/.pi/agent`);
 	await vm.fs.writeFile("/home/agent/.pi/agent/auth.json", creds.piAuthJson, { mode: 384 });
-	await vm.fs.writeFile(`${vmAgentDir}/moltnet.json`, creds.moltnetJson, { mode: 384 });
+	const vmMoltnetJson = rewriteMoltnetJsonPaths(creds.moltnetJson, vmAgentDir, vmSshDir, creds.githubAppPemFilename);
+	await vm.fs.writeFile(`${vmAgentDir}/moltnet.json`, vmMoltnetJson, { mode: 384 });
 	await vm.fs.writeFile(`${vmAgentDir}/env`, creds.agentEnvRaw, { mode: 384 });
 	if (creds.gitconfig) {
 		const vmSigningKey = `${vmSshDir}/id_ed25519`;
@@ -8074,6 +8638,7 @@ nameserver 1.1.1.1" > /etc/resolv.conf'`);
 	if (creds.sshPrivateKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519`, creds.sshPrivateKey, { mode: 384 });
 	if (creds.sshPublicKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519.pub`, creds.sshPublicKey, { mode: 420 });
 	if (creds.allowedSigners) await vm.fs.writeFile(`${vmSshDir}/allowed_signers`, creds.allowedSigners, { mode: 420 });
+	if (creds.githubAppPem && creds.githubAppPemFilename) await vm.fs.writeFile(`${vmAgentDir}/${creds.githubAppPemFilename}`, creds.githubAppPem, { mode: 384 });
 	await vm.exec("chown -R agent:agent /home/agent/.pi /home/agent/.moltnet");
 	return {
 		vm,
@@ -8084,6 +8649,43 @@ nameserver 1.1.1.1" > /etc/resolv.conf'`);
 	};
 }
 /**
+* Rewrite host-absolute paths inside moltnet.json to VM-local equivalents.
+*
+* Fields rewritten:
+*   ssh.private_key_path  → <vmSshDir>/<basename of original>
+*   ssh.public_key_path   → <vmSshDir>/<basename of original>
+*   git.config_path       → <vmAgentDir>/gitconfig
+*   github.private_key_path → <vmAgentDir>/<pemFilename>  (if present)
+*
+* All other fields are passed through unchanged.
+* Throws if moltnetJson is not valid JSON — callers must not inject a broken
+* moltnet.json into the guest.
+*/
+function rewriteMoltnetJsonPaths(moltnetJson, vmAgentDir, vmSshDir, githubAppPemFilename) {
+	const config = JSON.parse(moltnetJson);
+	if (config.ssh && typeof config.ssh === "object") {
+		const ssh = config.ssh;
+		const origPrivate = typeof ssh.private_key_path === "string" ? ssh.private_key_path : null;
+		const origPublic = typeof ssh.public_key_path === "string" ? ssh.public_key_path : null;
+		config.ssh = {
+			...ssh,
+			...origPrivate !== null && { private_key_path: `${vmSshDir}/${path.basename(origPrivate)}` },
+			...origPublic !== null && { public_key_path: `${vmSshDir}/${path.basename(origPublic)}` }
+		};
+	}
+	if (config.git && typeof config.git === "object") {
+		const git = { ...config.git };
+		git.config_path = `${vmAgentDir}/gitconfig`;
+		config.git = git;
+	}
+	if (githubAppPemFilename && config.github && typeof config.github === "object") {
+		const github = { ...config.github };
+		github.private_key_path = `${vmAgentDir}/${githubAppPemFilename}`;
+		config.github = github;
+	}
+	return JSON.stringify(config);
+}
+/**
 * Ensure `[worktree] useRelativePaths = true` is set in the given
 * gitconfig text. If the section exists, rewrite the key; otherwise
 * append a new section.
@@ -8121,9 +8723,9 @@ if (!FormatRegistry.Has("date-time")) FormatRegistry.Set("date-time", (v) => !Nu
 * own signed rows and CIDv1 lookup. The schema below is designed to
 * carry forward unchanged — only storage and addressing differ.
 *
-* Until Phase 2 lands, `rubric_id` + `version` + `content_hash` are
+* Until Phase 2 lands, `rubricId` + `version` + `contentHash` are
 * informational fields the author fills in; no uniqueness is enforced.
-* `content_hash` is optional in Phase 1 because the *task*'s input_cid
+* `contentHash` is optional in Phase 1 because the *task*'s input_cid
 * is the authoritative commitment.
 */
 /**
@@ -8159,12 +8761,12 @@ var RubricCriterion = Type$1.Object({
 * (stored row `body`); only the addressing mechanism differs.
 */
 var Rubric = Type$1.Object({
-	rubric_id: Type$1.String({ minLength: 1 }),
+	rubricId: Type$1.String({ minLength: 1 }),
 	version: Type$1.String({ minLength: 1 }),
 	preamble: Type$1.Optional(Type$1.String()),
 	criteria: Type$1.Array(RubricCriterion, { minItems: 1 }),
 	scope: Type$1.Optional(Type$1.String()),
-	content_hash: Type$1.Optional(Type$1.String())
+	contentHash: Type$1.Optional(Type$1.String())
 }, {
 	$id: "Rubric",
 	additionalProperties: false
@@ -8220,25 +8822,25 @@ var AssessBriefCriterion = Type$1.Object({
 	additionalProperties: false
 });
 var AssessBriefInput = Type$1.Object({
-	target_task_id: Type$1.String({ format: "uuid" }),
+	targetTaskId: Type$1.String({ format: "uuid" }),
 	criteria: Type$1.Array(AssessBriefCriterion, { minItems: 1 }),
-	rubric_preamble: Type$1.Optional(Type$1.String())
+	rubricPreamble: Type$1.Optional(Type$1.String())
 }, {
 	$id: "AssessBriefInput",
 	additionalProperties: false
 });
 /** One score line. */
 var AssessBriefScore = Type$1.Object({
-	criterion_id: Type$1.String({ minLength: 1 }),
+	criterionId: Type$1.String({ minLength: 1 }),
 	score: Type$1.Number({
 		minimum: 0,
 		maximum: 1
 	}),
 	rationale: Type$1.Optional(Type$1.String()),
 	evidence: Type$1.Optional(Type$1.Object({
-		commits_verified: Type$1.Number(),
-		commits_total: Type$1.Number(),
-		signature_failures: Type$1.Array(Type$1.String())
+		commitsVerified: Type$1.Number(),
+		commitsTotal: Type$1.Number(),
+		signatureFailures: Type$1.Array(Type$1.String())
 	}, { additionalProperties: false }))
 }, {
 	$id: "AssessBriefScore",
@@ -8251,7 +8853,7 @@ var AssessBriefOutput = Type$1.Object({
 		maximum: 1
 	}),
 	verdict: Type$1.String({ minLength: 1 }),
-	judge_model: Type$1.Optional(Type$1.String())
+	judgeModel: Type$1.Optional(Type$1.String())
 }, {
 	$id: "AssessBriefOutput",
 	additionalProperties: false
@@ -8282,15 +8884,15 @@ var EntryTypeFilter = Type$1.Union([
 	Type$1.Literal("reflection")
 ]);
 var CuratePackInput = Type$1.Object({
-	diary_id: Type$1.String({ format: "uuid" }),
-	task_prompt: Type$1.String({ minLength: 1 }),
-	entry_types: Type$1.Optional(Type$1.Array(EntryTypeFilter, { minItems: 1 })),
-	tag_filters: Type$1.Optional(Type$1.Object({
+	diaryId: Type$1.String({ format: "uuid" }),
+	taskPrompt: Type$1.String({ minLength: 1 }),
+	entryTypes: Type$1.Optional(Type$1.Array(EntryTypeFilter, { minItems: 1 })),
+	tagFilters: Type$1.Optional(Type$1.Object({
 		include: Type$1.Optional(Type$1.Array(Type$1.String())),
 		exclude: Type$1.Optional(Type$1.Array(Type$1.String())),
 		prefix: Type$1.Optional(Type$1.String())
 	}, { additionalProperties: false })),
-	token_budget: Type$1.Optional(Type$1.Number({ minimum: 500 })),
+	tokenBudget: Type$1.Optional(Type$1.Number({ minimum: 500 })),
 	recipe: Type$1.Optional(Type$1.Union([Type$1.Literal("topic-focused-v1"), Type$1.Literal("scope-inventory-v1")]))
 }, {
 	$id: "CuratePackInput",
@@ -8302,18 +8904,18 @@ var CuratePackInput = Type$1.Object({
 * is the receipt.
 */
 var CuratePackOutput = Type$1.Object({
-	pack_id: Type$1.String({ format: "uuid" }),
-	pack_cid: Type$1.String({ minLength: 1 }),
+	packId: Type$1.String({ format: "uuid" }),
+	packCid: Type$1.String({ minLength: 1 }),
 	entries: Type$1.Array(Type$1.Object({
-		entry_id: Type$1.String({ format: "uuid" }),
+		entryId: Type$1.String({ format: "uuid" }),
 		rank: Type$1.Number({ minimum: 1 }),
 		rationale: Type$1.String({ minLength: 1 })
 	}, { additionalProperties: false }), { minItems: 1 }),
-	recipe_params: Type$1.Record(Type$1.String(), Type$1.Unknown()),
+	recipeParams: Type$1.Record(Type$1.String(), Type$1.Unknown()),
 	checkpoints: Type$1.Optional(Type$1.Array(Type$1.Object({
 		phase: Type$1.String({ minLength: 1 }),
-		candidate_ids: Type$1.Array(Type$1.String({ format: "uuid" })),
-		dropped_ids: Type$1.Optional(Type$1.Array(Type$1.String({ format: "uuid" }))),
+		candidateIds: Type$1.Array(Type$1.String({ format: "uuid" })),
+		droppedIds: Type$1.Optional(Type$1.Array(Type$1.String({ format: "uuid" }))),
 		notes: Type$1.String({ minLength: 1 })
 	}, { additionalProperties: false }))),
 	summary: Type$1.String({ minLength: 1 })
@@ -8334,9 +8936,9 @@ var FULFILL_BRIEF_TYPE = "fulfill_brief";
 var FulfillBriefInput = Type$1.Object({
 	brief: Type$1.String({ minLength: 1 }),
 	title: Type$1.Optional(Type$1.String()),
-	acceptance_criteria: Type$1.Optional(Type$1.Array(Type$1.String())),
-	seed_files: Type$1.Optional(Type$1.Array(Type$1.String())),
-	scope_hint: Type$1.Optional(Type$1.String())
+	acceptanceCriteria: Type$1.Optional(Type$1.Array(Type$1.String())),
+	seedFiles: Type$1.Optional(Type$1.Array(Type$1.String())),
+	scopeHint: Type$1.Optional(Type$1.String())
 }, {
 	$id: "FulfillBriefInput",
 	additionalProperties: false
@@ -8350,10 +8952,10 @@ var FulfillBriefOutput = Type$1.Object({
 	commits: Type$1.Array(Type$1.Object({
 		sha: Type$1.String({ minLength: 7 }),
 		message: Type$1.String(),
-		diary_entry_id: Type$1.Union([Type$1.String({ format: "uuid" }), Type$1.Null()])
+		diaryEntryId: Type$1.Union([Type$1.String({ format: "uuid" }), Type$1.Null()])
 	}, { additionalProperties: false })),
-	pull_request_url: Type$1.Union([Type$1.String(), Type$1.Null()]),
-	diary_entry_ids: Type$1.Array(Type$1.String({ format: "uuid" })),
+	pullRequestUrl: Type$1.Union([Type$1.String(), Type$1.Null()]),
+	diaryEntryIds: Type$1.Array(Type$1.String({ format: "uuid" })),
 	summary: Type$1.String({ minLength: 1 })
 }, {
 	$id: "FulfillBriefOutput",
@@ -8384,8 +8986,8 @@ var FulfillBriefOutput = Type$1.Object({
 */
 var JUDGE_PACK_TYPE = "judge_pack";
 var JudgePackInput = Type$1.Object({
-	rendered_pack_id: Type$1.String({ format: "uuid" }),
-	source_pack_id: Type$1.String({ format: "uuid" }),
+	renderedPackId: Type$1.String({ format: "uuid" }),
+	sourcePackId: Type$1.String({ format: "uuid" }),
 	rubric: Rubric
 }, {
 	$id: "JudgePackInput",
@@ -8393,7 +8995,7 @@ var JudgePackInput = Type$1.Object({
 });
 /** One scored criterion. Mirrors `AssessBriefScore`. */
 var JudgePackScore = Type$1.Object({
-	criterion_id: Type$1.String({ minLength: 1 }),
+	criterionId: Type$1.String({ minLength: 1 }),
 	score: Type$1.Number({
 		minimum: 0,
 		maximum: 1
@@ -8411,8 +9013,8 @@ var JudgePackOutput = Type$1.Object({
 		maximum: 1
 	}),
 	verdict: Type$1.String({ minLength: 1 }),
-	judge_model: Type$1.Optional(Type$1.String()),
-	renderer_binary_cid: Type$1.Optional(Type$1.Union([Type$1.String(), Type$1.Null()]))
+	judgeModel: Type$1.Optional(Type$1.String()),
+	rendererBinaryCid: Type$1.Optional(Type$1.Union([Type$1.String(), Type$1.Null()]))
 }, {
 	$id: "JudgePackOutput",
 	additionalProperties: false
@@ -8436,7 +9038,7 @@ var JudgePackOutput = Type$1.Object({
 */
 var RENDER_PACK_TYPE = "render_pack";
 var RenderPackInput = Type$1.Object({
-	pack_id: Type$1.String({ format: "uuid" }),
+	packId: Type$1.String({ format: "uuid" }),
 	persist: Type$1.Optional(Type$1.Boolean()),
 	pinned: Type$1.Optional(Type$1.Boolean())
 }, {
@@ -8444,11 +9046,11 @@ var RenderPackInput = Type$1.Object({
 	additionalProperties: false
 });
 var RenderPackOutput = Type$1.Object({
-	rendered_pack_id: Type$1.Union([Type$1.String({ format: "uuid" }), Type$1.Null()]),
-	rendered_cid: Type$1.String({ minLength: 1 }),
-	render_method: Type$1.String({ minLength: 1 }),
-	byte_size: Type$1.Number({ minimum: 0 }),
-	entries_rendered: Type$1.Number({ minimum: 0 }),
+	renderedPackId: Type$1.Union([Type$1.String({ format: "uuid" }), Type$1.Null()]),
+	renderedCid: Type$1.String({ minLength: 1 }),
+	renderMethod: Type$1.String({ minLength: 1 }),
+	byteSize: Type$1.Number({ minimum: 0 }),
+	entriesRendered: Type$1.Number({ minimum: 0 }),
 	summary: Type$1.String({ minLength: 1 })
 }, {
 	$id: "RenderPackOutput",
@@ -8509,6 +9111,41 @@ var BUILT_IN_TASK_TYPES = {
 	}
 };
 //#endregion
+//#region ../tasks/src/task-type-registry.ts
+var schemaCids = null;
+function getTaskTypeRegistry() {
+	if (!schemaCids) throw new Error("Task type registry not initialized. Call initTaskTypeRegistry() first.");
+	return schemaCids;
+}
+new Proxy({}, { get(_, prop) {
+	if (typeof prop !== "string") return void 0;
+	return getTaskTypeRegistry().get(prop);
+} });
+//#endregion
+//#region ../tasks/src/validation.ts
+function getTaskTypeEntry(taskType) {
+	const taskTypes = BUILT_IN_TASK_TYPES;
+	if (!Object.prototype.hasOwnProperty.call(taskTypes, taskType)) return;
+	return taskTypes[taskType];
+}
+function formatField(prefix, path) {
+	return path ? `${prefix}${path}` : prefix;
+}
+function schemaErrors(prefix, schema, value) {
+	return [...Value.Errors(schema, value)].map((error) => ({
+		field: formatField(prefix, error.path),
+		message: error.message
+	}));
+}
+function validateTaskOutput(taskType, output) {
+	const entry = getTaskTypeEntry(taskType);
+	if (!entry) return [{
+		field: "taskType",
+		message: `Unknown task type: ${taskType}`
+	}];
+	return schemaErrors("output", entry.outputSchema, output);
+}
+//#endregion
 //#region ../tasks/src/wire.ts
 /**
 * Wire-format types for the MoltNet Task model.
@@ -8520,7 +9157,7 @@ var BUILT_IN_TASK_TYPES = {
 *   - `TaskReporter` output records (PR 0)
 *
 * Invariant: every property on `Task` is type-neutral (applies to all
-* `task_type`s). Type-specific payloads live inside `input` / `output`
+* `taskType`s). Type-specific payloads live inside `input` / `output`
 * JSONB, validated against schemas registered under `task_types`.
 *
 * Identity rule:
@@ -8563,8 +9200,8 @@ var IsoTimestamp = Type$1.String({ format: "date-time" });
 * Embedded in `tasks.references` JSONB array.
 */
 var TaskRef = Type$1.Object({
-	task_id: Type$1.Union([Uuid, Type$1.Null()]),
-	output_cid: Cid,
+	taskId: Type$1.Union([Uuid, Type$1.Null()]),
+	outputCid: Cid,
 	role: Type$1.Union([
 		Type$1.Literal("judged_work"),
 		Type$1.Literal("reviewed_diff"),
@@ -8593,11 +9230,11 @@ var TaskRef = Type$1.Object({
 * `TaskOutput.usage` for convenience.
 */
 var TaskUsage = Type$1.Object({
-	input_tokens: Type$1.Integer({ minimum: 0 }),
-	output_tokens: Type$1.Integer({ minimum: 0 }),
-	cache_read_tokens: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
-	cache_write_tokens: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
-	tool_calls: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
+	inputTokens: Type$1.Integer({ minimum: 0 }),
+	outputTokens: Type$1.Integer({ minimum: 0 }),
+	cacheReadTokens: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
+	cacheWriteTokens: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
+	toolCalls: Type$1.Optional(Type$1.Integer({ minimum: 0 })),
 	model: Type$1.Optional(Type$1.String()),
 	provider: Type$1.Optional(Type$1.String())
 }, {
@@ -8617,62 +9254,65 @@ var TaskError = Type$1.Object({
 	additionalProperties: false
 });
 Type$1.Object({
-	agent_id: Type$1.Union([Uuid, Type$1.Null()]),
-	human_id: Type$1.Union([Uuid, Type$1.Null()])
+	agentId: Type$1.Union([Uuid, Type$1.Null()]),
+	humanId: Type$1.Union([Uuid, Type$1.Null()])
 }, {
 	$id: "ActorPair",
 	additionalProperties: false
 });
 Type$1.Object({
 	id: Uuid,
-	task_type: Type$1.String({ minLength: 1 }),
-	team_id: Uuid,
-	diary_id: Type$1.Union([Uuid, Type$1.Null()]),
-	output_kind: OutputKind,
+	taskType: Type$1.String({ minLength: 1 }),
+	teamId: Uuid,
+	diaryId: Type$1.Union([Uuid, Type$1.Null()]),
+	outputKind: OutputKind,
 	input: Type$1.Record(Type$1.String(), Type$1.Unknown()),
-	input_schema_cid: Cid,
-	input_cid: Cid,
-	criteria_cid: Type$1.Union([Cid, Type$1.Null()]),
+	inputSchemaCid: Cid,
+	inputCid: Cid,
+	criteriaCid: Type$1.Union([Cid, Type$1.Null()]),
 	references: Type$1.Array(TaskRef),
-	correlation_id: Type$1.Union([Uuid, Type$1.Null()]),
-	imposed_by_agent_id: Type$1.Union([Uuid, Type$1.Null()]),
-	imposed_by_human_id: Type$1.Union([Uuid, Type$1.Null()]),
-	accepted_attempt_n: Type$1.Union([Type$1.Number(), Type$1.Null()]),
+	correlationId: Type$1.Union([Uuid, Type$1.Null()]),
+	imposedByAgentId: Type$1.Union([Uuid, Type$1.Null()]),
+	imposedByHumanId: Type$1.Union([Uuid, Type$1.Null()]),
+	acceptedAttemptN: Type$1.Union([Type$1.Number(), Type$1.Null()]),
 	status: TaskStatus,
-	queued_at: IsoTimestamp,
-	completed_at: Type$1.Union([IsoTimestamp, Type$1.Null()]),
-	expires_at: Type$1.Union([IsoTimestamp, Type$1.Null()]),
-	cancelled_by_agent_id: Type$1.Union([Uuid, Type$1.Null()]),
-	cancelled_by_human_id: Type$1.Union([Uuid, Type$1.Null()]),
-	cancel_reason: Type$1.Union([Type$1.String(), Type$1.Null()]),
-	max_attempts: Type$1.Number({ minimum: 1 })
+	queuedAt: IsoTimestamp,
+	completedAt: Type$1.Union([IsoTimestamp, Type$1.Null()]),
+	expiresAt: Type$1.Union([IsoTimestamp, Type$1.Null()]),
+	cancelledByAgentId: Type$1.Union([Uuid, Type$1.Null()]),
+	cancelledByHumanId: Type$1.Union([Uuid, Type$1.Null()]),
+	cancelReason: Type$1.Union([Type$1.String(), Type$1.Null()]),
+	maxAttempts: Type$1.Number({ minimum: 1 })
 }, {
 	$id: "Task",
 	additionalProperties: false
 });
 Type$1.Object({
-	task_id: Uuid,
-	attempt_n: Type$1.Number({ minimum: 1 }),
-	claimed_by_agent_id: Uuid,
-	runtime_id: Type$1.Union([Uuid, Type$1.Null()]),
-	claimed_at: IsoTimestamp,
-	started_at: Type$1.Union([IsoTimestamp, Type$1.Null()]),
-	completed_at: Type$1.Union([IsoTimestamp, Type$1.Null()]),
+	taskId: Uuid,
+	attemptN: Type$1.Number({ minimum: 1 }),
+	claimedByAgentId: Uuid,
+	runtimeId: Type$1.Union([Uuid, Type$1.Null()]),
+	claimedAt: IsoTimestamp,
+	startedAt: Type$1.Union([IsoTimestamp, Type$1.Null()]),
+	completedAt: Type$1.Union([IsoTimestamp, Type$1.Null()]),
 	status: TaskAttemptStatus,
 	output: Type$1.Union([Type$1.Record(Type$1.String(), Type$1.Unknown()), Type$1.Null()]),
-	output_cid: Type$1.Union([Cid, Type$1.Null()]),
+	outputCid: Type$1.Union([Cid, Type$1.Null()]),
 	error: Type$1.Union([TaskError, Type$1.Null()]),
 	usage: Type$1.Union([TaskUsage, Type$1.Null()]),
-	content_signature: Type$1.Union([Type$1.String(), Type$1.Null()]),
-	signed_at: Type$1.Union([IsoTimestamp, Type$1.Null()])
+	contentSignature: Type$1.Union([Type$1.String(), Type$1.Null()]),
+	signedAt: Type$1.Union([IsoTimestamp, Type$1.Null()])
 }, {
 	$id: "TaskAttempt",
 	additionalProperties: false
 });
 Type$1.Object({
-	task_id: Uuid,
-	attempt_n: Type$1.Number({ minimum: 1 }),
-	seq: Type$1.Number({ minimum: 0 }),
+	taskId: Uuid,
+	attemptN: Type$1.Number({ minimum: 1 }),
+	seq: Type$1.Number({
+		minimum: 0,
+		description: "Monotonically increasing integer assigned by the server. Use as the afterSeq cursor on the list-messages endpoint to poll for new messages without re-fetching earlier ones."
+	}),
 	timestamp: IsoTimestamp,
 	kind: TaskMessageKind,
 	payload: Type$1.Record(Type$1.String(), Type$1.Unknown())
@@ -8681,34 +9321,34 @@ Type$1.Object({
 	additionalProperties: false
 });
 Type$1.Object({
-	task_id: Uuid,
-	attempt_n: Type$1.Number({ minimum: 1 }),
+	taskId: Uuid,
+	attemptN: Type$1.Number({ minimum: 1 }),
 	status: Type$1.Union([
 		Type$1.Literal("completed"),
 		Type$1.Literal("failed"),
 		Type$1.Literal("cancelled")
 	]),
 	output: Type$1.Union([Type$1.Record(Type$1.String(), Type$1.Unknown()), Type$1.Null()]),
-	output_cid: Type$1.Union([Cid, Type$1.Null()]),
+	outputCid: Type$1.Union([Cid, Type$1.Null()]),
 	usage: TaskUsage,
-	duration_ms: Type$1.Number({ minimum: 0 }),
+	durationMs: Type$1.Number({ minimum: 0 }),
 	error: Type$1.Optional(TaskError),
-	content_signature: Type$1.Optional(Type$1.String())
+	contentSignature: Type$1.Optional(Type$1.String())
 }, {
 	$id: "TaskOutput",
 	additionalProperties: false
 });
 Type$1.Object({
-	runtime_id: Uuid,
-	agent_id: Uuid,
+	runtimeId: Uuid,
+	agentId: Uuid,
 	timestamp: IsoTimestamp,
 	status: Type$1.Union([
 		Type$1.Literal("idle"),
 		Type$1.Literal("busy"),
 		Type$1.Literal("draining")
 	]),
-	active_task_ids: Type$1.Array(Uuid),
-	supported_task_types: Type$1.Array(Type$1.String())
+	activeTaskIds: Type$1.Array(Uuid),
+	supportedTaskTypes: Type$1.Array(Type$1.String())
 }, {
 	$id: "RuntimeHeartbeat",
 	additionalProperties: false
@@ -8729,10 +9369,10 @@ function buildAssessBriefPrompt(input, ctx) {
 		...ctx.target.diaryEntryIds.map((id) => `- ${id}`),
 		""
 	].join("\n") : "";
-	const preambleSection = input.rubric_preamble ? [
+	const preambleSection = input.rubricPreamble ? [
 		"### Rubric preamble",
 		"",
-		input.rubric_preamble,
+		input.rubricPreamble,
 		""
 	].join("\n") : "";
 	return [
@@ -8763,12 +9403,12 @@ function buildAssessBriefPrompt(input, ctx) {
 		"",
 		"- `llm_judged`: score 0..1 continuous. `rationale` REQUIRED (2–4 sentences).",
 		"- `boolean`: score exactly 0 or 1. `rationale` optional.",
-		"- `deterministic_signature_check`: run `moltnet entry verify` on every diary entry listed above AND `git verify-commit` on every commit. Score 1 iff ALL signatures are valid; otherwise 0. Populate `evidence.commits_verified`, `evidence.commits_total`, `evidence.signature_failures`.",
+		"- `deterministic_signature_check`: run `moltnet entry verify` on every diary entry listed above AND `git verify-commit` on every commit. Score 1 iff ALL signatures are valid; otherwise 0. Populate `evidence.commitsVerified`, `evidence.commitsTotal`, `evidence.signatureFailures`.",
 		"",
 		"### Final output",
 		"",
 		"Emit a JSON object matching `AssessBriefOutput`:",
-		"  { \"scores\": [{criterion_id, score, rationale?, evidence?}], \"composite\", \"verdict\", \"judge_model\"? }",
+		"  { \"scores\": [{criterionId, score, rationale?, evidence?}], \"composite\", \"verdict\", \"judgeModel\"? }",
 		"`composite` = Σ(weight_i × score_i) recomputed. The runtime will reject a mismatch.",
 		"Write a signed diary entry (tags: \"judgment\", \"assess_brief\") capturing the rationale before emitting the JSON."
 	].filter(Boolean).join("\n");
@@ -8790,7 +9430,7 @@ function buildAssessBriefPrompt(input, ctx) {
 * N isolated `createAgentSession` children (one per tag cluster or
 * entry_type axis the curator picks after recon), each with a narrow
 * tool subset and a turn cap, and returns compressed summaries. Parent
-* curator keeps a warm context and only sees {candidate_ids, notes}
+* curator keeps a warm context and only sees {candidateIds, notes}
 * per probe — mirrors the fan-out pattern pi-mono SDK example #13
 * (session runtime) + #05 (custom tools) makes possible. Until that
 * lands, the `checkpoints[]` output field is the fallback: curator
@@ -8798,7 +9438,7 @@ function buildAssessBriefPrompt(input, ctx) {
 * resume without replaying the tool history.
 */
 function buildCuratePackPrompt(input, ctx) {
-	const { diary_id: diaryId, task_prompt: taskPrompt, entry_types: entryTypes, tag_filters: tagFilters, token_budget: tokenBudget, recipe } = input;
+	const { diaryId, taskPrompt, entryTypes, tagFilters, tokenBudget, recipe } = input;
 	const effectiveEntryTypes = entryTypes ?? [
 		"semantic",
 		"episodic",
@@ -8885,7 +9525,7 @@ function buildCuratePackPrompt(input, ctx) {
 		"",
 		"The tool returns a JSON payload whose top-level fields are `packId` and",
 		"`packCid` (NOT `id`). Copy those exact UUID/CID strings verbatim into",
-		"`pack_id` and `pack_cid` in your final output — do not substitute an",
+		"`packId` and `packCid` in your final output — do not substitute an",
 		"entry id, do not reformat, do not fabricate a UUID.",
 		"",
 		"## Hard constraints",
@@ -8902,14 +9542,14 @@ function buildCuratePackPrompt(input, ctx) {
 		"Write to stdout a JSON object matching `CuratePackOutput`:",
 		"```",
 		"{",
-		"  \"pack_id\": \"<uuid>\",",
-		"  \"pack_cid\": \"<cid>\",",
+		"  \"packId\": \"<uuid>\",",
+		"  \"packCid\": \"<cid>\",",
 		"  \"entries\": [",
-		"    { \"entry_id\": \"<uuid>\", \"rank\": 1, \"rationale\": \"<why>\" }",
+		"    { \"entryId\": \"<uuid>\", \"rank\": 1, \"rationale\": \"<why>\" }",
 		"  ],",
-		"  \"recipe_params\": { \"recipe\": \"...\", \"prompt\": \"...\", ... },",
+		"  \"recipeParams\": { \"recipe\": \"...\", \"prompt\": \"...\", ... },",
 		"  \"checkpoints\": [",
-		"    { \"phase\": \"recon\", \"candidate_ids\": [...], \"dropped_ids\": [...], \"notes\": \"...\" }",
+		"    { \"phase\": \"recon\", \"candidateIds\": [...], \"droppedIds\": [...], \"notes\": \"...\" }",
 		"  ],",
 		"  \"summary\": \"<2-4 sentences: what you looked for, how you narrowed, what defines the final set>\"",
 		"}",
@@ -8927,7 +9567,7 @@ function buildCuratePackPrompt(input, ctx) {
 * is told to inspect them itself.
 */
 function buildFulfillBriefPrompt(input, ctx) {
-	const { brief, title, acceptance_criteria: acceptanceCriteria, seed_files: seedFiles, scope_hint: scopeHint } = input;
+	const { brief, title, acceptanceCriteria, seedFiles, scopeHint } = input;
 	const criteriaSection = acceptanceCriteria?.length ? [
 		"### Acceptance criteria",
 		"",
@@ -8976,14 +9616,14 @@ function buildFulfillBriefPrompt(input, ctx) {
 		"### Final output",
 		"",
 		"When done, write to stdout a JSON object with shape matching `FulfillBriefOutput`:",
-		"  { \"branch\", \"commits\": [{sha, message, diary_entry_id}], \"pull_request_url\", \"diary_entry_ids\", \"summary\" }",
+		"  { \"branch\", \"commits\": [{sha, message, diaryEntryId}], \"pullRequestUrl\", \"diaryEntryIds\", \"summary\" }",
 		"The runtime parses this as the structured task output. Failing to emit it is a failure."
 	].filter(Boolean).join("\n");
 }
 //#endregion
 //#region ../agent-runtime/src/prompts/judge-pack.ts
 function buildJudgePackPrompt(input, ctx) {
-	const { rendered_pack_id: renderedPackId, source_pack_id: sourcePackId, rubric } = input;
+	const { renderedPackId, sourcePackId, rubric } = input;
 	const criteriaList = rubric.criteria.map((c, i) => `${i + 1}. **${c.id}** (weight ${c.weight}, scoring: \`${c.scoring}\`) — ${c.description}`).join("\n");
 	const preambleSection = rubric.preamble ? [
 		"### Rubric preamble",
@@ -9006,7 +9646,7 @@ function buildJudgePackPrompt(input, ctx) {
 		"",
 		`- **Rendered pack**: \`${renderedPackId}\``,
 		`- **Source pack**: \`${sourcePackId}\``,
-		`- **Rubric**: \`${rubric.rubric_id}\` v${rubric.version}`,
+		`- **Rubric**: \`${rubric.rubricId}\` v${rubric.version}`,
 		"",
 		preambleSection,
 		"## Workflow",
@@ -9045,12 +9685,12 @@ function buildJudgePackPrompt(input, ctx) {
 		"  non-empty `contentSignature`. If `required_signed_total` is 0,",
 		"  score = 1. Populate `evidence` with `{ entries_verified,",
 		"  entries_total, required_signed_total, required_signed_ok,",
-		"  signature_failures: [entry_ids] }` where `signature_failures` lists",
+		"  signatureFailures: [entryIds] }` where `signatureFailures` lists",
 		"  ONLY the REQUIRED-SIGNED entries that lack a signature.",
 		"- `deterministic_coverage_check`: for every source entry, check",
-		"  whether its `entry_id` (or a stable reference like title + CID",
+		"  whether its `entryId` (or a stable reference like title + CID",
 		"  prefix) appears in the rendered `content`. Score 1 iff coverage is",
-		"  complete; otherwise 0. Populate `evidence` with `{ covered, total, missing: [entry_ids] }`.",
+		"  complete; otherwise 0. Populate `evidence` with `{ covered, total, missing: [entryIds] }`.",
 		"",
 		"## Constraints",
 		"",
@@ -9064,17 +9704,17 @@ function buildJudgePackPrompt(input, ctx) {
 		"Write to stdout a JSON object matching `JudgePackOutput`:",
 		"```",
 		"{",
-		"  \"scores\": [{\"criterion_id\": \"...\", \"score\": 0.0, \"rationale\": \"...\", \"evidence\": {...}}],",
+		"  \"scores\": [{\"criterionId\": \"...\", \"score\": 0.0, \"rationale\": \"...\", \"evidence\": {...}}],",
 		"  \"composite\": <sum-of-weighted-scores>,",
 		"  \"verdict\": \"<1-3 sentence overall>\",",
-		"  \"judge_model\": \"<provider:model>\",",
-		"  \"renderer_binary_cid\": \"<cid-string-only-if-available>\"",
+		"  \"judgeModel\": \"<provider:model>\",",
+		"  \"rendererBinaryCid\": \"<cid-string-only-if-available>\"",
 		"}",
 		"```",
-		"Omit `renderer_binary_cid` entirely when no binary CID is exposed by",
+		"Omit `rendererBinaryCid` entirely when no binary CID is exposed by",
 		"`moltnet_rendered_pack_get`. Do NOT emit `null` — the field is optional",
 		"and absence is the correct representation when unavailable.",
-		`Write a signed diary entry (tags: \`judgment\`, \`judge_pack\`, \`rubric:${rubric.rubric_id}\`) capturing the rationale before`,
+		`Write a signed diary entry (tags: \`judgment\`, \`judge_pack\`, \`rubric:${rubric.rubricId}\`) capturing the rationale before`,
 		"emitting the JSON."
 	].filter((l) => l !== null).join("\n");
 }
@@ -9085,7 +9725,7 @@ function buildJudgePackPrompt(input, ctx) {
 * wraps `moltnet_pack_render` and emits the receipt.
 */
 function buildRenderPackPrompt(input, ctx) {
-	const { pack_id: packId, persist = true, pinned = false } = input;
+	const { packId, persist = true, pinned = false } = input;
 	return [
 		"# Render Pack Agent",
 		"",
@@ -9125,11 +9765,11 @@ function buildRenderPackPrompt(input, ctx) {
 		"Write to stdout a JSON object matching `RenderPackOutput`:",
 		"```",
 		"{",
-		"  \"rendered_pack_id\": \"<uuid-or-null>\",",
-		"  \"rendered_cid\": \"<cid>\",",
-		"  \"render_method\": \"<label>\",",
-		"  \"byte_size\": <int>,",
-		"  \"entries_rendered\": <int>,",
+		"  \"renderedPackId\": \"<uuid-or-null>\",",
+		"  \"renderedCid\": \"<cid>\",",
+		"  \"renderMethod\": \"<label>\",",
+		"  \"byteSize\": <int>,",
+		"  \"entriesRendered\": <int>,",
 		"  \"summary\": \"<1-3 sentence recap>\"",
 		"}",
 		"```",
@@ -9139,11 +9779,11 @@ function buildRenderPackPrompt(input, ctx) {
 //#endregion
 //#region ../agent-runtime/src/prompts/index.ts
 /**
-* Resolve the correct prompt builder for `task.task_type` and invoke it.
+* Resolve the correct prompt builder for `task.taskType` and invoke it.
 * Throws if the type is unknown or the input fails TypeBox validation.
 */
 function buildPromptForTask(task, ctx) {
-	switch (task.task_type) {
+	switch (task.taskType) {
 		case FULFILL_BRIEF_TYPE:
 			if (!Value.Check(FulfillBriefInput, task.input)) {
 				const errors = [...Value.Errors(FulfillBriefInput, task.input)];
@@ -9193,10 +9833,102 @@ function buildPromptForTask(task, ctx) {
 				diaryId: ctx.diaryId,
 				taskId: ctx.taskId
 			});
-		default: throw new Error(`No prompt builder registered for task_type="${task.task_type}"`);
+		default: throw new Error(`No prompt builder registered for taskType="${task.taskType}"`);
 	}
 }
 //#endregion
+//#region src/runtime/task-output.ts
+async function parseStructuredTaskOutput(assistantText, taskType) {
+	const extracted = extractJsonObject(assistantText);
+	if (!extracted) return {
+		output: null,
+		outputCid: null,
+		error: {
+			code: "output_missing",
+			message: "Agent did not emit a parseable JSON object as its final message."
+		}
+	};
+	const errors = validateTaskOutput(taskType, extracted);
+	if (errors.length > 0) {
+		const details = errors.slice(0, 3).map((error) => `${error.field}: ${error.message}`);
+		const [firstError] = errors;
+		return {
+			output: null,
+			outputCid: null,
+			error: {
+				code: firstError?.field === "taskType" ? "unknown_task_type" : "output_validation_failed",
+				message: `Output failed schema validation: ${details.join("; ")}`
+			}
+		};
+	}
+	try {
+		return {
+			output: extracted,
+			outputCid: await computeJsonCid(extracted),
+			error: null
+		};
+	} catch (error) {
+		return {
+			output: null,
+			outputCid: null,
+			error: {
+				code: "output_cid_compute_failed",
+				message: `Validated output could not be canonicalized: ${error instanceof Error ? error.message : String(error)}`
+			}
+		};
+	}
+}
+/**
+* Find the last balanced top-level JSON object in `text` and parse it.
+* Tolerates markdown fences and leading prose. Returns null if parsing fails.
+*/
+function extractJsonObject(text) {
+	if (!text) return null;
+	const fenceMatch = /```(?:json)?\s*([\s\S]*?)```/gi;
+	const candidates = [];
+	for (const m of text.matchAll(fenceMatch)) candidates.push(m[1]);
+	const scanForObject = (s) => {
+		let depth = 0;
+		let start = -1;
+		let lastComplete = null;
+		let inString = false;
+		let escape = false;
+		for (let i = 0; i < s.length; i++) {
+			const ch = s[i];
+			if (inString) {
+				if (escape) escape = false;
+				else if (ch === "\\") escape = true;
+				else if (ch === "\"") inString = false;
+				continue;
+			}
+			if (ch === "\"") {
+				inString = true;
+				continue;
+			}
+			if (ch === "{") {
+				if (depth === 0) start = i;
+				depth++;
+			} else if (ch === "}") {
+				depth--;
+				if (depth === 0 && start !== -1) {
+					lastComplete = s.slice(start, i + 1);
+					start = -1;
+				}
+			}
+		}
+		return lastComplete;
+	};
+	candidates.push(text);
+	for (let i = candidates.length - 1; i >= 0; i--) {
+		const obj = scanForObject(candidates[i]);
+		if (!obj) continue;
+		try {
+			return JSON.parse(obj);
+		} catch {}
+	}
+	return null;
+}
+//#endregion
 //#region src/runtime/execute-pi-task.ts
 /**
 * executePiTask — run a single Task attempt using pi-coding-agent inside a
@@ -9221,14 +9953,14 @@ function buildPromptForTask(task, ctx) {
 */
 function createPiTaskExecutor(opts) {
 	let cachedCheckpoint = opts.checkpointPath ?? null;
-	return async (task, reporter) => {
+	return async (claimedTask, reporter) => {
 		if (!cachedCheckpoint) cachedCheckpoint = await ensureSnapshot({
 			config: opts.sandboxConfig?.snapshot,
 			onProgress: opts.onSnapshotProgress ?? ((m) => {
 				process.stderr.write(`[snapshot] ${m}\n`);
 			})
 		});
-		return executePiTask(task, reporter, {
+		return executePiTask(claimedTask, reporter, {
 			...opts,
 			checkpointPath: cachedCheckpoint
 		});
@@ -9240,8 +9972,9 @@ function createPiTaskExecutor(opts) {
 * a `TaskOutput` (failures surface as `status: 'failed'`); throws only on
 * unrecoverable setup errors.
 */
-async function executePiTask(task, reporter, opts) {
-	const attemptN = opts.attemptN ?? 1;
+async function executePiTask(claimedTask, reporter, opts) {
+	const task = claimedTask.task;
+	const attemptN = claimedTask.attemptN;
 	const startTime = Date.now();
 	const mountPath = opts.mountPath ?? process.cwd();
 	const checkpointPath = opts.checkpointPath ?? await ensureSnapshot({
@@ -9267,17 +10000,18 @@ async function executePiTask(task, reporter, opts) {
 		extraAllowedHosts: opts.extraAllowedHosts,
 		sandboxConfig: opts.sandboxConfig
 	});
-	const diaryId = task.diary_id ?? "";
+	const diaryId = task.diaryId ?? "";
 	let reporterOpen = false;
 	let session = null;
-	const makeFailedOutput = (code, message, usage = emptyUsage(opts.provider, opts.model)) => ({
-		task_id: task.id,
-		attempt_n: attemptN,
+	const finalUsage = emptyUsage(opts.provider, opts.model);
+	const makeFailedOutput = (code, message, usage = finalUsage) => ({
+		taskId: task.id,
+		attemptN,
 		status: "failed",
 		output: null,
-		output_cid: null,
+		outputCid: null,
 		usage,
-		duration_ms: Date.now() - startTime,
+		durationMs: Date.now() - startTime,
 		error: {
 			code,
 			message,
@@ -9298,8 +10032,8 @@ async function executePiTask(task, reporter, opts) {
 		});
 		await emit("info", {
 			event: "execute_start",
-			task_type: task.task_type,
-			team_id: task.team_id,
+			taskType: task.taskType,
+			teamId: task.teamId,
 			provider: opts.provider,
 			model: opts.model
 		});
@@ -9330,7 +10064,9 @@ async function executePiTask(task, reporter, opts) {
 				getAgent: () => moltnetAgent,
 				getDiaryId: () => diaryId,
 				getSessionErrors: () => [],
-				clearSessionErrors: () => {}
+				clearSessionErrors: () => {},
+				getHostCwd: () => mountPath,
+				hostExecBaseEnv: new Set([...HOST_EXEC_DEFAULT_BASE_ENV, ...Object.keys(managed.credentials.agentEnv)])
 			});
 			const piAuthDir = join(homedir(), ".pi", "agent");
 			const modelHandle = getModel(opts.provider, opts.model);
@@ -9358,7 +10094,7 @@ async function executePiTask(task, reporter, opts) {
 		let llmAbort = false;
 		let assistantText = "";
 		let reporterError = null;
-		const usage = emptyUsage(opts.provider, opts.model);
+		const usage = finalUsage;
 		const recordingPromise = [];
 		const track = (p) => {
 			recordingPromise.push(p.catch((err) => {
@@ -9388,12 +10124,12 @@ async function executePiTask(task, reporter, opts) {
 			else if (event.type === "turn_end") {
 				const msg = event.message;
 				if (msg?.role === "assistant" && msg.usage) {
-					usage.input_tokens += Math.max(0, msg.usage.input ?? 0);
-					usage.output_tokens += Math.max(0, msg.usage.output ?? 0);
+					usage.inputTokens += Math.max(0, msg.usage.input ?? 0);
+					usage.outputTokens += Math.max(0, msg.usage.output ?? 0);
 					const cr = Math.max(0, msg.usage.cacheRead ?? 0);
 					const cw = Math.max(0, msg.usage.cacheWrite ?? 0);
-					if (cr) usage.cache_read_tokens = (usage.cache_read_tokens ?? 0) + cr;
-					if (cw) usage.cache_write_tokens = (usage.cache_write_tokens ?? 0) + cw;
+					if (cr) usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + cr;
+					if (cw) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + cw;
 				}
 				track(emit("turn_end", { stop_reason: msg?.stopReason ?? "end_turn" }));
 				llmAbort = msg?.stopReason === "error";
@@ -9415,28 +10151,13 @@ async function executePiTask(task, reporter, opts) {
 		}
 		await Promise.all(recordingPromise);
 		let parsedOutput = null;
+		let parsedOutputCid = null;
 		let parseError = null;
 		if (!runError && !llmAbort) {
-			const extracted = extractJsonObject(assistantText);
-			if (!extracted) parseError = {
-				code: "output_missing",
-				message: "Agent did not emit a parseable JSON object as its final message."
-			};
-			else {
-				const entry = BUILT_IN_TASK_TYPES[task.task_type];
-				if (!entry) parseError = {
-					code: "unknown_task_type",
-					message: `No output schema registered for task_type=${task.task_type}`
-				};
-				else {
-					const check = TypeCompiler.Compile(entry.outputSchema);
-					if (check.Check(extracted)) parsedOutput = extracted;
-					else parseError = {
-						code: "output_validation_failed",
-						message: `Output failed schema validation: ${[...check.Errors(extracted)].slice(0, 3).map((e) => `${e.path}: ${e.message}`).join("; ")}`
-					};
-				}
-			}
+			const parsed = await parseStructuredTaskOutput(assistantText, task.taskType);
+			parsedOutput = parsed.output;
+			parsedOutputCid = parsed.outputCid;
+			parseError = parsed.error;
 			if (parseError) await emit("error", {
 				message: parseError.message,
 				phase: "output_validation"
@@ -9446,13 +10167,13 @@ async function executePiTask(task, reporter, opts) {
 		const errorCode = runError?.code ?? parseError?.code ?? reporterError?.code ?? (llmAbort ? "llm_api_error" : void 0);
 		const errorMessage = runError?.message ?? parseError?.message ?? reporterError?.message ?? (llmAbort ? "LLM API error during turn" : void 0);
 		return {
-			task_id: task.id,
-			attempt_n: attemptN,
+			taskId: task.id,
+			attemptN,
 			status,
 			output: parsedOutput,
-			output_cid: null,
+			outputCid: parsedOutputCid,
 			usage,
-			duration_ms: Date.now() - startTime,
+			durationMs: Date.now() - startTime,
 			...errorCode && errorMessage ? { error: {
 				code: errorCode,
 				message: errorMessage,
@@ -9467,7 +10188,7 @@ async function executePiTask(task, reporter, opts) {
 		} catch {}
 		if (reporterOpen) {
 			try {
-				await reporter.finalize(emptyUsage(opts.provider, opts.model));
+				await reporter.finalize(finalUsage);
 			} catch {}
 			try {
 				await reporter.close();
@@ -9478,8 +10199,8 @@ async function executePiTask(task, reporter, opts) {
 }
 function emptyUsage(provider, model) {
 	return {
-		input_tokens: 0,
-		output_tokens: 0,
+		inputTokens: 0,
+		outputTokens: 0,
 		provider,
 		model
 	};
@@ -9513,79 +10234,16 @@ function truncateForWire(value) {
 		};
 	}
 }
-/**
-* Find the last balanced top-level JSON object in `text` and parse it.
-* Tolerates markdown fences and leading prose. Returns null if parsing fails.
-*/
-function extractJsonObject(text) {
-	if (!text) return null;
-	const fenceMatch = /```(?:json)?\s*([\s\S]*?)```/gi;
-	const candidates = [];
-	for (const m of text.matchAll(fenceMatch)) candidates.push(m[1]);
-	const scanForObject = (s) => {
-		let depth = 0;
-		let start = -1;
-		let lastComplete = null;
-		let inString = false;
-		let escape = false;
-		for (let i = 0; i < s.length; i++) {
-			const ch = s[i];
-			if (inString) {
-				if (escape) escape = false;
-				else if (ch === "\\") escape = true;
-				else if (ch === "\"") inString = false;
-				continue;
-			}
-			if (ch === "\"") {
-				inString = true;
-				continue;
-			}
-			if (ch === "{") {
-				if (depth === 0) start = i;
-				depth++;
-			} else if (ch === "}") {
-				depth--;
-				if (depth === 0 && start !== -1) {
-					lastComplete = s.slice(start, i + 1);
-					start = -1;
-				}
-			}
-		}
-		return lastComplete;
-	};
-	candidates.push(text);
-	for (let i = candidates.length - 1; i >= 0; i--) {
-		const obj = scanForObject(candidates[i]);
-		if (!obj) continue;
-		try {
-			return JSON.parse(obj);
-		} catch {}
-	}
-	return null;
-}
 //#endregion
 //#region src/index.ts
 /**
 * @themoltnet/pi-extension — MoltNet pi extension
 *
-* Sandboxes tool execution in a Gondolin VM with:
-*   - Auto-built and cached VM snapshots
-*   - Credential injection (pi OAuth + MoltNet identity)
-*   - Egress policy (only LLM provider + MoltNet API)
-*   - Tool redirection (read/write/edit/bash → VM)
-*   - MoltNet custom tools (diary entries — run on host via SDK)
-*   - Optional git worktree per session
+* Runs pi coding-agent sessions inside a Gondolin VM with the agent's
+* MoltNet identity fully available inside the sandbox.
 *
-* Usage:
-*   pi -e @themoltnet/pi-extension
-*   pi -e @themoltnet/pi-extension --agent legreffier
-*   pi -e @themoltnet/pi-extension --worktree-branch feat/my-task
-*   pi -e @themoltnet/pi-extension --sandbox-config ./sandbox.json
-*
-* Sandbox config resolution (first match):
-*   1. --sandbox-config flag (explicit path to JSON)
-*   2. sandbox.json in cwd (convention)
-*   3. Base only (git, gh, moltnet CLI, agent user)
+* See README.md for credential injection flow, tool split, sandbox.json
+* reference, and headless/programmatic usage.
 */
 var GUEST_WORKSPACE = "/workspace";
 function moltnetExtension(pi) {
@@ -9623,6 +10281,7 @@ function moltnetExtension(pi) {
 	let worktreePath = null;
 	let moltnetAgent = null;
 	let diaryId = null;
+	let hostExecBaseEnv = HOST_EXEC_DEFAULT_BASE_ENV;
 	async function ensureVm(ctx) {
 		if (vm) return vm;
 		if (vmStarting) return vmStarting;
@@ -9676,6 +10335,7 @@ function moltnetExtension(pi) {
 			activateAgentEnv(managed.credentials.agentEnv, mainRepo);
 			moltnetAgent = await connect({ configDir: managed.agentDir });
 			diaryId = managed.credentials.agentEnv.MOLTNET_DIARY_ID ?? null;
+			hostExecBaseEnv = new Set([...HOST_EXEC_DEFAULT_BASE_ENV, ...Object.keys(managed.credentials.agentEnv)]);
 			vm = managed.vm;
 			const label = worktreePath ? `${mountPath} → ${GUEST_WORKSPACE}` : `${localCwd} → ${GUEST_WORKSPACE}`;
 			ctx?.ui.setStatus("sandbox", ctx.ui.theme.fg("accent", `Sandbox: running (${label})`));
@@ -9738,7 +10398,9 @@ function moltnetExtension(pi) {
 		getSessionErrors: () => sessionErrors,
 		clearSessionErrors: () => {
 			sessionErrors.length = 0;
-		}
+		},
+		getHostCwd: () => worktreePath ?? localCwd,
+		hostExecBaseEnv
 	});
 	for (const tool of moltnetTools) pi.registerTool(tool);
 	const sessionStartTime = Date.now();
@@ -9844,4 +10506,4 @@ function moltnetExtension(pi) {
 	registerMoltnetReflectCommand(pi, state);
 }
 //#endregion
-export { activateAgentEnv, buildPiJudgeRecipeManifest, computePiJudgeRecipeCid, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiTaskExecutor, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, loadCredentials, resolvePiJudgeRecipeVersions, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildPiJudgeRecipeManifest, computePiJudgeRecipeCid, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiTaskExecutor, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, loadCredentials, resolvePiJudgeRecipeVersions, resumeVm, toGuestPath };