@themoltnet/pi-extension 0.33.0 → 0.33.1

package/dist/index.d.ts

@@ -308,6 +308,12 @@ export declare interface ExecutePiTaskOptions {
     sandboxConfig?: SandboxConfig;
     /** Host environment variable names to forward into the Pi VM. */
     forwardEnv?: string[];
+    /**
+     * Runtime profile context defaults. Merged with task.input.context at
+     * execution time because the selected runtime profile is known only after
+     * claim. Task entries override profile entries with the same slug.
+     */
+    runtimeProfileContext?: readonly ContextRef[];
     /**
      * Forwarded to `buildTaskUserPrompt` for per-type builders. Static
      * across tasks. Today no built-in builder needs per-task `extras` —
@@ -480,14 +486,14 @@ export declare interface InjectedTaskContext {
 }
 
 /**
- * Resolve a task's `input.context[]` and inject the side effects pi
+ * Resolve effective runtime context and inject the side effects Pi
  * needs. Safe to call with an empty array — returns an inert result.
  */
 export declare function injectTaskContext(args: InjectTaskContextArgs): Promise<InjectedTaskContext>;
 
 export declare interface InjectTaskContextArgs {
     /** Empty array (the default for any non-eval task) is a no-op. */
-    context: TaskContext;
+    context: readonly ContextRef[];
     /** Guest filesystem handle. In production this is `managed.vm.fs`. */
     fs: VmFsForContext;
     /** Guest path where the active host workspace is mounted. */
@@ -922,15 +928,6 @@ declare const Task: Type.TObject<{
 
 declare type Task = Static<typeof Task>;
 
-/** Reusable input fragment for any task type. Soft cap at 5 items. */
-declare const TaskContext: Type.TArray<Type.TObject<{
-    slug: Type.TString;
-    binding: Type.TUnion<[Type.TLiteral<"skill">, Type.TLiteral<"context_inline">, Type.TLiteral<"prompt_prefix">, Type.TLiteral<"user_inline">]>;
-    content: Type.TString;
-}>>;
-
-declare type TaskContext = Static<typeof TaskContext>;
-
 declare const TaskMessage: Type.TObject<{
     taskId: Type.TString;
     attemptN: Type.TNumber;

package/dist/index.js

@@ -1965,7 +1965,7 @@ var findLatestRuntimeSlotForAttempt = (options) => (options.client ?? client).ge
 	...options
 });
 /**
-* Queue asynchronous deletion of terminal tasks in bulk. By default, live, unauthorized, missing, and protected tasks are skipped. Set force: true with a reason to delete protected terminal tasks.
+* Queue asynchronous deletion of waiting, queued, and terminal tasks in bulk. By default, dispatched, running, unauthorized, missing, and protected tasks are skipped. Set force: true with a reason to delete protected terminal tasks.
 */
 var batchDeleteTasks = (options) => (options.client ?? client).delete({
 	security: [
@@ -10030,7 +10030,7 @@ _Object_({
 * (server-side schema check). Self-assessment is a truthful self-rating,
 * NOT enforcement — `verification.passed=false` does not block /complete
 * and does not affect `acceptedAttemptN`. See
-* `docs/understand/agent-runtime.md` for the full producer/judge flow.
+* `docs/use/tasks-and-runtime.md` for the full producer/judge flow.
 *
 * **Binding evaluation** (judgment tasks: `assess_brief`, `judge_pack`).
 * A separate task whose IS the application of `successCriteria` to
@@ -19937,8 +19937,19 @@ async function resolvePersistentSessionManager(args) {
 //#endregion
 //#region ../agent-runtime/src/context-bindings.ts
 var PROMPT_SEPARATOR = "\n\n---\n\n";
+var MAX_MERGED_RUNTIME_CONTEXT_ENTRIES = 10;
 /**
-* Resolve `task.input.context[]` into delivered side-effects (skills
+* Merge runtime-profile context defaults with task-scoped context. Profile
+* entries are defaults; task entries with the same slug override them.
+*/
+function mergeRuntimeProfileContext(profileContext, taskContext) {
+	const taskSlugs = new Set(taskContext.map((ref) => ref.slug));
+	const merged = [...profileContext.filter((ref) => !taskSlugs.has(ref.slug)), ...taskContext];
+	if (merged.length > MAX_MERGED_RUNTIME_CONTEXT_ENTRIES) throw new Error(`merged runtime context has ${merged.length} entries; maximum is ${MAX_MERGED_RUNTIME_CONTEXT_ENTRIES}`);
+	return merged;
+}
+/**
+* Resolve runtime context entries into delivered side-effects (skills
 * persisted via `deliver.skill`) and prompt fragments
 * (`systemPromptPrefix`, `userInlineSuffix`) the caller weaves into the
 * built prompt.
@@ -19958,9 +19969,10 @@ var PROMPT_SEPARATOR = "\n\n---\n\n";
 *   - `user_inline`   → content appended to `userInlineSuffix` in
 *                       declared order, same separator.
 *
-* No fetching, no hashing — bytes are inlined in `ContextRef.content`,
-* and the task's `inputCid` already pins the entire input. The proposer
-* chose these bytes; the resolver just dispatches them.
+* No fetching, no hashing — bytes are inlined in `ContextRef.content`.
+* Task-scoped entries are pinned by the task's `inputCid`; profile-scoped
+* entries are pinned by the runtime profile revision/source the daemon
+* resolved. The resolver just dispatches already-selected bytes.
 *
 * The function is pure with respect to its arguments: file writes are
 * confined to the injected `deliver` callback, which makes the
@@ -20006,12 +20018,13 @@ function formatInlineContextBlock(slug, content) {
 		"### Injected Task Context",
 		"",
 		`Context id: \`${slug}\``,
-		"The following raw context was supplied by the task creator. Treat it",
-		"as task-relevant background that may override generic coding instincts",
-		"when it contains repo- or workflow-specific constraints.",
+		"The following raw context was selected for this task by its task input",
+		"or runtime profile. Treat it as task-relevant background that may",
+		"override generic coding instincts when it contains repo- or",
+		"workflow-specific constraints.",
 		"The same content may also be materialized by the runtime under",
 		"`/moltnet-task-context/context` for tool-based inspection. Do not",
-		"create or rely on workspace mirror files for this task context.",
+		"create or rely on workspace mirror files for this runtime context.",
 		"",
 		"<context>",
 		content,
@@ -21334,11 +21347,11 @@ function buildRenderPackUserPrompt(input, ctx) {
 * `judge_eval_attempt` task(s) grade against their own hidden rubric.
 *
 * Context delivery is handled by `resolveTaskContext` (see
-* libs/agent-runtime/src/context-bindings.ts) and runs BEFORE this
-* prompt is rendered: `prompt_prefix` items are concatenated ahead of
-* the body, `skill` items are persisted at the runtime's skill path,
-* and `user_inline` items are appended to the first user message. This
-* builder does NOT inline `input.context[]` itself.
+* libs/agent-runtime/src/context-bindings.ts) and is selected BEFORE this
+* prompt is rendered. Task-scoped context lives in `input.context`; runtime
+* profile defaults arrive as `ctx.effectiveRuntimeContext` after the runtime
+* merges them with task context. This builder only renders context
+* discipline; it does NOT inline context bytes itself.
 *
 * Prompt-shape notes (issue #1175, area 1):
 * - No `Correlation` section: the agent never acts on it. The id is
@@ -21356,12 +21369,13 @@ function buildRenderPackUserPrompt(input, ctx) {
 */
 function buildRunEvalUserPrompt(input, ctx) {
 	const { scenario, variantLabel, successCriteria } = input;
-	const hasContext = input.context.length > 0;
-	const hasInlineContext = input.context.some((entry) => entry.binding === "context_inline");
+	const effectiveRuntimeContext = ctx.effectiveRuntimeContext ?? input.context;
+	const hasContext = effectiveRuntimeContext.length > 0;
+	const hasInlineContext = effectiveRuntimeContext.some((entry) => entry.binding === "context_inline");
 	const header = `# Run Eval Agent\n\nYou are running an evaluation scenario as variant \`${variantLabel}\`.\nTask id: \`${ctx.taskId}\``;
 	const contextDiscipline = hasContext ? [
 		"This task includes Injected Task Context supplied by the task",
-		"creator. You MUST inspect it BEFORE you write solution files or",
+		"input or runtime profile. You MUST inspect it BEFORE you write solution files or",
 		"draft your final answer — not after.",
 		"",
 		"Reconcile every constraint from that context **into the code path",
@@ -21534,7 +21548,8 @@ function buildTaskUserPrompt(task, ctx) {
 			return buildRunEvalUserPrompt(task.input, {
 				diaryId: ctx.diaryId,
 				taskId: ctx.taskId,
-				correlationId: task.correlationId
+				correlationId: task.correlationId,
+				effectiveRuntimeContext: ctx.effectiveRuntimeContext
 			});
 		default: throw new Error(`No prompt builder registered for taskType="${task.taskType}"`);
 	}
@@ -25007,119 +25022,6 @@ var require_multistream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports.pino = pino;
 })))();
 //#endregion
-//#region src/runtime/inject-task-context.ts
-/**
-* Slice 1.5 of #943 — wire the agent-runtime resolver into the
-* pi-extension execution path.
-*
-* `resolveTaskContext` is a pure dispatcher; this module provides the
-* Gondolin-aware deliverer and the post-resolution shape the
-* `execute-pi-task` caller needs to splice into pi's setup:
-*
-*   - `systemPromptPrefix` → fed into `appendSystemPrompt` alongside
-*      the runtime instructor (it IS a system-prompt fragment).
-*   - `userInlineSuffix`   → appended to the `buildTaskUserPrompt`
-*      output BEFORE `session.prompt(text)`.
-*   - `skills`             → spliced into the `skillsOverride` callback's
-*      return value. pi includes them in `<available_skills>` in the
-*      system prompt; the agent fetches the body on demand via the
-*      Read tool.
-*
-* Task-context files are written into a memory-backed VM mount. pi only reads
-* `<available_skills>` metadata (name, description, location), never the skill
-* body, so we construct synthetic `Skill` objects pointing at the in-VM path
-* without ever materialising the file on the host.
-*/
-/**
-* Where in the VM we write task-context bodies — the memory-backed mount
-* declared in `vm-manager.ts`. See the comment on
-* `GUEST_TASK_CONTEXT_MOUNT` there for the full rationale (ephemeral by
-* intent + the worktree symlink interaction with Gondolin's sandbox-escape
-* protection). The agent's Gondolin Read tool accepts paths under this mount
-* via `toGuestPath` in `tool-operations.ts`.
-*/
-var SKILL_ROOT_IN_VM = `${GUEST_TASK_CONTEXT_MOUNT}/skills`;
-var INLINE_CONTEXT_ROOT_IN_VM = `${GUEST_TASK_CONTEXT_MOUNT}/context`;
-/** Bounds borrowed from pi's skill validation; conservative caps so a
-*  malformed SKILL.md doesn't bloat the system prompt. */
-var MAX_SKILL_NAME = 64;
-var MAX_SKILL_DESCRIPTION = 1024;
-/**
-* Resolve a task's `input.context[]` and inject the side effects pi
-* needs. Safe to call with an empty array — returns an inert result.
-*/
-async function injectTaskContext(args) {
-	const skills = [];
-	args.guestWorkspace;
-	const resolved = await resolveTaskContext({
-		context: args.context,
-		deliver: {
-			skill: async ({ slug, content }) => {
-				const dir = `${SKILL_ROOT_IN_VM}/${slug}`;
-				const filePath = `${dir}/SKILL.md`;
-				await args.fs.mkdir(dir, { recursive: true });
-				await args.fs.writeFile(filePath, content, { mode: 420 });
-				skills.push(buildSyntheticSkill({
-					slug,
-					content,
-					filePath,
-					dir
-				}));
-			},
-			contextFile: async ({ suggestedFileName, content }) => {
-				await args.fs.mkdir(INLINE_CONTEXT_ROOT_IN_VM, { recursive: true });
-				const filePath = `${INLINE_CONTEXT_ROOT_IN_VM}/${suggestedFileName}`;
-				await args.fs.writeFile(filePath, content, { mode: 420 });
-			}
-		}
-	});
-	return {
-		injected: resolved.injected,
-		skills,
-		systemPromptPrefix: resolved.systemPromptPrefix,
-		userInlineSuffix: resolved.userInlineSuffix
-	};
-}
-/**
-* Build a `Skill` object pi will faithfully render in
-* `<available_skills>`. We extract `name` and `description` from the
-* skill content's YAML frontmatter using pi's own `parseFrontmatter`
-* helper (proper YAML, not a regex hack) and fall back to the slug +
-* a generic description so a SKILL.md without frontmatter still
-* renders something meaningful.
-*
-* Frontmatter parsing is best-effort: a malformed YAML block is
-* optional metadata, not a reason to fail the task. We swallow parser
-* errors and fall back to the slug-derived metadata; the skill body
-* is unaffected.
-*
-* pi's `formatSkillsForPrompt` only reads `name`, `description`, and
-* `filePath` — `sourceInfo`/`baseDir` exist on the type but never
-* surface in the prompt, so a synthetic `SourceInfo` is enough.
-*/
-function buildSyntheticSkill(args) {
-	let fm = {};
-	try {
-		fm = parseFrontmatter(args.content).frontmatter;
-	} catch {}
-	return {
-		name: clip(typeof fm.name === "string" && fm.name.trim().length > 0 ? fm.name.trim() : args.slug, MAX_SKILL_NAME),
-		description: clip(typeof fm.description === "string" && fm.description.trim().length > 0 ? fm.description.trim() : `Task-injected context skill (${args.slug})`, MAX_SKILL_DESCRIPTION),
-		filePath: args.filePath,
-		baseDir: args.dir,
-		sourceInfo: createSyntheticSourceInfo(args.filePath, {
-			source: "moltnet:task-context",
-			scope: "temporary",
-			origin: "top-level",
-			baseDir: args.dir
-		}),
-		disableModelInvocation: fm["disable-model-invocation"] === true
-	};
-}
-function clip(s, max) {
-	return s.length > max ? s.slice(0, max) : s;
-}
-//#endregion
 //#region src/runtime/resolve-prior-context.ts
 /**
 * Fetch the named attempt's output and project it into the prompt's
@@ -25306,6 +25208,113 @@ async function withTimeout(promise, timeoutMs, onTimeout) {
 	}
 }
 //#endregion
+//#region src/runtime/runtime-context.ts
+/**
+* Pi-specific runtime context handling.
+*
+* `@themoltnet/agent-runtime` owns generic context semantics: merge profile
+* defaults with task context, resolve bindings, and produce prompt fragments.
+* This module owns the Pi/Gondolin boundary: validate effective context for an
+* attempt, write skill/context files into the VM, and build synthetic Pi Skill
+* metadata for injected skill bindings.
+*/
+/**
+* Where in the VM we write runtime-context bodies — the memory-backed mount
+* declared in `vm-manager.ts`. See the comment on
+* `GUEST_TASK_CONTEXT_MOUNT` there for the full rationale (ephemeral by
+* intent + the worktree symlink interaction with Gondolin's sandbox-escape
+* protection). The agent's Gondolin Read tool accepts paths under this mount
+* via `toGuestPath` in `tool-operations.ts`.
+*/
+var SKILL_ROOT_IN_VM = `${GUEST_TASK_CONTEXT_MOUNT}/skills`;
+var INLINE_CONTEXT_ROOT_IN_VM = `${GUEST_TASK_CONTEXT_MOUNT}/context`;
+/** Bounds borrowed from pi's skill validation; conservative caps so a
+*  malformed SKILL.md doesn't bloat the system prompt. */
+var MAX_SKILL_NAME = 64;
+var MAX_SKILL_DESCRIPTION = 1024;
+function resolveEffectiveRuntimeContext(args) {
+	const taskContext = args.rawTaskContext === void 0 ? [] : args.rawTaskContext;
+	if (!Check(TaskContext, taskContext)) throw new Error(`task.input.context failed TaskContext validation: ${JSON.stringify([...Errors(TaskContext, taskContext)].slice(0, 3))}`);
+	const profileContext = args.runtimeProfileContext ?? [];
+	if (!Check(TaskContext, profileContext)) throw new Error(`runtime profile context failed TaskContext validation: ${JSON.stringify([...Errors(TaskContext, profileContext)].slice(0, 3))}`);
+	return mergeRuntimeProfileContext(profileContext, taskContext);
+}
+/**
+* Resolve effective runtime context and inject the side effects Pi
+* needs. Safe to call with an empty array — returns an inert result.
+*/
+async function injectRuntimeContext(args) {
+	const skills = [];
+	args.guestWorkspace;
+	const resolved = await resolveTaskContext({
+		context: args.context,
+		deliver: {
+			skill: async ({ slug, content }) => {
+				const dir = `${SKILL_ROOT_IN_VM}/${slug}`;
+				const filePath = `${dir}/SKILL.md`;
+				await args.fs.mkdir(dir, { recursive: true });
+				await args.fs.writeFile(filePath, content, { mode: 420 });
+				skills.push(buildSyntheticSkill({
+					slug,
+					content,
+					filePath,
+					dir
+				}));
+			},
+			contextFile: async ({ suggestedFileName, content }) => {
+				await args.fs.mkdir(INLINE_CONTEXT_ROOT_IN_VM, { recursive: true });
+				const filePath = `${INLINE_CONTEXT_ROOT_IN_VM}/${suggestedFileName}`;
+				await args.fs.writeFile(filePath, content, { mode: 420 });
+			}
+		}
+	});
+	return {
+		injected: resolved.injected,
+		skills,
+		systemPromptPrefix: resolved.systemPromptPrefix,
+		userInlineSuffix: resolved.userInlineSuffix
+	};
+}
+/**
+* Build a `Skill` object pi will faithfully render in
+* `<available_skills>`. We extract `name` and `description` from the
+* skill content's YAML frontmatter using pi's own `parseFrontmatter`
+* helper (proper YAML, not a regex hack) and fall back to the slug +
+* a generic description so a SKILL.md without frontmatter still
+* renders something meaningful.
+*
+* Frontmatter parsing is best-effort: a malformed YAML block is
+* optional metadata, not a reason to fail the task. We swallow parser
+* errors and fall back to the slug-derived metadata; the skill body
+* is unaffected.
+*
+* pi's `formatSkillsForPrompt` only reads `name`, `description`, and
+* `filePath` — `sourceInfo`/`baseDir` exist on the type but never
+* surface in the prompt, so a synthetic `SourceInfo` is enough.
+*/
+function buildSyntheticSkill(args) {
+	let fm = {};
+	try {
+		fm = parseFrontmatter(args.content).frontmatter;
+	} catch {}
+	return {
+		name: clip(typeof fm.name === "string" && fm.name.trim().length > 0 ? fm.name.trim() : args.slug, MAX_SKILL_NAME),
+		description: clip(typeof fm.description === "string" && fm.description.trim().length > 0 ? fm.description.trim() : `Runtime-injected context skill (${args.slug})`, MAX_SKILL_DESCRIPTION),
+		filePath: args.filePath,
+		baseDir: args.dir,
+		sourceInfo: createSyntheticSourceInfo(args.filePath, {
+			source: "moltnet:runtime-context",
+			scope: "temporary",
+			origin: "top-level",
+			baseDir: args.dir
+		}),
+		disableModelInvocation: fm["disable-model-invocation"] === true
+	};
+}
+function clip(s, max) {
+	return s.length > max ? s.slice(0, max) : s;
+}
+//#endregion
 //#region src/runtime/subagent-tool.ts
 var SUBAGENT_SUBMIT_TOOL_NAME = "submit_subagent_output";
 var DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES = 2;
@@ -25841,6 +25850,46 @@ function resolveSubmitTools(taskType, opts = {}) {
 	};
 }
 //#endregion
+//#region src/runtime/task-event-emitter.ts
+var LOG_TRUNCATE_LIMIT = 4 * 1024;
+async function emitTaskEvent(input) {
+	try {
+		input.onTurnEvent(input.kind, summarizePayloadForLog(input.kind, input.payload));
+	} catch (err) {
+		process.stderr.write(`[emit] onTurnEvent threw for kind="${input.kind}": ${err instanceof Error ? err.message : String(err)}\n`);
+	}
+	try {
+		await input.reporter.record({
+			kind: input.kind,
+			payload: input.payload
+		});
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		input.log(`executePiTask: reporter.record() failed for task ${input.taskId} attempt ${input.attemptN} kind="${input.kind}": ${detail}`);
+	}
+}
+function summarizePayloadForLog(kind, payload) {
+	switch (kind) {
+		case "text_delta": {
+			const delta = payload.delta;
+			return { chars: typeof delta === "string" ? delta.length : 0 };
+		}
+		case "tool_call_start": return { tool: payload.tool_name };
+		case "tool_call_end": return {
+			tool: payload.tool_name,
+			is_error: payload.is_error === true,
+			...payload.is_error === true && payload.result !== void 0 ? { result: payload.result } : {}
+		};
+		case "turn_end": return { stop_reason: payload.stop_reason };
+		case "error": return {
+			phase: payload.phase,
+			message: typeof payload.message === "string" ? payload.message.slice(0, LOG_TRUNCATE_LIMIT) : payload.message
+		};
+		case "info": return Object.fromEntries(Object.entries(payload).map(([k, v]) => [k, typeof v === "string" ? v.slice(0, LOG_TRUNCATE_LIMIT) : v]));
+		default: return payload;
+	}
+}
+//#endregion
 //#region src/runtime/task-workspace.ts
 function prepareTaskWorkspace(task, requestedMountPath, executionPlan) {
 	const branch = executionPlan?.worktreeBranch ?? null;
@@ -26209,15 +26258,17 @@ async function executePiTask(claimedTask, reporter, opts) {
 		onTurnEvent = noopTurnEventHandler;
 	}
 	else onTurnEvent = opts.onTurnEvent ?? noopTurnEventHandler;
-	const emit = (kind, payload) => {
-		try {
-			onTurnEvent(kind, summarizePayloadForLog(kind, payload));
-		} catch (err) {
-			process.stderr.write(`[emit] onTurnEvent threw for kind="${kind}": ${err instanceof Error ? err.message : String(err)}\n`);
-		}
-		return reporter.record({
+	const emit = async (kind, payload) => {
+		await emitTaskEvent({
 			kind,
-			payload
+			payload,
+			onTurnEvent,
+			reporter,
+			taskId: task.id,
+			attemptN,
+			log: (message) => {
+				process.stderr.write(`${message}\n`);
+			}
 		});
 	};
 	const emitError = async (phase, message, extra = {}) => {
@@ -26321,6 +26372,21 @@ async function executePiTask(claimedTask, reporter, opts) {
 				message
 			});
 		}
+		const rawContext = task.input.context;
+		let effectiveRuntimeContext;
+		try {
+			effectiveRuntimeContext = resolveEffectiveRuntimeContext({
+				rawTaskContext: rawContext,
+				runtimeProfileContext: opts.runtimeProfileContext
+			});
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await emit("error", {
+				message,
+				phase: "context_resolution"
+			});
+			return makeFailedOutput("context_resolution_failed", message);
+		}
 		let taskPrompt;
 		try {
 			const assembled = buildTaskUserPrompt(task, {
@@ -26333,7 +26399,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 					source: executionPlan?.workspaceSeed?.source === "producer" ? "producer_copy" : executionPlan?.workspaceAttachment !== void 0 ? "producer_attachment" : void 0
 				},
 				extras: opts.promptExtras,
-				priorContext: resolvedPriorContext
+				priorContext: resolvedPriorContext,
+				effectiveRuntimeContext
 			});
 			taskPrompt = assembled.text;
 			await emit("info", {
@@ -26350,13 +26417,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 			});
 			return makeFailedOutput("prompt_build_failed", message);
 		}
-		const rawContext = task.input.context;
 		let injectedContext;
 		try {
-			const contextArray = rawContext === void 0 ? [] : rawContext;
-			if (!Check(TaskContext, contextArray)) throw new Error(`task.input.context failed TaskContext validation: ${JSON.stringify([...Errors(TaskContext, contextArray)].slice(0, 3))}`);
-			injectedContext = await injectTaskContext({
-				context: contextArray,
+			injectedContext = await injectRuntimeContext({
+				context: effectiveRuntimeContext,
 				fs: managed.vm.fs,
 				guestWorkspace: managed.guestWorkspace
 			});
@@ -26948,27 +27012,6 @@ function wireSessionAbort(cancelSignal, session) {
 * `task_messages.payload` row. Bodies above 4 KiB are replaced with a
 * `{ truncated, original_size }` marker so the JSONL/DB size stays bounded.
 */
-function summarizePayloadForLog(kind, payload) {
-	switch (kind) {
-		case "text_delta": {
-			const delta = payload.delta;
-			return { chars: typeof delta === "string" ? delta.length : 0 };
-		}
-		case "tool_call_start": return { tool: payload.tool_name };
-		case "tool_call_end": return {
-			tool: payload.tool_name,
-			is_error: payload.is_error === true,
-			...payload.is_error === true && payload.result !== void 0 ? { result: payload.result } : {}
-		};
-		case "turn_end": return { stop_reason: payload.stop_reason };
-		case "error": return {
-			phase: payload.phase,
-			message: typeof payload.message === "string" ? payload.message.slice(0, TRUNCATE_LIMIT) : payload.message
-		};
-		case "info": return Object.fromEntries(Object.entries(payload).map(([k, v]) => [k, typeof v === "string" ? v.slice(0, TRUNCATE_LIMIT) : v]));
-		default: return payload;
-	}
-}
 /**
 * Classify a `tool_execution_end` event for telemetry purposes.
 *
@@ -27565,4 +27608,4 @@ function moltnetExtension(pi) {
 	registerMoltnetReflectCommand(pi, state);
 }
 //#endregion
-export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiProviderErrorRetryUi, createPiRetryTriage, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveTaskWorktreePath, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiProviderErrorRetryUi, createPiRetryTriage, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectRuntimeContext as injectTaskContext, loadCredentials, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveTaskWorktreePath, resumeVm, toGuestPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "keywords": [
@@ -36,7 +36,7 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "typebox": "^1.2.8",
-    "@themoltnet/agent-runtime": "0.35.0",
+    "@themoltnet/agent-runtime": "0.35.1",
     "@themoltnet/sdk": "0.119.0"
   },
   "peerDependencies": {