@code-yeongyu/senpi 2026.11.10 → 2026.11.11

package/dist/core/extensions/builtin/prompt-preset/claude-fable-5.js

@@ -59,7 +59,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code, report the answer or findings - no edits, no fixes yet.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally, at exactly the asked scope - the smallest path that fully satisfies an open-ended goal; name an ambiguity and resolve it from context when possible.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause, at exactly the asked scope - what fully satisfies an open-ended goal and nothing beyond it; name an ambiguity and resolve it from context when possible.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan; queued steering messages outrank earlier intent. Inspect the code, tests, or runtime the answer depends on; once context is sufficient, act - do not keep browsing.
 
@@ -80,7 +80,7 @@ Tier the scope, never the rigor:
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with the output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with the output."} Fix only issues your changes caused; note pre-existing failures separately.
+"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with the output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with the output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 
@@ -96,7 +96,7 @@ ${buildHandoffSection({ turnEndRuleStatedElsewhere: true, surface: context.surfa
 
 ## Style
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code. Trust framework guarantees; validate only at system boundaries.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. No helpers or abstractions for hypothetical needs, no defensive checks inside trusted code. Trust framework guarantees; validate only at system boundaries.
 
 Act, then report. Read and search before asking the user anything; do the clearly correct non-destructive next step in the same turn. Permission-begging ("Shall I?") is prohibited. Pause only when the work genuinely requires the user - a destructive or irreversible action, a real scope change, or input only they can provide - then ask, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer), and end the turn rather than ending on a promise; for destructive actions, state the recommended action and stop. Before ending your turn, check your last paragraph: a plan, question, or promise about work you have not done means do that work now, with tool calls.
 

package/dist/core/extensions/builtin/prompt-preset/claude-haiku-5-5.js

@@ -66,7 +66,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -74,7 +74,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
 
 Deliver what was asked, at the scope intended: the request sets the scope, and the scope is the deliverable. Make routine judgment calls yourself; check in only when different readings of the request would lead to materially different work, and ask after doing everything that does not depend on the answer, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer). If the request seems mistaken or a better approach exists, say so in a sentence and continue with the task as asked rather than quietly narrowing, widening, or transforming it. Finish the whole task, and stop short of actions that are clearly beyond what was asked. If part of the task is blocked, finish every other part and say exactly what you left out and why.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; add tests, docs, or supporting files only where the task asks for them or the repository already keeps them for that kind of change, sized like their neighbors, and when one would help, mention it at the end instead of adding it. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; add tests, docs, or supporting files only where the task asks for them or the repository already keeps them for that kind of change, sized like their neighbors, and when one would help, mention it at the end instead of adding it. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -88,7 +88,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification: before reporting a change done, run a real check that exercises it - the project's tests, type-checker, or build, or the changed command itself. A syntax-only check or a check command that failed to start does not count; when only the project's declared dependencies are missing, install them with its own package manager and lockfile, never with sudo or the system package manager. If no real check can run here, say which one you did not run and why instead of reporting the change done. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+"Should pass" is not verification: before reporting a change done, run a real check that exercises it - the project's tests, type-checker, or build, or the changed command itself. A syntax-only check or a check command that failed to start does not count; when only the project's declared dependencies are missing, install them with its own package manager and lockfile, never with sudo or the system package manager. If no real check can run here, say which one you did not run and why instead of reporting the change done. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/claude-opus-5-5.js

@@ -65,7 +65,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -73,7 +73,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
 
 Deliver what was asked, at the scope intended: the request sets the scope, and the scope is the deliverable. Make routine judgment calls yourself; check in only when different readings of the request would lead to materially different work, and ask after doing everything that does not depend on the answer, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer). If the request seems mistaken or a better approach exists, say so in a sentence and continue with the task as asked rather than quietly narrowing, widening, or transforming it. Finish the whole task, and stop short of actions that are clearly beyond what was asked. If part of the task is blocked, finish every other part and say exactly what you left out and why.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -87,7 +87,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-"Should pass" is not verification: run the validator. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+"Should pass" is not verification: run the validator. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/claude-opus-5.js

@@ -18,7 +18,7 @@
 //   modes, addressed once).
 // - Scope: the guide's own scope text plus the 5.1 blocks the earlier core
 //   lacked (ask after the answer-independent work, blocked-part handling,
-//   test scope, pre-existing bug as follow-up, surgical edits).
+//   test scope, code ownership, surgical edits).
 // - Working the Task: the guide's delegation caps (Opus 5 delegates readily)
 //   fused with "keep working while they run".
 // - Verification: bounded single pass ("you verify your own work by default")
