@oh-my-pi/pi-coding-agent 15.7.2 → 15.7.5

package/src/modes/workflow.ts

@@ -0,0 +1,42 @@
+import workflowNotice from "../prompts/system/workflow-notice.md" with { type: "text" };
+import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
+import { keywordInProse } from "./markdown-prose";
+
+/**
+ * "workflow" keyword support.
+ *
+ * Typing the standalone word in the input editor paints it with a warm
+ * amber→green gradient ({@link highlightWorkflow}); submitting a message that
+ * mentions it appends a hidden {@link WORKFLOW_NOTICE} that steers the model to
+ * author a deterministic multi-subagent workflow in eval cells (agent/parallel/
+ * pipeline). Matching is whitespace-delimited and case-sensitive (lowercase
+ * only) — "workflow"/"workflows" trigger, but "workflowed", "Workflow", and
+ * "workflow.ts" never do.
+ */
+
+// Detection: lowercase keyword (singular or plural) flanked by whitespace or a string edge. Non-global so `.test` stays stateless.
+const WORKFLOW_WORD = /(?<!\S)workflows?(?!\S)/;
+
+/** Hidden system notice appended after a user message that mentions "workflow". */
+export const WORKFLOW_NOTICE: string = workflowNotice.trim();
+
+/**
+ * Whether `text` contains the standalone keyword "workflow"/"workflows"
+ * (lowercase, whitespace-delimited) in prose — never inside a code block, inline
+ * code span, or XML/HTML section.
+ */
+export function containsWorkflow(text: string): boolean {
+	return keywordInProse(text, WORKFLOW_WORD);
+}
+
+/**
+ * Highlight every standalone "workflow"/"workflows" in `text` for editor display
+ * with a warm amber→green gradient (hue 30..150), visually distinct from
+ * ultrathink's rainbow and orchestrate's teal→violet.
+ */
+export const highlightWorkflow: KeywordHighlighter = createGradientHighlighter({
+	probe: /workflow/,
+	highlight: /(?<!\S)workflows?(?!\S)/g,
+	stops: 14,
+	hue: t => 30 + t * 120,
+});

package/src/prompts/system/omfg-user.md

