@themoltnet/pi-extension 0.32.1 → 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
@@ -18037,7 +18037,7 @@ function createMoltNetTools(config) {
 	const searchEntries = defineTool({
 		name: "moltnet_search_entries",
 		label: "Search MoltNet Diary Entries",
-		description: "Hybrid (semantic + lexical) search over diary entries. Optional tags / excludeTags / entryTypes filters AND with the query; the taskFilter shorthand expands into task:* provenance tags so `taskFilter: { taskType: \"fulfill_brief\" }` returns only entries from fulfill_brief attempts. Filters apply server-side before ranking.",
+		description: "Hybrid (semantic + lexical) search over diary entries. Use proactively before non-trivial investigation, code changes, review, or episodic incident capture so prior decisions and recurring failures surface before you act. Do not search randomly: pass taskFilter for task/correlation-local searches and tags or entryTypes for broader prior-knowledge searches. Optional tags / excludeTags / entryTypes filters AND with the query; the taskFilter shorthand expands into task:* provenance tags so `taskFilter: { taskType: \"fulfill_brief\" }` returns only entries from fulfill_brief attempts. Filters apply server-side before ranking.",
 		parameters: Type.Object({
 			query: Type.String({ description: "Natural language search query" }),
 			limit: Type.Optional(Type.Number({ description: "Max results (default 5)" })),
@@ -18096,12 +18096,18 @@ function createMoltNetTools(config) {
 	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. During an active task, the entry is forced into the task diary and tagged with the task:* provenance namespace (task:id:<id>, task:type:<type>, task:attempt:<n>, plus task:correlation:<id> when set); an explicit diaryId mismatching the task diary is rejected. Use this tool — NOT `moltnet entry create` / `moltnet entry create-signed` via bash. The CLI path bypasses task-tag auto-injection and leaves entries invisible to taskFilter queries.",
+		description: "Create a new diary entry to record decisions, findings, incidents, or reflections. Before creating an episodic incident entry, first call moltnet_search_entries with the title/root-cause/error/watch-for terms plus taskFilter, tags, or entryTypes filters, then reference close matches instead of creating an isolated duplicate. During an active task, the entry is forced into the task diary and tagged with the task:* provenance namespace (task:id:<id>, task:type:<type>, task:attempt:<n>, plus task:correlation:<id> when set); an explicit diaryId mismatching the task diary is rejected. Use this tool — NOT `moltnet entry create` / `moltnet entry create-signed` via bash. The CLI path bypasses task-tag auto-injection and leaves entries invisible to taskFilter queries.",
 		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)" })),
+			entryType: Type.Optional(Type.Union([
+				Type.Literal("episodic"),
+				Type.Literal("semantic"),
+				Type.Literal("procedural"),
+				Type.Literal("reflection")
+			], { description: "Entry type. Use episodic for incidents, workarounds, bugs, or recurrence evidence; defaults to semantic." })),
 			diaryId: Type.Optional(Type.String({ description: "Explicit diary id. During an active task, must match the task diary or the call is rejected. Outside a task, overrides the env-derived diary." }))
 		}),
 		async execute(_id, params) {
@@ -18125,7 +18131,8 @@ function createMoltNetTools(config) {
 				title: params.title,
 				content: params.content,
 				tags: mergedTags,
-				importance: params.importance ?? 5
+				importance: params.importance ?? 5,
+				...params.entryType ? { entryType: params.entryType } : {}
 			});
 			return {
 				content: [{
@@ -18135,6 +18142,8 @@ function createMoltNetTools(config) {
 						title: entry.title,
 						createdAt: entry.createdAt,
 						diaryId: targetDiaryId,
+						entryType: entry.entryType,
+						importance: entry.importance,
 						tags: mergedTags
 					}, null, 2)
 				}],
@@ -18514,6 +18523,29 @@ function buildRuntimeInstructor(ctx) {
 		"  requires human approval and is unavailable in headless task runs;",
 		"  never use it for routine git/gh.",
 		"",
+		"## Proactive memory use",
+		"",
+		"- Before non-trivial investigation, debugging, code changes, or review,",
+		"  check the task diary for relevant prior knowledge instead of waiting",
+		"  for a human to ask. Use `moltnet_diary_tags` for cheap reconnaissance,",
+		"  `moltnet_list_entries` when tags or task provenance are known, and",
+		"  `moltnet_search_entries` for semantic similarity. Do not search",
+		"  randomly: pass `taskFilter` for task-local or correlation-local",
+		"  queries, and pass `tags` / `entryTypes` for broader prior-knowledge",
+		"  queries using known tags such as `incident`, `decision`, or",
+		"  `scope:<area>`. Broaden only after constrained searches miss.",
+		"- Before creating an `episodic` incident entry, you MUST search for",
+		"  similar incidents using the proposed title, root cause, error text,",
+		"  affected subsystem, and watch-for terms, filtered by `entryTypes:",
+		"  [\"episodic\", \"semantic\"]` and any known `scope:*` / task provenance",
+		"  tags. If a close prior match exists, do not create an isolated",
+		"  duplicate: reference the prior entry in your response or diary content,",
+		"  update/link it when the new occurrence adds material evidence, or",
+		"  create a new recurrence entry only when the recurrence itself is",
+		"  important signal.",
+		"- When you create a recurrence entry, include the prior matching entry",
+		"  id(s) in the content and explain what is new about this occurrence.",
+		"",
 		"## Diary discipline",
 		"",
 		`- During this task, every diary entry MUST land in \`${ctx.diaryId}\``,
@@ -19905,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;
+/**
+* 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 `task.input.context[]` into delivered side-effects (skills
+* 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.
@@ -19926,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
@@ -19974,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,
@@ -20114,6 +20159,22 @@ function buildFinalOutputBlock(opts) {
 	return lines.join("\n");
 }
 //#endregion
+//#region ../agent-runtime/src/prompts/proactive-memory.ts
+function buildProactiveMemoryWorkflowBlock() {
+	return [
+		"Before material work, apply the runtime instructor's proactive memory",
+		"rules instead of waiting for a human prompt. Start with constrained",
+		"diary context: inspect tags/list entries when task provenance or scope",
+		"tags are known, then use `moltnet_search_entries` with `taskFilter`,",
+		"`entryTypes`, and tags. Do not run broad unfiltered searches before",
+		"constrained searches miss.",
+		"",
+		"For incident capture, follow the runtime instructor exactly: search",
+		"for similar episodic/semantic entries first, reference close matches,",
+		"and create a recurrence entry only when the repeat is useful signal."
+	].join("\n");
+}
+//#endregion
 //#region ../agent-runtime/src/prompts/rubric-common.ts
 function renderRubricCriteriaList(rubric) {
 	return rubric.criteria.map((c, i) => `${i + 1}. **${c.id}** (weight ${c.weight}, scoring: \`${c.scoring}\`) — ${c.description}`).join("\n");
@@ -20215,6 +20276,12 @@ function buildAssessBriefUserPrompt(input, ctx) {
 			header: "Querying the producer's diary entries",
 			body: diaryQuery
 		},
+		{
+			id: "assess_brief.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "assess_brief.workspace",
 			source: "workspace",
@@ -20542,11 +20609,13 @@ function buildFreeformUserPrompt(input, ctx) {
 	const suggestedTaskType = input.suggestedTaskType ? [`The proposer suggested task type \`${input.suggestedTaskType}\`.`, "Use it as a hint, not as a contract."].join("\n") : "";
 	const workflow = [
 		"1. Clarify the real objective from the brief before acting.",
-		"2. Gather enough context to avoid guessing.",
-		"3. Complete the requested work when it is safe and bounded.",
-		"4. If the request reveals a recurring task shape, include a",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring traps relevant to the brief.",
+		"3. Gather enough context to avoid guessing.",
+		"4. Complete the requested work when it is safe and bounded.",
+		"5. If the request reveals a recurring task shape, include a",
 		"   `proposedTaskType` in the final output with a concise rationale.",
-		"5. If you changed code on a branch, include that branch in",
+		"6. If you changed code on a branch, include that branch in",
 		"   `branch` so future continuations can recover git context."
 	].join("\n");
 	const sections = [
@@ -20585,6 +20654,12 @@ function buildFreeformUserPrompt(input, ctx) {
 			header: "Workflow",
 			body: workflow
 		},
+		{
+			id: "freeform.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "freeform.verification",
 			source: "verification",
@@ -20661,13 +20736,15 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 	].join("\n") : "";
 	const workflow = [
 		ctx.workspace?.mode === "dedicated_worktree" ? `1. Use the already-provisioned dedicated worktree branch${ctx.workspace.branch ? ` (\`${ctx.workspace.branch}\`)` : ""}; do not create or switch the primary checkout.` : `1. Create a feature branch (starting prefix suggestion: \`${branchSlug}<short-slug>\`).`,
-		"2. Understand the problem — read relevant code; do not speculate.",
-		"3. Implement the change. Keep commits small and coherent.",
-		"4. Add tests if applicable.",
-		"5. For every commit, create a signed diary entry first via",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring traps relevant to the brief before changing code.",
+		"3. Understand the problem — read relevant code; do not speculate.",
+		"4. Implement the change. Keep commits small and coherent.",
+		"5. Add tests if applicable.",
+		"6. For every commit, create a signed diary entry first via",
 		"   `moltnet_create_entry` and embed its id in the commit trailer",
 		"   `MoltNet-Diary: <id>` (per the runtime instructor).",
-		"6. Push the branch and open a PR — run `git push` and `gh pr create`",
+		"7. Push the branch and open a PR — run `git push` and `gh pr create`",
 		"   IN the VM with your normal `bash` tool (use the",
 		"   `GH_TOKEN=$(moltnet github token …) gh …` form from the runtime",
 		"   instructor). Do NOT use `moltnet_host_exec` for this; it needs human",
@@ -20709,6 +20786,12 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 			header: "Workflow",
 			body: workflow
 		},
+		{
+			id: "fulfill_brief.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "fulfill_brief.verification",
 			source: "verification",
@@ -21024,13 +21107,15 @@ function buildPrReviewUserPrompt(input, ctx) {
 	const workflow = [
 		"1. Read the subject summary, resources, inspection hints, and any",
 		"   task-specific instructions before scoring.",
-		"2. Inspect the target artefact directly using the tools and resources the",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring review traps relevant to the subject.",
+		"3. Inspect the target artefact directly using the tools and resources the",
 		"   task makes available.",
-		"3. If you are in a dedicated disposable worktree and need the review target",
+		"4. If you are in a dedicated disposable worktree and need the review target",
 		"   checked out locally, do that work inside this disposable workspace only.",
-		"4. Apply the rubric strictly. This task is about complexity and",
+		"5. Apply the rubric strictly. This task is about complexity and",
 		"   reviewability, not correctness or feature desirability.",
-		"5. Perform any required outward action before emitting the final",
+		"6. Perform any required outward action before emitting the final",
 		"   structured output."
 	].join("\n");
 	const taskPromptSection = input.taskPrompt ?? "";
@@ -21087,6 +21172,12 @@ function buildPrReviewUserPrompt(input, ctx) {
 			header: "Review workflow",
 			body: workflow
 		},
+		{
+			id: "pr_review.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "pr_review.task_prompt",
 			source: "task_input",
@@ -21256,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
@@ -21278,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",
@@ -21456,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}"`);
 	}
@@ -24929,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
@@ -25228,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;
@@ -25763,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;
@@ -26131,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 = {}) => {
@@ -26243,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, {
@@ -26255,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", {
@@ -26272,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
 			});
@@ -26870,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.
 *
@@ -27487,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.32.1",
+  "version": "0.33.1",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "keywords": [
@@ -36,8 +36,8 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "typebox": "^1.2.8",
-    "@themoltnet/sdk": "0.119.0",
-    "@themoltnet/agent-runtime": "0.34.1"
+    "@themoltnet/agent-runtime": "0.35.1",
+    "@themoltnet/sdk": "0.119.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",