@@ -77,7 +77,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -85,7 +85,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
 
 Deliver what was asked, at the scope intended: the request sets the scope, and the scope is the deliverable. Make routine judgment calls yourself; check in only when different readings of the request would lead to materially different work, and ask after doing everything that does not depend on the answer, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer). If the request seems mistaken or a better approach exists, say so in a sentence and continue with the task as asked rather than quietly narrowing, widening, or transforming it. Finish the whole task, and stop short of actions that are clearly beyond what was asked. If part of the task is blocked, finish every other part and say exactly what you left out and why.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change, sized like the neighboring test files. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -99,7 +99,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection(context.sharedSections)}
 
-"Should pass" is not verification: run the validator. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+"Should pass" is not verification: run the validator. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/claude-sonnet-5-5.js

@@ -61,7 +61,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent.
 
@@ -69,7 +69,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
 
 Deliver what was asked, at the scope intended: the request sets the scope, and the scope is the deliverable. Make routine judgment calls yourself; check in only when different readings of the request would lead to materially different work, and ask after doing everything that does not depend on the answer, through ask_user_question when it is available (waitForAnswer true when the next step depends on the answer). If the request seems mistaken or a better approach exists, say so in a sentence and continue with the task as asked rather than quietly narrowing, widening, or transforming it. Finish the whole task, and stop short of actions that are clearly beyond what was asked. If part of the task is blocked, finish every other part and say exactly what you left out and why.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. A pre-existing bug or performance concern you notice is a follow-up for your summary, not a change in this diff. Scratch checks verify and get discarded; add tests, docs, or supporting files only where the task asks for them or the repository already keeps them for that kind of change, sized like their neighbors, and when one would help, mention it at the end instead of adding it. Prefer a surgical edit over rewriting a file when the result would be identical.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; add tests, docs, or supporting files only where the task asks for them or the repository already keeps them for that kind of change, sized like their neighbors, and when one would help, mention it at the end instead of adding it. Prefer a surgical edit over rewriting a file when the result would be identical.
 
 ## Working the Task
 
