@oh-my-pi/pi-coding-agent 17.0.4 → 17.0.6

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

@@ -1,89 +1,104 @@
 <system-notice>
-The user's message above contains the **workflowz** keyword: drive this task as a deterministic multi-subagent workflow. Use the `task` tool {{#if taskBatch}}for batched fan-out{{else}}once per independent subagent{{/if}} — 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.
+The user's message above contains the **workflowz** keyword: drive this task as a deterministic multi-subagent workflow. Author the orchestration 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. Common shapes:
-- **Understand** — parallel readers over subsystems → structured map.
-- **Design** — independent approaches → scored synthesis.
-- **Review** — split dimensions → find per dimension → adversarially verify each finding.
-- **Research** — multi-modal sweep → deep-read the hits → synthesize.
-- **Migrate** — discover sites → transform each → verify.
+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>
 
-<task-contract>
-{{#if taskBatch}}
-Call `task` once per independent fan-out batch. Put shared background in `context`, and put each independent work item in `tasks[]`. Do not emulate batching with shell loops or eval helper APIs.
-
-`context` must carry the shared contract:
-
-    # Goal
-    What the batch accomplishes.
-    # Constraints
-    Rules, non-goals, permissions, and verification limits.
-    # Contract
-    Shared interfaces, output shape, branch/base assumptions, and coordination rules.
-
-Each task assignment must be self-contained:
-
-    # Target
-    Exact files, symbols, subsystem, or evidence surface; explicit non-goals.
-    # Change
-    What to inspect or modify, step by step, including APIs and patterns to reuse.
-    # Acceptance
-    Observable result, return packet, and local verification. Subagents skip formatters,
-    linters, and project-wide tests; the parent runs shared proof once.
-{{else}}
-Call `task` once per independent subagent. Put the full shared background and the leaf work in that call's `assignment`. Do not pass `context` or `tasks[]`: the flat task schema rejects them when batch calls are disabled.
-
-Each assignment must be self-contained:
-
-    # Target
-    Exact files, symbols, subsystem, or evidence surface; explicit non-goals.
-    # Change
-    Shared background plus what to inspect or modify, step by step, including APIs and patterns to reuse.
-    # Acceptance
-    Observable result, return packet, and local verification. Subagents skip formatters,
-    linters, and project-wide tests; the parent runs shared proof once.
-{{/if}}
+<helpers>
+State persists across eval calls, so scout in one call and fan out in the next. Every eval call has:
+
+- `agent(prompt, *, agent="task", model=None, label=None, schema=None, isolated=None, apply=None, merge=None, handle=False)` — 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` picks a discovered agent ("explore", "reviewer", …); `label` names the artifact. Shared background goes in a `local://` file referenced from each prompt, not a parameter. Subagents are told their final text IS the return value, so they hand back raw data. `agent()` blocks until the subagent finishes. Recursion follows `task.maxRecursionDepth` (default 2; a negative value disables the cap): main agent depth = 0, each `agent()` child increments depth by 1, and, when the cap is non-negative, a spawner may call `agent()` only while its current `taskDepth < cap`. Pass `isolated=True` to run the spawn in a copy-on-write worktree so parallel `agent()` calls can edit overlapping files safely — strict opt-in, mirrors the `task` tool, defaults off regardless of `task.isolation.mode`; `isolated=True` while the setting is `"none"` errors out instead of silently downgrading. With isolation, `apply=False` keeps changes in the worktree, and `merge=False` forces patch mode even when the setting is `"branch"`. Captured root patch path, branch name, nested repo patches, and apply summary reach the workflow through `handle=True` — combine it with `apply=False` (or `apply=False, schema=…`) and read `node["patch_path"]`, `node["branch_name"]`, `node["nested_patches"]`, `node["changes_applied"]`, `node["isolation_summary"]` (JS: same keys camelCased) to recover artifacts.
+- `parallel(thunks)` — run zero-arg callables concurrently through a bounded pool, preserving input order; returns once all finish. The pool is bounded by the session's `task` concurrency — don't hand-tune it; fan out as wide as the work divides. 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)` — 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. Same pool width as `parallel()`.
+- `completion(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 calls and turns for multi-phase work, reading each result before you decide the next phase.
+</helpers>
 
 <structure>
-Decompose first, then {{#if taskBatch}}batch the independent leaves{{else}}issue one independent task call per leaf in the same turn{{/if}}:
-
-{{#if taskBatch}}
-    task(
-      context: "# Goal\nReview the auth diff…\n# Constraints\nRead-only…\n# Contract\nReturn findings as severity/file/line/fix…",
-      tasks: [
-        { id: "AuthOwner", role: "Auth Storage Reviewer", assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nTrace credential selection…\n# Acceptance\nReturn confirmed findings only…" },
-        { id: "PromptOwner", role: "Prompt Contract Reviewer", assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance…\n# Acceptance\nReturn mismatches and exact prompt lines…" },
-      ]
-    )
-{{else}}
-    task(
-      role: "Auth Storage Reviewer",
-      assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nReview the auth diff. Shared contract: read-only; return findings as severity/file/line/fix.\n# Acceptance\nReturn confirmed findings only…"
-    )
-    task(
-      role: "Prompt Contract Reviewer",
-      assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance. Shared contract: read-only; return mismatches and exact prompt lines.\n# Acceptance\nReturn confirmed findings only…"
-    )
-{{/if}}
-
-{{#if taskBatch}}Prefer one wide batch over serial subagent calls when work items do not share files. If tasks overlap, name the overlap and have agents coordinate through IRC before editing.{{else}}Prefer issuing all independent task calls in one assistant turn over serial dispatch when work items do not share files. If tasks overlap, name the overlap and have agents coordinate through IRC before editing.{{/if}}
+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:
+
+**Python (`eval`, Python backend):**
+
+    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"]]
+
+**JavaScript (`eval`, JavaScript backend):**
+
+    const DIMENSIONS = [{ key: "bugs", prompt: "…" }, { key: "perf", prompt: "…" }];
+    async function reviewAndVerify(d) {
+        const found = await agent(d.prompt, {
+            label: `review:${d.key}`,
+            schema: FINDINGS_SCHEMA,
+        });
+        return await parallel(found.findings.map((f) => async () => ({
+            …f,
+            verdict: await agent(
+                `Refute if you can (default refuted when unsure): ${f.title}`,
+                { label: `verify:${f.file}`, schema: VERDICT_SCHEMA },
+            ),
+        })));
+    }
+    phase("Review");
+    const results = await parallel(DIMENSIONS.map((d) => async () => reviewAndVerify(d)));
+    const confirmed = results.flat().filter((f) => 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:
+
+**Python (`eval`, Python backend):**
+
+    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])
+
+**JavaScript (`eval`, JavaScript backend):**
+
+    phase("Find");
+    const found = await parallel(DIMENSIONS.map((d) => async () =>
+        await agent(d.prompt, { schema: FINDINGS_SCHEMA }),
+    ));
+    const findings = dedupe(found.flatMap((r) => r.findings)); // needs everything at once
+    phase("Verify");
+    const verdicts = await parallel(findings.map((f) => async () =>
+        await agent(verifyPrompt(f), { schema: VERDICT_SCHEMA }),
+    ));
+Use ordinary code between calls to flatten/map/filter; don't add a barrier just for that. Nested `parallel()` pools each cap independently, so keep total fan-out sane.
 </structure>
 
 <patterns>
-- **Adversarial verify** — dispatch skeptical reviewers with distinct targets, then keep only findings the parent can verify against source.
-- **Perspective-diverse review** — use separate correctness, security, performance, and maintainability roles instead of identical reviewers.
-- **Completeness critic** — after the first batch, dispatch one read-only critic that asks what modality, file, claim, or proof was missed.
-- **No silent caps** — if you bound coverage (top-N, no retry, sampling), state what was dropped and why before acting.
-- **Parent owns closure** — subagents return evidence; the parent reads it, resolves contradictions, runs proof, and makes the final decision.
+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** — Python: `while len(bugs) < 10:`; JavaScript: `while (bugs.length < 10) { … }`. In Python, gate an explicit budget with `budget.total` and `budget.remaining()`; in JavaScript, use `await budget.total()` and `await budget.remaining()`. `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>
-- Capture multi-phase workflow state in the visible todo system when available.
-{{#if taskBatch}}- Batch independent subagents in one `task` call.{{else}}- Dispatch independent subagents as separate `task` calls in the same turn.{{/if}}
-- Give every subagent a narrow target, explicit non-goals, and a concrete return packet.
-- After fan-out returns, read the artifacts, patch or decide, and run the shared gate.
-- Keep going until the task is closed — returned fan-out is a step, not a stopping point.
+- Decompose the surface first; capture it in `todo` 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/browser.md

@@ -6,7 +6,7 @@ Drives real Chromium tab; full puppeteer access via JS.
 - `run` scope: `page`, `browser`, `tab`, `display`, `assert`, `wait` available. `wait(fn)` polls until truthy — use instead of polling inside `tab.evaluate`.
 
 - `tab` helpers (drop to raw puppeteer `page` for anything uncovered):
-  Element handles: `tab.ref("e5")` / `tab.id(n)`. Also `aria-ref=e5` inline.
+  Element handles: `tab.ref("e5")` / `tab.id(n)` return a handle you call methods on directly — `(await tab.id(n)).click()`. Handles are NOT selectors: `tab.click`/`type`/`fill`/`waitFor*` take STRING selectors only. Snapshot refs work in any selector slot: `tab.click("e5")` ≡ `tab.click("aria-ref=e5")`.
   Simple: `tab.goto`, `tab.click`, `tab.type`, `tab.fill`, `tab.press`, `tab.scroll`, `tab.scrollIntoView`, `tab.drag`, `tab.uploadFile`, `tab.select`, `tab.screenshot`, `tab.extract`, `tab.evaluate`.
   Waits: `tab.waitFor`, `tab.waitForSelector`, `tab.waitForUrl`, `tab.waitForResponse`, `tab.waitForNavigation`.
   Snapshots: `tab.observe()` → accessibility tree; `tab.ariaSnapshot()` → ARIA YAML with `[ref=eN]`.
@@ -14,8 +14,9 @@ Drives real Chromium tab; full puppeteer access via JS.
   Gotchas:
   - `tab.fill` NEVER works for `<select>` — use `tab.select`.
   - `tab.waitForNavigation` must start BEFORE the trigger click.
-  - Navigation invalidates element ids — re-observe.
+  - Navigation and re-renders (virtualized lists, SPA updates) invalidate ids/refs — re-observe or re-snapshot, then act in the same cell.
   - Stalled actions fail fast with named error, never whole-cell timeout.
+  - Raw request interception is run-scoped: run end removes `request` handlers, disables interception, releases held requests.
 
 - `app.path` → NEVER tamper with a real desktop app (no stealth patches).
 - Selectors: CSS + puppeteer `aria/…`, `text/…`, `xpath/…`, `pierce/…`. Playwright-only pseudos (`:has-text()`, `:visible`) are REJECTED.

package/src/prompts/tools/debug.md

@@ -1,8 +1,3 @@
 Debugger access. Prefer over bash for program state, breakpoints, stepping, or thread inspection.
-
-Only one active session at a time. `program` is a target path, not a shell command. Directories need a directory-capable adapter (`dlv`).
-
-Adapters:
-- Python: `debugpy` (`pip install debugpy`)
-- Go: Delve (`go install github.com/go-delve/delve/cmd/dlv@latest`)
-- Ruby: `rdbg` (`gem install debug`)
+Only one active session at a time. `program` is a target path, not a shell command.
+Directories need a directory-capable adapter (e.g. `dlv`).

package/src/prompts/tools/github.md

@@ -1,8 +1,9 @@
-Op-based `gh` wrapper: repos, PRs, search, checkout, push, Actions watch. Read an issue/PR via `issue://<N>`/`pr://<N>`. PR diffs: `pr://<N>/diff` (file listing), `pr://<N>/diff/<i>` (file slice, 1-indexed), `pr://<N>/diff/all` (full diff).
+Op-based `gh` wrapper: repos, repository files, PRs, search, checkout, push, Actions watch. Read an issue/PR via `issue://<N>`/`pr://<N>`. PR diffs: `pr://<N>/diff` (file listing), `pr://<N>/diff/<i>` (file slice, 1-indexed), `pr://<N>/diff/all` (full diff).
 
 <instruction>
 Pick op via `op`. Beyond the field descriptions, per op:
 - `repo_view` — omit `repo` to view the current checkout.
+- `file_read` — reads `path` from `repo`; omit `repo` for the current checkout and `branch` for its default branch.
 - `pr_create` — `head` defaults to the current branch.
 - `pr_checkout` — checks PR(s) out into dedicated git worktrees, not your working tree; pass an array of `pr` to batch multiple in one call.
 - `pr_push` — requires the branch to have been checked out first via `op: pr_checkout`.
@@ -15,3 +16,7 @@ Pick op via `op`. Beyond the field descriptions, per op:
 <output>
 Concise summary per op. `run_watch` failures save full logs to a session artifact.
 </output>
+
+<critical>
+GitHub-hosted repository file? MUST use `file_read`; NEVER `curl`/`wget`.
+</critical>

package/src/prompts/tools/hub.md

@@ -3,7 +3,7 @@ Use `op: "list"` to discover peers. Address peers by exact roster ID — NEVER i
 
 # Messaging & Jobs
 
-Background jobs deliver their results automatically the moment they finish. You NEVER need to poll for output — intervene only to block, kill, or inspect.
+Background jobs auto-deliver when they finish. You NEVER need to poll; if `jobs`/`wait` observes a settled job first, that snapshot is the delivery and suppresses duplicate `async-result`.
 
 - **`send`** (with `to`): fire-and-forget, NEVER blocks. Delivery receipts (`delivered`/`failed`) immediate; `failed` → peer gone, don't retry.
   Sending wakes `idle`/`parked` peers. Answering: lead with answer, NEVER quote, set `replyTo`.
@@ -12,7 +12,9 @@ Background jobs deliver their results automatically the moment they finish. You
   - Bare `wait` watches every running job AND incoming messages. NEVER pass an array of every running ID; `ids` narrows to specific jobs, `from` to one peer (or use `await: true` on send).
 - **`inbox`**: drain queued messages without blocking.
 - **`cancel`**: kill background jobs by `ids` when they have hung, stalled, or are no longer needed. Returns immediately.
-- **`jobs`**: status snapshot of every job without waiting. Also names running subagents with no job entry — coordinate with those via `send`.
+- **`jobs`**: status snapshot of every job without waiting. A settled row consumes auto-delivery. Also names running subagents with no job entry — coordinate with those via `send`.
+- Job rows are process-local and expire roughly five minutes after settlement. Afterward, use the agent ID with `send`, `agent://<id>`, or `history://<id>`.
+- `completed` means successful yield/job exit, not artifact acceptance. Verify claimed changes.
 - NEVER use shell tools, grep, or read other sessions' files to figure out what a peer is doing. Message them directly.
 - NEVER use hub messaging for something a tool can answer (e.g., grepping codebase, running a build).
 

package/src/prompts/tools/task-async-contract.md

@@ -0,0 +1 @@
+No polling is needed. Inspecting a settled job with `hub jobs` or `hub wait` makes that snapshot its delivery, so no duplicate `async-result` follows. Job IDs live in process memory for roughly five minutes after settlement; afterward, use the agent ID with `hub send`, `agent://<id>`, or `history://<id>`. `completed` means the subagent yielded successfully, not that claimed artifacts were verified.

package/src/prompts/tools/task.md

@@ -1,7 +1,14 @@
 {{#if asyncEnabled}}{{#if batchEnabled}}Delegate work to background subagents by passing multiple items in a single `tasks[]` batch.
-Execution does not block — you receive IDs immediately; results deliver when subagents finish.{{else}}Delegate work to ONE background subagent per call.
-Execution does not block — you receive an ID immediately; the result delivers when the subagent finishes.{{/if}}{{#if hasBlockingAgents}}
+Execution does not block — you receive IDs immediately.{{else}}Delegate work to ONE background subagent per call.
+Execution does not block — you receive an ID immediately.{{/if}}{{#if hasBlockingAgents}}
 Agents marked BLOCKING run inline — results return in this call; non-blocking items in the same batch still spawn as background jobs.{{/if}}{{else}}{{#if batchEnabled}}Run subagents synchronously by passing items in a `tasks[]` batch. Execution blocks until all work finishes.{{else}}Run ONE subagent synchronously. Execution blocks until work finishes.{{/if}}{{/if}}
+{{#if asyncEnabled}}
+
+# Async Job Contract
+- Results auto-deliver. A settled `hub jobs`/`hub wait` snapshot is the delivery; no duplicate `async-result` follows.
+- Job IDs are process-local and expire roughly five minutes after settlement. Afterward, use the agent ID with `hub send`, `agent://<id>`, or `history://<id>`.
+- `completed` means successful yield/job exit, not artifact acceptance. Verify claimed changes.
+{{/if}}
 
 # Task Design
 - **Agent typing:** Pick each item's `agent` type. Read-only research MUST use `agent: "scout"` (faster model). Use default worker only when no specialist fits.

package/src/sdk.ts

@@ -50,6 +50,7 @@ import {
 	parseModelString,
 	pickDefaultAvailableModel,
 	resolveAllowedModels,
+	resolveCliModel,
 	resolveConfiguredModelPatterns,
 	resolveModelRoleValue,
 } from "./config/model-resolver";
@@ -389,6 +390,8 @@ export interface CreateAgentSessionOptions {
 	modelPatternAuthFallback?: string;
 	/** Role name used to install retry fallbacks after deferred subagent patterns resolve. */
 	modelPatternFallbackRole?: string;
+	/** Validated default retry chain to install when a deferred singleton pattern resolves. */
+	modelPatternDefaultFallbackChain?: string[];
 	/** Thinking selector. Default: from settings, else unset */
 	thinkingLevel?: ConfiguredThinkingLevel;
 	/** Models available for cycling (Ctrl+P in interactive mode) */
@@ -2066,13 +2069,35 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 		// Resolve deferred --model/subagent patterns now that extension models are
-		// registered. Expand role aliases (`@smol`) and comma chains to concrete
-		// selectors first so deferred resolution accepts everything the immediate
-		// path (resolveModelOverride → resolveModelRoleValue) accepts.
+		// registered. Use the same CLI resolver as the immediate path so bare role
+		// names, exact model names, and provider selectors keep one precedence rule.
 		if (!model && deferredModelPatterns.length > 0) {
-			const expandedModelPatterns = resolveConfiguredModelPatterns(deferredModelPatterns, settings);
 			const availableModels = modelRegistry.getAll();
 			const matchPreferences = getModelMatchPreferences(settings);
+			const expandedModelPatterns = deferredModelPatterns.flatMap(pattern =>
+				pattern.split(",").flatMap(selector => {
+					const trimmedSelector = selector.trim();
+					if (!trimmedSelector) return [];
+					const resolved = resolveCliModel({
+						cliModel: trimmedSelector,
+						modelRegistry,
+						settings,
+						preferences: matchPreferences,
+					});
+					if (resolved.configuredPatterns && resolved.configuredPatterns.length > 0) {
+						return resolved.configuredPatterns;
+					}
+					if (resolved.model) {
+						return [
+							formatModelSelectorValue(
+								resolved.selector ?? formatModelStringWithRouting(resolved.model),
+								resolved.thinkingLevel,
+							),
+						];
+					}
+					return resolveConfiguredModelPatterns([trimmedSelector], settings);
+				}),
+			);
 			for (let patternIndex = 0; patternIndex < expandedModelPatterns.length; patternIndex += 1) {
 				const pattern = expandedModelPatterns[patternIndex];
 				const primary = parseModelPattern(pattern, availableModels, matchPreferences);
@@ -2118,6 +2143,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						seenSelectors.add(fallbackSelector);
 						fallbackSelectors.push(fallbackSelector);
 					}
+					if (fallbackSelectors.length === 0) {
+						for (const selector of options.modelPatternDefaultFallbackChain ?? []) {
+							if (typeof selector !== "string" || seenSelectors.has(selector)) continue;
+							seenSelectors.add(selector);
+							fallbackSelectors.push(selector);
+						}
+					}
 					if (fallbackSelectors.length > 0) {
 						const modelRoles: Record<string, string> = {};
 						const existingRoles = settings.getModelRoles();
@@ -2698,8 +2730,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (snapcompactInline) transformed = await snapcompactInline.transform(transformed, transformModel);
 			return clampProviderContextImages(transformed, transformModel);
 		};
-		const onPayload = async (payload: unknown, _model?: Model) => {
-			return await extensionRunner.emitBeforeProviderRequest(payload);
+		const onPayload = async (payload: unknown, model?: Model) => {
+			return await extensionRunner.emitBeforeProviderRequest(payload, model);
 		};
 		const onResponse: SimpleStreamOptions["onResponse"] = async (response, model) => {
 			await extensionRunner.emitAfterProviderResponse(response, model);