@@ -0,0 +1,51 @@
+<omfg>
+The user is frustrated about recurring agent behavior.
+Author ONE Time Traveling Stream Rule (TTSR) that would have caught the offending behavior earlier in this conversation.
+
+TTSR mechanics:
+- A rule is a markdown file with YAML frontmatter.
+- `condition` is one or more JavaScript regex patterns tested against assistant streamed output.
+- `scope` is a comma-separated allowlist. If present, only listed streams are checked.
+- `text` = assistant prose only. `thinking` = hidden reasoning summaries. `tool` = every tool's arguments.
+- `tool:<name>(<glob>)` = one tool, only when path-like args match the glob. Examples: `tool:write(*.rb)`, `tool:edit(*.ts)`.
+- Prefer file-specific tool scopes for code complaints. Ruby code generated through `write` should use `tool:write(*.rb)`, not bare `tool` or `text`.
+- Tool arguments may be serialized while streaming. Conditions for code containing quotes should tolerate JSON escaping when needed.
+- When `condition` matches within `scope`, the stream is interrupted and the markdown body is injected as correction guidance.
+- `description` is a one-line summary.
+
+Output contract:
+- Emit exactly one JSON object and nothing else.
+- JSON fields: `name`, `description`, `condition`, `scope`, `body`.
+- `name` MUST be kebab-case.
+- `description` MUST be a one-line summary.
+- `condition` MUST be a string or string array of JavaScript regex patterns.
+- `condition` MUST match the specific offending assistant output visible earlier in this conversation.
+- Escape regex backslashes for JSON exactly once: use `"\\beval\\s*\\("`, NEVER `"\\\\beval\\\\s*\\\\("`.
+- Keep `condition` precise; NEVER use broad catch-alls.
+- `scope` MUST be a string or string array.
+- Keep `scope` as narrow as the complaint allows. NEVER use `tool, text` unless the same bad behavior occurred in both tool arguments and assistant prose.
+- `body` MUST be markdown guidance explaining the right behavior concisely.
+- The caller assembles YAML frontmatter. NEVER emit markdown frontmatter or a fenced code block around the JSON.
+
+Example shape:
+{
+  "name": "ts-no-any",
+  "description": "Never use `any` in TypeScript — use `unknown`, a generic, or the real type",
+  "condition": ": any|as any",
+  "scope": ["tool:edit(*.ts)", "tool:edit(*.tsx)", "tool:write(*.ts)", "tool:write(*.tsx)"],
+  "body": "Never use `: any` or `as any`. Use `unknown`, a domain type, a generic, or a type guard."
+}
+
+Complaint:
+{{complaint}}
+
+{{#if feedback}}
+Failed attempts or requested amendments so far:
+{{feedback}}
+
+Latest candidate JSON:
+{{previousRule}}
+
+Regenerate one corrected rule. Fix the listed validation failures or user amendment; do not repeat failed scopes or conditions.
+{{/if}}
+</omfg>

package/src/prompts/system/project-prompt.md

@@ -1,4 +1,6 @@
-[PROJECT]
+PROJECT
+===================================
+
 <workstation>
 {{#list environment prefix="- " join="\n"}}{{label}}: {{value}}{{/list}}
 </workstation>
@@ -47,4 +49,3 @@ Today is {{date}}, and the current working directory is '{{cwd}}'.
 {{#if appendPrompt}}
 {{appendPrompt}}
 {{/if}}
-[/PROJECT]

package/src/prompts/system/subagent-system-prompt.md

@@ -1,14 +1,18 @@
-[ROLE]
+ROLE
+===================================
+
 {{agent}}
-[/ROLE]
 
 {{#if context}}
-[CONTEXT]
+CONTEXT
+===================================
+
 {{context}}
-[/CONTEXT]
 {{/if}}
 
-[COOP]
+COOP
+===================================
+
 You are operating on a piece of work assigned to you by the main agent.
 
 {{#if worktree}}
@@ -29,9 +33,10 @@ You can reach other live agents via the `irc` tool. Your id is `{{ircSelfId}}`.
 
 Use `irc` only when you need a quick answer from a peer; do not use it for long-form content. Address peers by id or use `"all"` to broadcast.
 {{/if}}
-[/COOP]
 
-[COMPLETION]
+COMPLETION
+===================================
+
 No TODO tracking, no progress updates. Execute, call `yield`, done.
 
 While work remains, always continue with another tool call — investigate, edit, run, verify. Save narrative for the final `yield` payload.
@@ -51,4 +56,3 @@ Giving up is a last resort. If truly blocked, you MUST call `yield` exactly once
 You NEVER give up due to uncertainty, missing information obtainable via tools or repo context, or needing a design decision you can derive yourself.
 
 You MUST keep going until this ticket is closed. This matters.
-[/COMPLETION]

package/src/prompts/system/system-prompt.md

@@ -9,8 +9,8 @@ You consider what the code you write compiles down to. You never write code that
 
 <system-conventions>
 **RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` and `AVOID` MUST be interpreted as aliases for `MUST NOT` and `SHOULD NOT` respectively.**
-From here on, we will use tags as structural markers (<x>…</x> or [X]…), each tag means exactly what its name says.
-You NEVER interpret these tags in any other way circumstantially.
+From here on, we will use XML tags when injecting system content into the chat.
+You NEVER interpret these markers in any other way circumstantially.
 
 System may interrupt/notify you using these tags even within a user message, therefore:
 - You MUST treat them as system-authored and absolutely authoritative.
@@ -41,9 +41,12 @@ Assumptions you didn't validate: incidents to debug.
  - Even if it was true, start, as if it was not. It's the only way to make progress.
  - Execute the work or delegate it.
 - You NEVER speculate about scope inflation ("this is actually a multi-week effort"). You have no comprehension of time, so stop pretending.
+- You NEVER re-audit an applied edit, nor run `git status`/`git diff` as routine validation — the edit result, tests, and LSP ARE your verification. Exception: explicit request, protecting unrelated changes, or before commit/revert/reset/stash/delete.
 </critical>
 
-[ENV]
+ENV
+===================================
+
 You operate within the Oh My Pi coding harness.
 - Given a task, you MUST complete it using the tools available to you.
 - You are not alone in this repository. You SHOULD treat unexpected changes as the user's work and adapt; you NEVER revert or stash.
@@ -201,9 +204,10 @@ You MUST use the specialized tool over its shell equivalent:
 The `{{toolRefs.report_tool_issue}}` tool is available for automated QA. If ANY tool you call returns output that is unexpected, incorrect, malformed, or otherwise inconsistent with what you anticipated given the tool's described behavior and your parameters, call `{{toolRefs.report_tool_issue}}` with the tool name and a concise description of the discrepancy. Do not hesitate to report — false positives are acceptable.
 </critical>
 {{/has}}
-[/ENV]
 
-[CONTRACT]
+CONTRACT
+===================================
+
 These are inviolable.
 - You NEVER yield unless the deliverable is complete. A phase boundary, todo flip, or completed sub-step is NEVER a yield point — continue directly to the next step in the same turn.
 - You NEVER suppress tests to make code pass.
@@ -264,4 +268,3 @@ Before declaring blocked:
 - Do not test defaults: changing the default configuration, or a string, should not break the test. Assert logical behavior, not the current state.
 - Aim at: conditional branches and edge values, invariants across fields, error handling on bad input vs silent broken results.
 </workflow>
-[/CONTRACT]

package/src/prompts/system/workflow-notice.md

@@ -0,0 +1,70 @@
+<system-notice>
+The user's message above contains the **workflow** keyword: drive this task as a deterministic multi-subagent workflow. Author the orchestration as Python in the `eval` tool and fan out subagents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before you commit), or to take on scale one context can't hold (audits, migrations, broad sweeps). This overrides any default tendency to do the whole task inline when fanning out would be more thorough.
+
+<when>
+Worth it when the task benefits from decomposition + parallel coverage, or from independent/adversarial cross-checking before you commit. For a quick lookup or single edit, just do it directly — don't spin up agents. Scout inline FIRST (list the files, scope the diff, find the call sites) to discover the work-list, then fan out over it — you don't need to know the shape before the *task*, only before the *fan-out*. Common shapes, each a well-scoped `eval` call you can chain across turns:
+- **Understand** — parallel readers over subsystems → structured map
+- **Design** — judge panel of N independent approaches → scored synthesis
+- **Review** — split into dimensions → find per dimension → adversarially verify each finding
+- **Research** — multi-modal sweep → deep-read the hits → synthesize
+- **Migrate** — discover sites → transform each → verify
+</when>
+
+<helpers>
+State persists across cells, so scout in one cell and fan out in the next. Every cell has:
+
+- `agent(prompt, *, agent_type="task", model=None, context=None, label=None, schema=None)` — run ONE subagent; returns its final text, or the validated object when `schema` (a JSON Schema dict) is given. With `schema` the subagent is forced to emit structured output that is validated for you — branch on the object, not on parsed prose. `agent_type` picks a discovered agent ("explore", "reviewer", "oracle", …); `context` is shared background; `label` names the artifact. Subagents are told their final text IS the return value, so they hand back raw data. `agent()` blocks until the subagent finishes; eval-spawned agents nest at most 3 deep.
+- `parallel(thunks, *, concurrency=4)` — run zero-arg callables concurrently through a bounded pool (default 4, max 16), preserving input order; returns once all finish. A thunk that raises propagates — wrap risky work in `try/except` inside the thunk to keep partial results. In a loop, bind each closure's value with a default arg (`lambda d=d: …`) or every thunk captures the last one.
+- `pipeline(items, *stages, concurrency=4)` — map items through `stages` left-to-right. There is a BARRIER between stages: ALL items clear stage N before stage N+1 begins. Each stage is a one-arg callable; stage 1 gets the original item, later stages get the previous result.
+- `llm(prompt, *, model="default", system=None, schema=None)` — oneshot, stateless model call (no tools, no history). Tiers: "smol", "default", "slow". Cheap classification/scoring inside a fan-out.
+- `log(message)` — emit a progress line above the status tree. `phase(title)` — start a phase; the status lines that follow group under it.
+- `budget` — `budget.total` (output-token ceiling, or `None` when none is set), `budget.spent()` (tokens spent this turn — main loop + eval subagents), `budget.remaining()` (`math.inf` when total is `None`), `budget.hard` (whether it's enforced). A ceiling is set by the user: `+Nk` in their message is advisory (you self-limit via `budget.remaining()`), `+Nk!` (or Goal Mode) is hard — `agent()` refuses to spawn once spent reaches it. Gate loops on `budget.total` first, since it's `None` when the user set no budget.
+
+Everything runs INLINE and synchronously inside the eval call — no background mode, no resume, no separate progress app. Each eval call is one well-scoped fan-out; chain several across cells and turns for multi-phase work, reading each result before you decide the next phase.
+</helpers>
+
+<structure>
+For independent per-item chains (review → verify, fetch → extract → score), wrap the WHOLE chain in one function and run it with `parallel()` — then each item flows through its own steps without waiting on the others:
+
+    DIMENSIONS = [{"key": "bugs", "prompt": "…"}, {"key": "perf", "prompt": "…"}]
+    def review_and_verify(d):
+        found = agent(d["prompt"], label=f"review:{d['key']}", schema=FINDINGS_SCHEMA)
+        return parallel([lambda f=f: {**f, "verdict": agent(
+            f"Refute if you can (default refuted when unsure): {f['title']}",
+            label=f"verify:{f['file']}", schema=VERDICT_SCHEMA)} for f in found["findings"]])
+    phase("Review")
+    results = parallel([lambda d=d: review_and_verify(d) for d in DIMENSIONS])
+    confirmed = [f for group in results for f in group if f["verdict"]["is_real"]]
+
+Reach for `pipeline()` only when a stage genuinely needs ALL of the previous stage first — dedup/merge across the whole set, early-exit on zero, or "compare against the other findings" — because its inter-stage barrier makes every item wait for the slowest peer:
+
+    phase("Find")
+    found = parallel([lambda d=d: agent(d["prompt"], schema=FINDINGS_SCHEMA) for d in DIMENSIONS])
+    findings = dedupe([f for r in found for f in r["findings"]])   # needs everything at once
+    phase("Verify")
+    verdicts = parallel([lambda f=f: agent(verify_prompt(f), schema=VERDICT_SCHEMA) for f in findings])
+
+Don't add a barrier just to flatten/map/filter — do that with plain Python between calls. Nested `parallel()` pools each cap independently, so keep total fan-out sane.
+</structure>
+
+<patterns>
+Compose the harness the task calls for:
+- **Adversarial verify** — N independent skeptics per finding, each prompted to REFUTE; keep it only if a majority survive. `votes = parallel([lambda i=i: agent(f"Refute: {claim}. refuted=true if unsure.", schema=VERDICT) for i in range(3)])`, then keep when `sum(not v["refuted"] for v in votes) ≥ 2`.
+- **Perspective-diverse verify** — give each verifier a distinct lens (correctness, security, perf, does-it-reproduce) instead of N identical refuters.
+- **Judge panel** — N attempts from different angles, scored by parallel judges; synthesize from the winner, graft the best of the rest.
+- **Loop-until-dry** — for unknown-size discovery, keep spawning finders until K consecutive rounds surface nothing new; dedup against everything SEEN, not just what was confirmed, or it never converges.
+- **Multi-modal sweep** — parallel finders each searching a different way (by-container, by-content, by-entity, by-time), each blind to the others.
+- **Completeness critic** — a final agent that asks "what's missing — modality not run, claim unverified, file unread?"; its answer is the next round.
+- **Budget/count loops** — `while len(bugs) < 10:` to hit a target, or `while budget.total and budget.remaining() > 50_000:` to scale depth to the turn budget; `log()` each round.
+- **No silent caps** — if you bound coverage (top-N, no-retry, sampling), `log()` what you dropped; silent truncation reads as "covered everything" when it didn't.
+
+Scale to the ask: "find any bugs" → a few finders, single-vote verify. "thoroughly audit / be comprehensive" → larger finder pool, 3–5-vote adversarial pass, a synthesis stage.
+</patterns>
+
+<execution>
+- Decompose the surface first; capture it in `todo_write` when it spans phases.
+- Prefer `schema=` for any agent whose output you branch on.
+- After a fan-out returns, YOU own correctness: read the artifacts, run the gate, verify before acting. Subagents do the legwork; they don't get the last word.
+- Keep going until the task is closed — a returned fan-out is a step, not a stopping point.
+</execution>
+</system-notice>

package/src/prompts/tools/eval.md

@@ -8,7 +8,7 @@ Cell fields:
 - `language` — {{#if py}}`"py"` for the IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`"js"` for the persistent JavaScript VM{{/if}}.
 - `code` — cell body, verbatim. Newlines, quotes, and indentation are JSON-encoded; no fences, no headers.
 - `title` (optional) — short label shown in the transcript (e.g. `"imports"`, `"load config"`).
-- `timeout` (optional) — per-cell timeout in seconds (1-600). Default 30.
+- `timeout` (optional) — per-cell **inactivity** budget in seconds (1-600). Default 30. The cell is interrupted only after this long with no progress, and every status event (`agent()` updates, `log()`/`phase()`, tool activity) resets the clock — so a long `agent()`/`parallel()` fanout that keeps reporting progress is not killed. Raw `print`/stdout does not reset it; raise `timeout` for a cell that runs long without emitting status.
 - `reset` (optional) — wipe this cell's language kernel before running.{{#ifAll py js}} Reset is per-language: a `py` cell's reset does not touch the JavaScript VM and vice versa.{{/ifAll}}
 
 **Work incrementally:**
@@ -46,6 +46,18 @@ tool.<name>(args) → unknown
     Invoke any session tool by name. `args` is the tool's parameter object.
 llm(prompt, model?="default", system?=None, schema?=None) → str | dict
     Oneshot, stateless LLM call (no history, no tools). `model` picks a tier: "smol" (fast), "default" (this session's model), "slow" (most capable). Pass `system` for a system prompt. Pass a JSON-Schema `schema` to force structured output and get the parsed object back; otherwise returns the completion text.
+agent(prompt, agent_type?="task", model?=None, context?=None, label?=None, schema?=None) → str | dict
+    Run a subagent and return its final output. Defaults to the bundled "task" agent; pass `agent_type`/`agentType` for another discovered agent. Pass a JSON-Schema `schema` to force structured output and get the parsed object back.
+parallel(thunks, concurrency?=4) → list
+    Run thunks (callables) through a bounded pool (default 4, max 16), preserving input order. Barrier: returns once all finish; a thunk that throws propagates.
+pipeline(items, ...stages, concurrency?=4) → list
+    Map each item through stages left-to-right; a barrier runs between stages (every item clears stage N before stage N+1). Each stage is a one-arg callable: stage 1 gets the original item, later stages get the previous result.
+log(message) → None
+    Emit a progress line above the status tree.
+phase(title) → None
+    Start a phase; the status lines that follow group under it.
+budget → per-turn token budget
+    {{#if py}}`budget.total` (ceiling or None), `budget.spent()` (output tokens this turn), `budget.remaining()` (math.inf when no ceiling), `budget.hard` (bool).{{/if}}{{#if js}}`await budget.total()` (ceiling or null), `await budget.spent()`, `await budget.remaining()` (Infinity when no ceiling), `await budget.hard()`.{{/if}} A ceiling is set by a `+Nk` message directive (advisory) or `+Nk!`/Goal Mode (hard — `agent()` refuses to spawn past it); otherwise total is None/null and spend is still tracked across the turn (main loop + eval subagents).
 ```
 </prelude>
 

package/src/prompts/tools/memory-edit.md

@@ -1,4 +1,4 @@
-Edit Mnemosyne long-term memories by id.
+Edit Mnemopi long-term memories by id.
 
 Use only with ids returned by the `recall` tool. Operations:
 - `update`: replace content and/or importance for a working memory.

package/src/sdk.ts

@@ -88,7 +88,7 @@ import { LocalProtocolHandler, type LocalProtocolOptions } from "./internal-urls
 import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "./lsp/startup-events";
 import { discoverAndLoadMCPTools, MCPManager, type MCPToolsLoadResult } from "./mcp";
 import { resolveMemoryBackend } from "./memory-backend";
-import { getMnemosyneSessionState, type MnemosyneSessionState } from "./mnemosyne/state";
+import { getMnemopiSessionState, type MnemopiSessionState } from "./mnemopi/state";
 import asyncResultTemplate from "./prompts/tools/async-result.md" with { type: "text" };
 import { AgentRegistry, MAIN_AGENT_ID } from "./registry/agent-registry";
 import {
@@ -321,8 +321,8 @@ export interface CreateAgentSessionOptions {
 	taskDepth?: number;
 	/** Parent Hindsight state to alias for subagent memory tools. */
 	parentHindsightSessionState?: HindsightSessionState;
-	/** Parent Mnemosyne state to alias for subagent memory tools. */
-	parentMnemosyneSessionState?: MnemosyneSessionState;
+	/** Parent Mnemopi state to alias for subagent memory tools. */
+	parentMnemopiSessionState?: MnemopiSessionState;
 	/** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
 	agentId?: string;
 	/** Display name for the agent in IRC. Default: "main" or "sub". */
@@ -464,6 +464,44 @@ export async function discoverExtensions(cwd?: string): Promise<LoadExtensionsRe
 	return discoverAndLoadExtensions([], resolvedCwd);
 }
 
+/**
+ * Load the discovered/configured extensions for a session — everything {@link
+ * createAgentSession} would load except the inline factory extensions it appends
+ * itself. Extracted so the CLI can resolve extension-registered flags (and thus
+ * classify `@file` arguments extension-aware) *before* a session — and its
+ * terminal breadcrumb — is created, then hand the result back through
+ * {@link CreateAgentSessionOptions.preloadedExtensions} so the work is not
+ * repeated. Keep this the single source of the discovery branch logic.
+ */
+export async function loadSessionExtensions(
+	options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">,
+	cwd: string,
+	settings: Settings,
+	eventBus: EventBus,
+): Promise<LoadExtensionsResult> {
+	let result: LoadExtensionsResult;
+	if (options.disableExtensionDiscovery) {
+		const configuredPaths = options.additionalExtensionPaths ?? [];
+		result = await logger.time("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
+	} else {
+		// Merge CLI extension paths with settings extension paths.
+		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
+		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
+		result = await logger.time(
+			"discoverAndLoadExtensions",
+			discoverAndLoadExtensions,
+			configuredPaths,
+			cwd,
+			eventBus,
+			disabledExtensionIds,
+		);
+	}
+	for (const { path, error } of result.errors) {
+		logger.error("Failed to load extension", { path, error });
+	}
+	return result;
+}
+
 /**
  * Discover skills from cwd and agentDir.
  */
@@ -1193,7 +1231,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				session ? session.trackEvalExecution(execution, abortController) : execution,
 			getSessionId: () => sessionManager.getSessionId?.() ?? null,
 			getHindsightSessionState: () => session?.getHindsightSessionState(),
-			getMnemosyneSessionState: () => getMnemosyneSessionState(session),
+			getMnemopiSessionState: () => getMnemopiSessionState(session),
 			getAgentId: () => resolvedAgentId,
 			getToolByName: name => session?.getToolByName(name),
 			agentRegistry,
@@ -1203,6 +1241,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getPlanModeState: () => session?.getPlanModeState(),
 			getGoalModeState: () => session?.getGoalModeState(),
 			getGoalRuntime: () => session?.goalRuntime,
+			getUsageStatistics: () => sessionManager.getUsageStatistics(),
+			getTurnBudget: () => sessionManager.getTurnBudget(),
+			recordEvalSubagentUsage: output => sessionManager.recordEvalSubagentOutput(output),
 			getClientBridge: () => session?.clientBridge,
 			getCompactContext: () => session.formatCompactContext(),
 			getTodoPhases: () => session.getTodoPhases(),
@@ -1262,10 +1303,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			setActiveRules([...rulebookRules, ...alwaysApplyRules]);
 			if (asyncJobManager) AsyncJobManager.setInstance(asyncJobManager);
 		}
+		const localProtocolOptions = options.localProtocolOptions ?? {
+			getArtifactsDir,
+			getSessionId: () => sessionManager.getSessionId?.() ?? null,
+		};
 		if (options.localProtocolOptions) {
 			LocalProtocolHandler.setOverride(options.localProtocolOptions);
 		}
 		toolSession.getArtifactsDir = getArtifactsDir;
+		toolSession.localProtocolOptions = localProtocolOptions;
 		toolSession.agentOutputManager = new AgentOutputManager(
 			getArtifactsDir,
 			options.parentTaskPrefix ? { parentPrefix: options.parentTaskPrefix } : undefined,
@@ -1276,6 +1322,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 		// Discover MCP tools from .mcp.json files
 		let mcpManager: MCPManager | undefined = options.mcpManager;
+		toolSession.mcpManager = mcpManager;
 		const enableMCP = options.enableMCP ?? true;
 		const customTools: CustomTool[] = [];
 		if (enableMCP && !mcpManager) {
@@ -1294,6 +1341,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				authStorage,
 			});
 			mcpManager = mcpResult.manager;
+			toolSession.mcpManager = mcpManager;
 
 			if (settings.get("mcp.notifications")) {
 				mcpManager.setNotificationsEnabled(true);
@@ -1357,32 +1405,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			inlineExtensions.push(createCustomToolsExtension(customTools));
 		}
 
-		// Load extensions (discovers from standard locations + configured paths)
-		let extensionsResult: LoadExtensionsResult;
-		if (options.disableExtensionDiscovery) {
-			const configuredPaths = options.additionalExtensionPaths ?? [];
-			extensionsResult = await logger.time("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
-			for (const { path, error } of extensionsResult.errors) {
-				logger.error("Failed to load extension", { path, error });
-			}
-		} else if (options.preloadedExtensions) {
-			extensionsResult = options.preloadedExtensions;
-		} else {
-			// Merge CLI extension paths with settings extension paths
-			const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
-			const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
-			extensionsResult = await logger.time(
-				"discoverAndLoadExtensions",
-				discoverAndLoadExtensions,
-				configuredPaths,
-				cwd,
-				eventBus,
-				disabledExtensionIds,
-			);
-			for (const { path, error } of extensionsResult.errors) {
-				logger.error("Failed to load extension", { path, error });
-			}
-		}
+		// Load extensions. A preloaded result (e.g. resolved by the CLI before
+		// session creation so it can classify `@file` args extension-aware without
+		// a session/breadcrumb existing yet) is reused as-is; otherwise discover now
+		// through the shared helper. Preloaded wins over `disableExtensionDiscovery`
+		// because the preloaded result already reflects that choice — re-running the
+		// loader here would double-load.
+		const extensionsResult: LoadExtensionsResult =
+			options.preloadedExtensions ?? (await loadSessionExtensions(options, cwd, settings, eventBus));
 
 		// Load inline extensions from factories
 		if (inlineExtensions.length > 0) {
@@ -1960,8 +1990,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				sessionManager.appendModelChange(`${model.provider}/${model.id}`);
 			}
 			if (!autoThinking) {
-				// `auto` is never written to the session log; resume reads it from the
-				// `defaultThinkingLevel` setting instead, keeping `hasThinkingEntry` false.
+				// Do not write the `auto` selector before the first turn resolves; auto
+				// classification persists its concrete effort once a real user turn runs.
 				sessionManager.appendThinkingLevelChange(effectiveThinkingLevel);
 			}
 			if (initialServiceTier) {
@@ -2132,7 +2162,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					agentDir,
 					taskDepth,
 					parentHindsightSessionState: options.parentHindsightSessionState,
-					parentMnemosyneSessionState: options.parentMnemosyneSessionState,
+					parentMnemopiSessionState: options.parentMnemopiSessionState,
 				}),
 			),
 		);