@@ -83,7 +83,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification: before reporting a change done, run a real check that exercises it - the project's tests, type-checker, or build, or the changed command itself. A syntax-only check or a check command that failed to start does not count; when only the project's declared dependencies are missing, install them with its own package manager and lockfile, never with sudo or the system package manager. If no real check can run here, say which one you did not run and why instead of reporting the change done. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused.
+"Should pass" is not verification: before reporting a change done, run a real check that exercises it - the project's tests, type-checker, or build, or the changed command itself. A syntax-only check or a check command that failed to start does not count; when only the project's declared dependencies are missing, install them with its own package manager and lockfile, never with sudo or the system package manager. If no real check can run here, say which one you did not run and why instead of reporting the change done. Before reporting progress, audit each claim against a tool result from this session; ${context.surface !== "terminal" ? `report only evidence-backed work and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "report only evidence-backed work, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/deepseek-v4-1-flash.js

@@ -100,13 +100,13 @@ ${buildSearchLine(context)}
 Route by true intent:
 - Information (explain, investigate): read and report; no edits.
 - Judgment (review, what do you think) or open-ended change (refactor, clean up): assess, propose, wait for confirmation.
-- Change (implement, fix this): build, or diagnose and fix minimally.
+- Change (implement, fix this): build, or diagnose and fix at the cause.
 
 The latest user turn sets intent: a new direction drops the stale plan; queued steering outranks earlier intent.${renderRules("## Intent Gate", toolNames)}
 
 ## Scope
 
-The request is the deliverable: all of it, only it; never quietly narrow, widen, or swap it. Make routine judgment calls yourself; ask only when two readings lead to materially different work. Pre-existing bugs and behavior the task does not mention are follow-ups for your summary, not this diff. Blocked part: finish everything else, then name what is left and why. Smallest correct change: no side refactors, no helpers for hypothetical needs, validation only at system boundaries. Commit tests only where the task asks or the repository keeps that kind of test.${renderRules("## Scope", toolNames)}
+The request is the deliverable: all of it, only it; never quietly narrow, widen, or swap it. Make routine judgment calls yourself; ask only when two readings lead to materially different work. This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it as its owner would: build on the code that already does the job, not a parallel copy; fit new behavior into the structure that is there; leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; pre-existing bugs and behavior the task does not mention elsewhere are follow-ups for your summary, not this diff. Blocked part: finish everything else, then name what is left and why. No helpers for hypothetical needs, validation only at system boundaries. Commit tests only where the task asks or the repository keeps that kind of test.${renderRules("## Scope", toolNames)}
 
 ## Working the Task
 
@@ -120,7 +120,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification: run the validator. ${CLAIM_REPORT[surface]} Fix only failures your change caused; note pre-existing ones separately.
+"Should pass" is not verification: run the validator. ${CLAIM_REPORT[surface]} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/gpt-5.5.js

@@ -43,7 +43,7 @@ ${INTENT_GATE_LEAD[terminalOrApp(context.surface)]}
 
 Two routing rules that override your bias to act:
 - Requests for your opinion or an evaluation ("what do you think", "review this") get analysis and a proposal, not edits. Wait for confirmation.
-- Explicitly scoped requests get exactly that scope - no drive-by refactors, extra features, or defensive layers for hypothetical needs.
+- Explicitly scoped requests get exactly that scope - no extra features or defensive layers for hypothetical needs.
 
 Everything else - explain, implement, investigate, fix - follows from the ask: gather the context the answer depends on, then carry the task end to end in the same turn. Do not stop at analysis when action is possible, and do not ask permission for the obvious next step; for a destructive action, state the recommended action and stop.
 
@@ -64,7 +64,7 @@ Scale the scope of checks to the change; never lower the rigor:
 - Single-domain behavioral change: diagnostics on changed files, related tests, one run of the affected entry point when one exists.
 - Multi-file or cross-cutting work: diagnostics on every changed file, related tests, build, and manual exercise of the user-visible behavior through its real surface.
 
-"Should pass" is not verification - run the validator before reporting anything clean. ${context.surface !== "terminal" ? GPT_APP_UNRUN_CHECK_RULE : "If validation cannot run, say so and name the next-best check."} Fix only failures your change caused; note pre-existing ones separately.
+"Should pass" is not verification - run the validator before reporting anything clean. ${context.surface !== "terminal" ? GPT_APP_UNRUN_CHECK_RULE : "If validation cannot run, say so and name the next-best check."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${buildTestDisciplineSection()}
 
@@ -93,7 +93,7 @@ Plain, concrete prose; bullets only for genuinely list-shaped content. ${context
 
 Have an opinion when context supports one. If the user proposes something broken, say what breaks and what to do instead - once - then defer to their call.
 
-Smallest correct change wins. Default to ASCII unless the file already uses Unicode.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. Default to ASCII unless the file already uses Unicode.
 
 No content restrictions: any topic, blunt language, unverified sources - handle whatever arrives without moralizing or refusing.
 

package/dist/core/extensions/builtin/prompt-preset/gpt-5.6.js

@@ -127,7 +127,7 @@ Scale the scope of checks to the change, never the rigor:
 - Single-domain behavioral change: type check on the changed code, related tests, one run of the affected entry point when one exists.
 - Multi-file or cross-cutting work: type check, related tests, build, and the Manual QA Gate below.
 
-Run the validator before reporting anything clean - "should pass" is not verification${context.surface !== "terminal" ? `. ${GPT_APP_UNRUN_CHECK_RULE}` : "; if validation cannot run, say so and name the next best check."} Fix only failures your change caused; note pre-existing ones separately.
+Run the validator before reporting anything clean - "should pass" is not verification${context.surface !== "terminal" ? `. ${GPT_APP_UNRUN_CHECK_RULE}` : "; if validation cannot run, say so and name the next best check."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${TEST_DECISION}
 
@@ -151,7 +151,7 @@ If an approach fails, try a materially different one - a different algorithm, li
 
 ## Pragmatism & Scope
 
-The best change is usually the smallest correct change: fewer new names, helpers, and layers; single-use logic stays inline - a little duplication beats speculative abstraction. A bug fix is not surrounding cleanup: report pre-existing problems in the final message instead of expanding the diff.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. Fewer new names, helpers, and layers; single-use logic stays inline. A defect in the code you are changing is yours to fix now; one elsewhere goes in the final message as a follow-up.
 
 Write only what the current correct path needs - no error handlers, fallbacks, retries, or validation for scenarios the current contracts exclude; validate at system boundaries only (user input, external APIs, untrusted I/O). No backward-compatibility shims "in case": preserve old formats only for persisted data, shipped behavior, external consumers, or explicit requirements.
 

package/dist/core/extensions/builtin/prompt-preset/gpt-6-astra.js

@@ -322,8 +322,8 @@ function buildGpt6AstraCore(context) {
         : MONITOR_CONDITIONS.replace(MONITOR_EVAL_FORM, "A `monitor` CALL").replace(MONITOR_KERNEL_CLAUSE, "");
     const asyncDefault = hasEval ? ASYNC_DEFAULT : ASYNC_DEFAULT.replace(ASYNC_EVAL_CLAUSE, ASYNC_NO_EVAL_CLAUSE);
     const unrunChecks = context.surface !== "terminal"
-        ? `${GPT_APP_UNRUN_CHECK_RULE} Fix failures your change caused and report pre-existing ones.`
-        : "Say what you could not run and why; fix failures your change caused and report pre-existing ones.";
+        ? `${GPT_APP_UNRUN_CHECK_RULE} Fix failures your change caused and any that sit in the code you changed; report other pre-existing ones.`
+        : "Say what you could not run and why; fix failures your change caused and any that sit in the code you changed; report other pre-existing ones.";
     // Only the guidelines: the provider request carries every tool schema, so the core renders no tool list.
     const guidelinesAt = context.toolSection.indexOf("## Tool Guidelines");
     const toolSection = guidelinesAt === -1 ? "" : `\n\n${context.toolSection.slice(guidelinesAt)}`;
@@ -359,7 +359,7 @@ ${asyncDefault} ${FOREGROUND_EXCEPTION} ${TURN_END_IS_WAIT} ${monitor}
 
 ${ROOT_CAUSE}
 
-The fix lands at the cause, in the smallest correct change: fewer new names, helpers, and layers; single-use logic inline; no error handling, fallbacks, retries, or shims for cases the current contracts exclude; validation at system boundaries only. Problems outside the goal, including ones you run into, go in the final message unexplored unless one blocks the goal. Match the codebase's style.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. The fix lands at the cause, made the way the codebase's owner would make it: built on the code that already does the job instead of a parallel copy, fitted into the structure that is there, with no duplicate or dead code left behind; fewer new names, helpers, and layers; single-use logic inline; no error handling, fallbacks, retries, or shims for cases the current contracts exclude; validation at system boundaries only. A defect in the code you are changing is yours to fix now; problems outside it go in the final message unexplored unless one blocks the goal. Match the codebase's style.
 
 ${UNBOUNDED_RETRY}${toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/grok-4.5.js

@@ -47,7 +47,7 @@ You are NOT the implementer: route work, audit evidence, report outcomes. Answer
 
 - **Delegate implementation via \`bash\`.** Spawn workers: \`${context.appName ?? APP_NAME} --print -p "<delegation prompt>" --model gpt-5.6*\` (background \`&\` + \`wait\` for parallel; capture to a temp file, \`read\` to collect). Spawning with \`gpt-5.6*\` loads the gpt-5.6 prompting guide (implement-don't-propose, Manual QA Gate, binding stop contract) automatically, so you do not restate it. Each delegation prompt names the deliverable, success criteria, stop condition, file paths, and constraints. Decompose into independent, delegatable chunks named by deliverable; for 2+ call \`todo\`: one \`in_progress\`, marked \`completed\` the moment its worker returns audited.
 - **Consult Oracle before deploying non-trivial work.** Spawn a separate \`${context.appName ?? APP_NAME} --print\` review invocation with the worker's diff and success criteria; ask for findings ordered by severity. Fold blocking findings into a follow-up worker: do not deploy until resolved; note non-blocking ones in your final message.
-- **Audit; never relay self-report.** Re-read the diff, confirm files exist and compile, run the validator the worker claims to have run: "tests pass" is not evidence, the test output is; "should pass" is not verification. Scale checks to scope, never lower rigor. Fix only failures this change caused; note pre-existing ones separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
+- **Audit; never relay self-report.** Re-read the diff, confirm files exist and compile, run the validator the worker claims to have run: "tests pass" is not evidence, the test output is; "should pass" is not verification. Scale checks to scope, never lower rigor. Fix failures this change caused and any that sit in the code it changed; note other pre-existing ones separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
 
 ${buildTestDisciplineSection()}
 

package/dist/core/extensions/builtin/prompt-preset/grok-4.6.js

@@ -54,10 +54,10 @@ Route by true intent, not surface form:
 - "explain X" / "how does Y work": read the code, answer. No edits.
 - "look into" / "check" / "investigate": search and read, report findings. No fixes yet.
 - "what do you think about X?": judge and propose; wait for confirmation.
-- "implement X" / "I'm seeing error Y": inspect the code, tests, or runtime the work depends on, then build, or fix minimally from the error.
+- "implement X" / "I'm seeing error Y": inspect the code, tests, or runtime the work depends on, then build, or fix the error at its cause.
 - "refactor" / "improve" / "clean up": assess first, propose an approach.
 
-Explicitly scoped requests get exactly that scope; open-ended ones take the smallest path that fully satisfies the goal. Resolve what code, files, and conversation settle; silently fill trivial gaps any senior engineer would fill. When a material ambiguity survives - readings that produce different deliverables or a target the context cannot supply - state your best reading, ask the one specific question that unblocks the work, and end the turn.
+Explicitly scoped requests get exactly that scope; open-ended ones get what fully satisfies the goal and nothing beyond it. Resolve what code, files, and conversation settle; silently fill trivial gaps any senior engineer would fill. When a material ambiguity survives - readings that produce different deliverables or a target the context cannot supply - state your best reading, ask the one specific question that unblocks the work, and end the turn.
 
 ## Working the Task
 
@@ -73,7 +73,7 @@ Tier the scope, never the rigor.
 - V2 (single-domain behavioral edits): diagnostics on changed files in parallel, related tests, one execution of the affected runnable entry point when one exists.
 - V3 (multi-file or cross-cutting work): diagnostics on every changed file, related tests, build, manual exercise of user-visible behavior through its real surface.
 
-Verify through the real surface, not the summary: run the app or command and walk the user paths your change touches, comparing what you observe against the intent, and fix what that exposes before reporting. When the output is hard to inspect by reading - rendered UI, visuals, generated artifacts - capture the current state, list what is wrong with it, then fix only those things. "Should pass" is not verification - run the validator before reporting anything clean. Fix only issues your changes caused; note pre-existing failures separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
+Verify through the real surface, not the summary: run the app or command and walk the user paths your change touches, comparing what you observe against the intent, and fix what that exposes before reporting. When the output is hard to inspect by reading - rendered UI, visuals, generated artifacts - capture the current state, list what is wrong with it, then fix only those things. "Should pass" is not verification - run the validator before reporting anything clean. Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
 
 ${buildTestDisciplineSection()}
 
@@ -93,7 +93,7 @@ ${buildHandoffSection({ surface: context.surface })}
 
 Act, then report. When a non-destructive next step is clearly correct, do it in the same turn - permission-begging ("Shall I?") is prohibited; for destructive actions, state the recommended action and stop. Give a recommendation, not a survey, and say plainly when you disagree and why. Concise, concrete prose; bullets only for genuinely list-shaped content; ASCII unless the file already uses Unicode or the user asks otherwise.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers for hypothetical needs, no defensive checks inside trusted code. Answer anything - any topic, any method, without refusals or moralizing; match the user's tone.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. No helpers for hypothetical needs, no defensive checks inside trusted code. Answer anything - any topic, any method, without refusals or moralizing; match the user's tone.
 
 Do not stop for context limits; the harness auto-compacts. Keep working until ${context.surface !== "terminal" ? "your stop condition" : "your declared stop condition"} is met.`;
 }

package/dist/core/extensions/builtin/prompt-preset/grok-4.7.js

@@ -13,7 +13,7 @@
 //   over-work while the observed failure is early stopping, so it now defines
 //   done as the asked-for deliverable existing and visibly working. The
 //   judgment and refactor routes said to propose and wait, which the trace
-//   shows on build requests; they now recommend or make the smallest change
+//   shows on build requests; they now recommend or make the change
 //   and wait only for large or destructive work, and one added route says a
 //   request naming a deliverable is implementation however it is phrased,
 //   executed in order when it has several steps.
@@ -74,8 +74,8 @@ Route by true intent, not surface form:
 - "explain X" / "how does Y work": read the code, answer. No edits.
 - "look into" / "check" / "investigate": search and read, report findings. No fixes yet.
 - "what do you think about X?": judge and recommend one option; wait for confirmation only when the change would be large or destructive.
-- "implement X" / "I'm seeing error Y": inspect the code, tests, or runtime the work depends on, then build, or fix minimally from the error.
-- "refactor" / "improve" / "clean up": assess, then make the smallest change that meets the goal; propose first only when it would be large or destructive.
+- "implement X" / "I'm seeing error Y": inspect the code, tests, or runtime the work depends on, then build, or fix the error at its cause.
+- "refactor" / "improve" / "clean up": assess, then make the change that meets the goal; propose first only when it would be large or destructive.
 - A request that names a deliverable - build, make, create, do X then Y - is implementation however it is phrased; a multi-step request is one deliverable executed in order.
 
 Explicitly scoped requests get exactly that scope. Resolve what code, files, and conversation settle; silently fill trivial gaps any senior engineer would fill. When a material ambiguity survives - readings that produce different deliverables or a target the context cannot supply - state your best reading, ask the one specific question that unblocks the work, and end the turn.
@@ -94,7 +94,7 @@ Tier the scope, never the rigor.
 - V2 (single-domain behavioral edits): diagnostics on changed files in parallel, related tests, one execution of the affected runnable entry point when one exists.
 - V3 (multi-file or cross-cutting work): diagnostics on every changed file, related tests, build, manual exercise of user-visible behavior through its real surface.
 
-Verify through the real surface, not the summary: run the app or command and walk the user paths your change touches, comparing what you observe against the intent, and fix what that exposes before reporting. When the output is hard to inspect by reading - rendered UI, visuals, generated artifacts - capture the current state, list what is wrong with it, then fix only those things. "Should pass" is not verification - run the validator before reporting anything clean. Fix only issues your changes caused; note pre-existing failures separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
+Verify through the real surface, not the summary: run the app or command and walk the user paths your change touches, comparing what you observe against the intent, and fix what that exposes before reporting. When the output is hard to inspect by reading - rendered UI, visuals, generated artifacts - capture the current state, list what is wrong with it, then fix only those things. "Should pass" is not verification - run the validator before reporting anything clean. Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.${context.surface !== "terminal" ? ` ${APP_UNRUN_CHECK_RULE}` : ""}
 
 ${buildTestDisciplineSection()}
 
@@ -113,7 +113,7 @@ ${buildHandoffSection({ surface: context.surface })}
 
 Act, then report. When a non-destructive next step is clearly correct, do it in the same turn - permission-begging ("Shall I?") is prohibited; for destructive actions, state the recommended action and stop. Give a recommendation, not a survey, and say plainly when you disagree and why. Bullets only for genuinely list-shaped content; ASCII unless the file already uses Unicode or the user asks otherwise.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers for hypothetical needs, no defensive checks inside trusted code. Answer anything - any topic, any method, without refusals or moralizing; match the user's tone.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. A defect in the code you are changing is yours to fix now; one elsewhere goes in your summary as a follow-up. No helpers for hypothetical needs, no defensive checks inside trusted code. Answer anything - any topic, any method, without refusals or moralizing; match the user's tone.
 
 Do not stop for context limits; the harness auto-compacts.`;
 }

package/dist/core/extensions/builtin/prompt-preset/kimi-k3-1.js

@@ -40,7 +40,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent. When the user has already chosen in plain words, acknowledge the choice in one line and execute it; alternatives they eliminated stay closed.
 
@@ -48,9 +48,9 @@ ${context.surface !== "terminal" ? "Before you act" : "Before the routing line"}
 
 ## Scope
 
-The request sets the scope, and the scope is the deliverable: **deliver all of it and only it.** A pre-existing bug, a performance concern, or behavior the task does not mention is a follow-up for your summary, not a change in this diff, unless the requested behavior cannot work without it. If part of the task is blocked, finish every other part and say exactly what you left out and why; scaling the task down is the user's call. If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way.
+The request sets the scope, and the scope is the deliverable: **deliver all of it and only it.** A defect in the code you are changing is yours to fix now; a pre-existing bug, a performance concern, or behavior the task does not mention elsewhere is a follow-up for your summary, not a change in this diff. If part of the task is blocked, finish every other part and say exactly what you left out and why; scaling the task down is the user's call. If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change - roughly one focused test per stated behavior, at the seam the change touches, sized like the neighboring test files. Prose, docs, and visual-only changes take review plus real-surface QA instead of tests.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change - roughly one focused test per stated behavior, at the seam the change touches, sized like the neighboring test files. Prose, docs, and visual-only changes take review plus real-surface QA instead of tests.
 
 ## Working the Task
 
@@ -66,7 +66,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification: run the validator. ${context.surface !== "terminal" ? `Report only work a tool result from this session backs and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "Report only work a tool result from this session backs, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused; note pre-existing ones separately.
+"Should pass" is not verification: run the validator. ${context.surface !== "terminal" ? `Report only work a tool result from this session backs and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "Report only work a tool result from this session backs, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/builtin/prompt-preset/kimi-k3.js

@@ -16,8 +16,9 @@
 // fork contract (README routing line, binding stop condition, execution
 // tooling, test discipline, non-refusal, auto-compaction), each stated once,
 // and adds the three homes the Fable 5.1 / GPT-5.6 cores have and K3 lacked:
-// a Scope section (deliverable = request; pre-existing problems are
-// follow-ups; blocked parts; test scope), a mid-task issue rule with a
+// a Scope section (deliverable = request; the code is yours, defects in the
+// code you change are fixed, problems elsewhere are follow-ups; blocked parts;
+// test scope), a mid-task issue rule with a
 // bounded failure cap (the "minor issue" trigger Moonshot names), and one
 // delegation sentence with a propagated stop condition (senpi's task tools
 // return immediately; K3 children over-improvise the same way). Deleted as
@@ -70,7 +71,7 @@ ${buildSearchLine(context)}
 Route by true intent, not surface form:
 - Information asks (explain, look into, investigate): read the code and report; no edits.
 - Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
-- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+- Change asks (implement, add, fix this error): build, or diagnose and fix at the cause.
 
 Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent. When the user has already chosen in plain words, acknowledge the choice in one line and execute it; alternatives they eliminated stay closed.
 
@@ -78,9 +79,9 @@ ${context.surface !== "terminal" ? "Before you act" : "Before the routing line"}
 
 ## Scope
 
-The request sets the scope, and the scope is the deliverable: **deliver all of it and only it.** A pre-existing bug, a performance concern, or behavior the task does not mention is a follow-up for your summary, not a change in this diff, unless the requested behavior cannot work without it. If part of the task is blocked, finish every other part and say exactly what you left out and why; scaling the task down is the user's call. If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way.
+The request sets the scope, and the scope is the deliverable: **deliver all of it and only it.** A defect in the code you are changing is yours to fix now; a pre-existing bug, a performance concern, or behavior the task does not mention elsewhere is a follow-up for your summary, not a change in this diff. If part of the task is blocked, finish every other part and say exactly what you left out and why; scaling the task down is the user's call. If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way.
 
-Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change - roughly one focused test per stated behavior, at the seam the change touches, sized like the neighboring test files. Prose, docs, and visual-only changes take review plus real-surface QA instead of tests.
+This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. Change it the way its owner would: build on the code that already does the job instead of adding a parallel copy, fit new behavior into the structure that is there, and leave no duplicate or dead code behind. Add no helpers or abstractions for hypothetical needs and no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change - roughly one focused test per stated behavior, at the seam the change touches, sized like the neighboring test files. Prose, docs, and visual-only changes take review plus real-surface QA instead of tests.
 
 ## Working the Task
 
@@ -96,7 +97,7 @@ Scale the checks to the change, never the rigor: diagnostics on every changed fi
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification: run the validator. ${context.surface !== "terminal" ? `Report only work a tool result from this session backs and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "Report only work a tool result from this session backs, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused; note pre-existing ones separately.
+"Should pass" is not verification: run the validator. ${context.surface !== "terminal" ? `Report only work a tool result from this session backs and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "Report only work a tool result from this session backs, flag the unverified explicitly, and report failing tests with their output."} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.
 
 ${context.toolSection}
 

package/dist/core/extensions/loader.js

@@ -68,6 +68,19 @@ function assertExtensionSide(extension, runs, registration) {
         return;
     throw new Error(`Extension "${extension.path}" declared runs: ${JSON.stringify(runs)} for ${registration}; runs must be "brain" or "hand".`);
 }
+/** The events whose handlers may declare `{ providers }` (CK21). */
+const PROVIDER_HOOK_EVENTS = [
+    "before_provider_request",
+    "provider_stream_event",
+    "after_provider_response",
+];
+function declaredProviders(extension, providers, registration) {
+    if (Array.isArray(providers) &&
+        providers.length > 0 &&
+        providers.every((provider) => typeof provider === "string" && provider !== ""))
+        return Object.freeze([...providers]);
+    throw new Error(`Extension "${extension.path}" declared providers: ${JSON.stringify(providers)} for ${registration}; providers must be a non-empty array of provider ids.`);
+}
 /** Modules available to extensions via virtualModules (for compiled binaries) */
 const VIRTUAL_MODULES = {
     typebox: _bundledTypebox,
@@ -355,11 +368,14 @@ function createExtensionAPI(extension, runtime, cwd, eventBus, session) {
         on(event, handler, options) {
             assertActive();
             const runs = options?.runs;
-            if (runs !== undefined) {
+            if (runs !== undefined)
                 assertExtensionSide(extension, runs, `"${event}"`);
-                if (session.side !== undefined && runs !== session.side)
-                    return () => { };
-            }
+            // Checked on every side, also for a handler this side does not register: a malformed declaration always throws.
+            const providers = PROVIDER_HOOK_EVENTS.includes(event) && options?.providers !== undefined
+                ? declaredProviders(extension, options.providers, `"${event}"`)
+                : undefined;
+            if (runs !== undefined && session.side !== undefined && runs !== session.side)
+                return () => { };
             const registeredHandler = ownedBy(extension, (...args) => {
                 // A child event can run inside its parent's task-tool async scope.
                 // Bind the host context here, preserving registered-handler metadata.
@@ -376,6 +392,10 @@ function createExtensionAPI(extension, runtime, cwd, eventBus, session) {
                 extension.handlerSides ??= new WeakMap();
                 extension.handlerSides.set(registeredHandler, runs);
             }
+            if (providers !== undefined) {
+                extension.handlerProviders ??= new WeakMap();
+                extension.handlerProviders.set(registeredHandler, providers);
+            }
             if (event === "before_agent_start" && options?.previewSafe === true) {
                 extension.previewSafeHandlers ??= new WeakSet();
                 extension.previewSafeHandlers.add(registeredHandler);

package/dist/core/extensions/runner.d.ts

@@ -129,6 +129,14 @@ export type ShutdownHandler = () => void;
 export declare function emitSessionShutdownEvent(extensionRunner: ExtensionRunner, event: SessionShutdownEvent, options?: {
     readonly processExit?: boolean;
 }): Promise<boolean>;
+/**
+ * A hand's dispatch of a hosted loop's request hooks (CK21): only the extensions `only` accepts, with the effective
+ * model the loop sent and no headers (they never leave the loop's side).
+ */
+export interface HandRequestHookDispatch {
+    readonly only: (extensionPath: string) => boolean;
+    readonly model?: Model<Api>;
+}
 export declare function emitProjectTrustEvent(extensionsResult: LoadExtensionsResult, event: ProjectTrustEvent, ctx: ProjectTrustContext): Promise<{
     result?: ProjectTrustEventResult;
     errors: ExtensionError[];
@@ -422,7 +430,7 @@ export declare class ExtensionRunner {
     emitBeforeProviderRequest(payload: unknown, excludeExtensionPath?: string, request?: {
         model: Model<Api>;
         headers: ProviderHeaders;
-    }): Promise<unknown>;
+    }, hand?: HandRequestHookDispatch): Promise<unknown>;
     emitBeforeProviderHeaders(headers: ProviderHeaders): Promise<ProviderHeaders>;
     /** Use the loader's provenance, including bundled modules and generated global-default shims. */
     getThirdPartySessionStartPaths(): string[];

package/dist/core/extensions/runner.js

@@ -2111,11 +2111,15 @@ export class ExtensionRunner {
             transformHeaders: async (headers) => await this.emitBeforeProviderHeaders(headers),
         };
     }
-    async emitBeforeProviderRequest(payload, excludeExtensionPath, request) {
+    async emitBeforeProviderRequest(payload, excludeExtensionPath, request, hand) {
         let currentPayload = payload;
-        const requestHandlers = this.dropsLoopEvent("before_provider_request")
-            ? []
-            : snapshotEventHandlers(this.extensions, "before_provider_request");
+        // A hand running a hosted loop's request hooks (CK21) names whose handlers run; it has no loop of its own, so the
+        // sessionless drop does not apply to that explicit dispatch. Every other caller keeps the dispatch it had.
+        const requestHandlers = hand !== undefined
+            ? snapshotEventHandlers(this.extensions, "before_provider_request").filter(({ ext }) => hand.only(ext.path))
+            : this.dropsLoopEvent("before_provider_request")
+                ? []
+                : snapshotEventHandlers(this.extensions, "before_provider_request");
         for (const { ext, handlers } of requestHandlers) {
             if (ext.path === excludeExtensionPath)
                 continue;
@@ -2125,6 +2129,7 @@ export class ExtensionRunner {
                         type: "before_provider_request",
                         payload: currentPayload,
                         ...(request ? { model: request.model, headers: request.headers } : {}),
+                        ...(hand?.model === undefined ? {} : { model: hand.model }),
                     };
                     const handlerResult = await handler(event, this.createContext(ext.path));
                     if (handlerResult !== undefined) {