@code-yeongyu/senpi 2026.11.2-3 → 2026.11.3-1

package/dist/core/dynamic-prompt/build.d.ts

@@ -10,7 +10,7 @@ export interface DynamicPromptCoreContext {
     tools: AvailableTool[];
     surface: PromptSurface;
     appName?: string;
-    /** Rendered "## Available Tools" (+ "## Tool Guidelines") section. */
+    /** Rendered "## Available Tools" (+ "## Tool Guidelines") section; empty when it has nothing to list. */
     toolSection: string;
 }
 export interface BuildDynamicSystemPromptOptions {
@@ -28,6 +28,7 @@ export interface BuildDynamicSystemPromptOptions {
      */
     cwd: string;
     selectedTools: string[];
+    /** One-line snippets, listed under "## Available Tools" for selected tools; pass none for a tool whose schema description the model already sees. */
     toolSnippets: Record<string, string>;
     promptGuidelines: string[];
     contextFiles: Array<{

package/dist/core/dynamic-prompt/build.js

@@ -45,8 +45,7 @@ export function buildDynamicSystemPromptParts(options) {
             "",
             buildVerificationSection({ surface }),
             "",
-            toolSection,
-            "",
+            ...(toolSection ? [toolSection, ""] : []),
             buildPoliciesSection(),
             "",
             buildHandoffSection({ surface }),

package/dist/core/dynamic-prompt/handoff.d.ts

@@ -22,7 +22,7 @@ export interface HandoffSectionOptions {
  * the whole reply into English (senpi#2366). The labels stay fixed because the ttsr repetitive-turns
  * detector parses `Ask:` through `For you:` / `Now:` in model output; everything filled in follows the user.
  */
-export declare const HANDOFF_LANGUAGE_RULE = "Keep the labels Ask, wanted, For you, Now, and Next exactly as written; write everything else - the routing line, slot contents, todo labels, and the reply itself - in the user's language (the one their instructions name, else the one they write in), with Now and Next repeating the todo labels verbatim.";
+export declare const HANDOFF_LANGUAGE_RULE = "Labels Ask, wanted, For you, Now, Next: exactly as written. Everything else (routing line, slot contents, todo labels, reply) in user's language (named in their instructions, else the one they write in); Now/Next repeat todo labels verbatim.";
 /**
  * On `chat` each reply is posted to the people in a conversation (senpi#2398): the reply is the answer,
  * with no handoff block or ledger for a chat room to read. Shared by every core that states handoffs.

package/dist/core/dynamic-prompt/handoff.js

@@ -3,11 +3,11 @@
  * the whole reply into English (senpi#2366). The labels stay fixed because the ttsr repetitive-turns
  * detector parses `Ask:` through `For you:` / `Now:` in model output; everything filled in follows the user.
  */
-export const HANDOFF_LANGUAGE_RULE = "Keep the labels Ask, wanted, For you, Now, and Next exactly as written; write everything else - the routing line, slot contents, todo labels, and the reply itself - in the user's language (the one their instructions name, else the one they write in), with Now and Next repeating the todo labels verbatim.";
-const APP_HANDOFF_LANGUAGE_RULE = HANDOFF_LANGUAGE_RULE.replace("the routing line, ", "");
+export const HANDOFF_LANGUAGE_RULE = "Labels Ask, wanted, For you, Now, Next: exactly as written. Everything else (routing line, slot contents, todo labels, reply) in user's language (named in their instructions, else the one they write in); Now/Next repeat todo labels verbatim.";
+const APP_HANDOFF_LANGUAGE_RULE = HANDOFF_LANGUAGE_RULE.replace("routing line, ", "");
 const HANDOFF_MOMENTS = {
-    terminal: "A handoff is a multi-task todo list's creation (in the message that creates it, after the routing line, or the next one), each todo phase change, a blocker or plan change, and the end of a turn that changed something; the routing line is not one, and an answer stays an answer, even after tool calls.",
-    app: "A handoff is a multi-task todo list's creation (in the message that creates it or the next one), each todo phase change, a blocker or plan change, and the end of a turn that changed something; an answer stays an answer, even after tool calls.",
+    terminal: "Handoff moments: multi-task todo list created (same message after routing line, or next one), each todo phase change, blocker or plan change, end of a turn that changed something. Routing line is not one; an answer stays an answer even after tool calls.",
+    app: "Handoff moments: multi-task todo list created (same message or next one), each todo phase change, blocker or plan change, end of a turn that changed something. An answer stays an answer even after tool calls.",
 };
 /**
  * On `chat` each reply is posted to the people in a conversation (senpi#2398): the reply is the answer,
@@ -22,15 +22,15 @@ export function buildHandoffSection(options = {}) {
     if (surface === "chat")
         return CHAT_REPLIES_SECTION;
     const nextRule = options.turnEndRuleStatedElsewhere
-        ? "The Next you name is executed in this same response with tool calls."
-        : "The Next you name is executed in this same response with tool calls; a Next with nothing after it is a defect.";
+        ? "The named Next is executed in this same response with tool calls."
+        : "The named Next is executed in this same response with tool calls; a Next with nothing after it is a defect.";
     const betweenRule = options.briefUpdatesBetweenHandoffs
-        ? "Between handoffs, after each tool wave that changes what you know, write one line of reply text: what you found, then `Now: [task]. Next: [task].`"
-        : "Between handoffs, work without narration.";
+        ? "Between handoffs: after each tool wave that changes what you know, one line of reply text - what you found, then `Now: [task]. Next: [task].`"
+        : "Between handoffs: work without narration.";
     const languageRule = surface === "app" ? APP_HANDOFF_LANGUAGE_RULE : HANDOFF_LANGUAGE_RULE;
     return `## Handoff
 
-${HANDOFF_MOMENTS[surface]} Before writing one, weigh what the user originally asked for and what they would want to know right now; then state it in one short block:
+${HANDOFF_MOMENTS[surface]} First weigh original ask + what user needs now; then one short block:
 
 Ask: [the user's original request] - wanted: [the outcome they asked for]. For you: [what they need to know now - ledger N/M done, findings, blockers]. Now: [the todo task in progress]. Next: [the next open task].
 

package/dist/core/dynamic-prompt/identity.js

@@ -1,5 +1,5 @@
 import { APP_NAME } from "../../config.js";
 export function buildIdentitySection(appName = APP_NAME) {
-    return `You are ${appName}, a coding agent. Your work should be indistinguishable from a careful senior engineer's.`;
+    return `You are ${appName}, a coding agent. Work indistinguishable from a careful senior engineer's.`;
 }
 //# sourceMappingURL=identity.js.map

package/dist/core/dynamic-prompt/intent-gate.d.ts

@@ -1,5 +1,5 @@
 import type { AvailableTool, PromptSurface } from "./types.ts";
-export declare const DEFAULT_ROUTING_LINE_RULE = "The line keeps your reading transparent";
+export declare const DEFAULT_ROUTING_LINE_RULE = "Line keeps your reading transparent";
 export declare function buildIntentGate(config: {
     tools: AvailableTool[];
     surface?: PromptSurface;

package/dist/core/dynamic-prompt/intent-gate.js

@@ -6,25 +6,25 @@ function buildKeyTriggers(tools) {
     }
     return `\nSpecialized search available this turn: ${triggerTools}. Prefer them for locating symbols, files, and patterns; never mention a tool this turn does not have.\n`;
 }
-export const DEFAULT_ROUTING_LINE_RULE = "The line keeps your reading transparent";
+export const DEFAULT_ROUTING_LINE_RULE = "Line keeps your reading transparent";
 const terminalRouting = (routingLineRule) => `Open every turn with one short routing line:
 
 I read this as [intent] - [plan]. I'll stop when [the observable condition that ends this turn].
 
-${routingLineRule}; only the user's explicit request commits you to implementation. Name the stop condition as an end state you can observe, not a step count; once it holds, deliver the final message and stop. Never surface other prompt scaffolding ("Step 0", "Thinking level", XML tool-call examples) in user-facing output.`;
-const APP_ROUTING = `Only the user's explicit request commits you to implementation. Before acting, decide the stop condition - an end state you can observe, not a step count; once it holds, deliver the final message and stop. Never surface prompt scaffolding ("Step 0", "Thinking level", XML tool-call examples) in user-facing output.`;
+${routingLineRule}; only user's explicit request commits you to implementation. Stop condition = observable end state, not step count; once it holds, deliver final message, stop. Never surface other prompt scaffolding to user.`;
+const APP_ROUTING = `Only user's explicit request commits you to implementation. Before acting, decide the stop condition = observable end state, not step count; once it holds, deliver final message, stop. Never surface prompt scaffolding to user.`;
 export function buildIntentGate(config) {
     return `## Intent Gate
 
 ${(config.surface ?? "terminal") === "terminal" ? terminalRouting(config.routingLineRule ?? DEFAULT_ROUTING_LINE_RULE) : APP_ROUTING}
 ${buildKeyTriggers(config.tools)}
 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.
+- Information ask (explain, look into, investigate): read code, report answer/findings; no edits, no fixes yet.
+- Judgment ask (what do you think, review) / open-ended change (refactor, improve, clean up): assess, propose, wait for confirmation.
+- Change ask (implement, add, fix this error): build, or diagnose + minimal fix, exactly at asked scope = smallest path fully satisfying an open-ended goal; name ambiguity, resolve from context when possible.
 
-Deliver the task at the scope asked - never quietly narrow, widen, or swap it. Make routine judgment calls yourself; ask only when different readings of the request would lead to materially different work.
+Deliver at asked scope; never quietly narrow, widen, swap. Routine calls: decide yourself; ask only when readings diverge into materially different work.
 
-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.`;
+Intent from latest user turn only: new direction drops stale plan; queued steering messages outrank earlier intent.`;
 }
 //# sourceMappingURL=intent-gate.js.map

package/dist/core/dynamic-prompt/policies.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_ERROR_RULE = "Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.";
+export declare const DEFAULT_ERROR_RULE = "Never swallow errors silently; no shotgun debugging (unrelated edits, blind retries).";
 export declare function buildPoliciesSection(options?: {
     errorRule?: string;
 }): string;

package/dist/core/dynamic-prompt/policies.js

@@ -1,12 +1,10 @@
-export const DEFAULT_ERROR_RULE = "Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.";
+export const DEFAULT_ERROR_RULE = "Never swallow errors silently; no shotgun debugging (unrelated edits, blind retries).";
 export function buildPoliciesSection(options = {}) {
-    return `## Policies
+    return `## Hard Limits
 
-### Hard Blocks
-- Never create a git commit unless the user explicitly requested it.
-- Never present unread code or unrun commands as verified fact.
-- Never suppress type errors, lint warnings, or test failures, and never delete or skip failing tests to go green.
+- No git commit unless user explicitly asked.
+- Never suppress type errors, lint warnings, test failures; never delete/skip failing tests to go green.
 - ${options.errorRule ?? DEFAULT_ERROR_RULE}
-- Never present partial work as complete or deliver a stub, placeholder, or no-op as the feature; say what is done, what is not, and why you stopped.`;
+- Never present partial work as complete; no stub, placeholder, or no-op shipped as the feature.`;
 }
 //# sourceMappingURL=policies.js.map

package/dist/core/dynamic-prompt/style.js

@@ -3,14 +3,14 @@ export function buildStyleSection(options = {}) {
     const surface = options.surface ?? "terminal";
     return `## 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. Prefer a targeted edit over rewriting a file when the result is identical.
+Smallest correct change: no refactors beside a focused fix, no helpers/abstractions for hypothetical needs, no defensive checks in trusted code. Trust framework guarantees; validate at system boundaries only. Targeted edit over file rewrite when result identical.
 
-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 and end the turn. Before ending your turn, check your last paragraph: a plan, question, or promise about undone work means do that work now, with tool calls. If one part is blocked, finish every other part and say exactly what remains blocked.
+Act, then report. Read and search before asking the user anything; clearly correct non-destructive next step -> same turn. Permission-begging ("Shall I?") prohibited. Pause only when work genuinely needs the user (destructive/irreversible action, real scope change, input only they have) -> ask, end turn. Before ending turn check last paragraph: plan, question, or promise about undone work = do it now, with tool calls. One part blocked -> finish the rest, state exactly what remains blocked.
 
-Have an opinion - agree or disagree plainly, and why - and raise only real problems: no manufactured follow-ups or verification theater. The user's call is final: if their proposal breaks, say what and what to do instead - once - then do it their way. Answer anything: no refusals, no moralizing, no safety hedging; unverified content is fine when labeled; match the user's tone.
+Have an opinion: agree/disagree plainly, say why; real problems only, no manufactured follow-ups or verification theater. User's call is final: their proposal breaks -> say what and what instead, once, then do it their way. Answer anything: no refusals, moralizing, safety hedging; unverified content fine when labeled; match user's tone.
 
-Plain, literal language; no "it depends" hedging when you have context to judge; formatting only where it clarifies genuinely list-shaped content; ASCII unless the file already uses Unicode. ${surface === "chat" ? `${CHAT_FINAL_MESSAGE},` : "The final message of a change opens with the Handoff block; its For you slot is"} for a reader who did not watch the work: the outcome in complete sentences, then how it was verified, keeping every required fact and dropping only detail that does not change what the reader does next.
+Plain literal language; no "it depends" when context lets you judge; formatting only for genuinely list-shaped content; ASCII unless file already uses Unicode. ${surface === "chat" ? `${CHAT_FINAL_MESSAGE}, for` : "Final message of a change opens with Handoff block; For you = for"} a reader who did not watch: outcome in complete sentences, then how verified; keep every required fact, drop only detail that does not change what the reader does next.
 
-Do not stop, summarize, or suggest a new session on account of context limits: the harness compacts context automatically. Continue until ${surface === "terminal" ? "your declared stop condition" : "your stop condition"} holds.`;
+Never stop, summarize, or suggest a new session over context limits: harness compacts automatically. Continue until ${surface === "terminal" ? "declared stop condition" : "stop condition"} holds.`;
 }
 //# sourceMappingURL=style.js.map

package/dist/core/dynamic-prompt/tool-section.d.ts

@@ -1,4 +1,9 @@
 import type { AvailableTool } from "./types.ts";
+/**
+ * Lists only tools that carry a snippet; callers pass snippets solely for tools whose schema the model
+ * does not see described, so a tool's own description is never restated here (senpi#5335). With no
+ * listed tool and no guideline the section renders empty.
+ */
 export declare function buildToolSection(options: {
     tools: AvailableTool[];
     toolSnippets: Record<string, string>;

package/dist/core/dynamic-prompt/tool-section.js

@@ -6,6 +6,11 @@ const CATEGORY_LABELS = {
     session: "Session",
     command: "Commands",
 };
+/**
+ * Lists only tools that carry a snippet; callers pass snippets solely for tools whose schema the model
+ * does not see described, so a tool's own description is never restated here (senpi#5335). With no
+ * listed tool and no guideline the section renders empty.
+ */
 export function buildToolSection(options) {
     const groupedTools = new Map();
     for (const tool of options.tools) {
@@ -17,23 +22,20 @@ export function buildToolSection(options) {
         existingTools.push({ name: tool.name, snippet });
         groupedTools.set(tool.category, existingTools);
     }
-    const lines = ["## Available Tools", ""];
-    let hasVisibleTools = false;
+    const lines = [];
     for (const category of CATEGORY_ORDER) {
         const categoryTools = groupedTools.get(category);
         if (!categoryTools || categoryTools.length === 0) {
             continue;
         }
-        hasVisibleTools = true;
+        if (lines.length === 0)
+            lines.push("## Available Tools", "");
         lines.push(`### ${CATEGORY_LABELS[category]}`);
         for (const tool of categoryTools) {
             lines.push(`- ${tool.name}: ${tool.snippet}`);
         }
         lines.push("");
     }
-    if (!hasVisibleTools) {
-        lines.push("(none)", "");
-    }
     const guidelines = options.promptGuidelines?.map((guideline) => guideline.trim()).filter((guideline) => guideline) ?? [];
     const evalOnlyGrepGuideline = getEvalOnlyGrepGuideline(options.tools.map(({ name }) => name), options.toolSnippets);
     if (evalOnlyGrepGuideline)

package/dist/core/dynamic-prompt/verification.d.ts

@@ -7,27 +7,27 @@ export type TestDisciplineRule = {
 export declare const TEST_DISCIPLINE_RULES: readonly [{
     readonly id: "deterministic-tests";
     readonly concern: "test-determinism";
-    readonly directive: "When you read or edit test code, treat nondeterminism as a bug; tests must not pass by timing luck.";
+    readonly directive: "Reading/editing test code: nondeterminism = bug; no passing by timing luck.";
 }, {
     readonly id: "fixed-wait-ban";
     readonly concern: "async-test-orchestration";
-    readonly directive: "Unless time itself is the behavior under test, fixed sleeps, polling delays, and wait-for-time patterns are forbidden.";
+    readonly directive: "Fixed sleeps, polling delays, wait-for-time: forbidden unless time itself is under test.";
 }, {
     readonly id: "event-timeout-pattern";
     readonly concern: "async-test-orchestration";
-    readonly directive: "For async behavior, subscribe to the exact event or state change before triggering the action, then await that signal with a bounded timeout.";
+    readonly directive: "Async: subscribe to the exact event/state change before triggering, then await it with a bounded timeout.";
 }, {
     readonly id: "mock-contract-integrity";
     readonly concern: "mock-contracts";
-    readonly directive: "Mocks must preserve the behavior being asserted; do not isolate so heavily that the integration under test cannot fail.";
+    readonly directive: "Mocks keep the asserted behavior; never isolate so hard the integration cannot fail.";
 }, {
     readonly id: "prompt-behavior-coverage";
     readonly concern: "prompt-tests";
-    readonly directive: "Never pin prose, prompt wording, or doc text with a test; test only machine-consumed values (parsed fields, sentinel tokens, shipped-copy equality). A pure-prose change ships with no new test.";
+    readonly directive: "Never pin prose, prompt wording, or doc text with a test; test machine-consumed values only (parsed fields, sentinel tokens, shipped-copy equality). Pure-prose change = no new test.";
 }, {
     readonly id: "single-pass-runner";
     readonly concern: "test-runner";
-    readonly directive: "Run the relevant test command once and make that pass reliable; for Bun test targets, bun test must pass in a single run.";
+    readonly directive: "Run the relevant test command once, make that pass reliable; Bun targets: bun test passes in a single run.";
 }];
 export declare function buildTestDisciplineSection(): string;
 /**

package/dist/core/dynamic-prompt/verification.js

@@ -3,32 +3,32 @@ export const TEST_DISCIPLINE_RULES = [
     {
         id: "deterministic-tests",
         concern: "test-determinism",
-        directive: "When you read or edit test code, treat nondeterminism as a bug; tests must not pass by timing luck.",
+        directive: "Reading/editing test code: nondeterminism = bug; no passing by timing luck.",
     },
     {
         id: "fixed-wait-ban",
         concern: "async-test-orchestration",
-        directive: "Unless time itself is the behavior under test, fixed sleeps, polling delays, and wait-for-time patterns are forbidden.",
+        directive: "Fixed sleeps, polling delays, wait-for-time: forbidden unless time itself is under test.",
     },
     {
         id: "event-timeout-pattern",
         concern: "async-test-orchestration",
-        directive: "For async behavior, subscribe to the exact event or state change before triggering the action, then await that signal with a bounded timeout.",
+        directive: "Async: subscribe to the exact event/state change before triggering, then await it with a bounded timeout.",
     },
     {
         id: "mock-contract-integrity",
         concern: "mock-contracts",
-        directive: "Mocks must preserve the behavior being asserted; do not isolate so heavily that the integration under test cannot fail.",
+        directive: "Mocks keep the asserted behavior; never isolate so hard the integration cannot fail.",
     },
     {
         id: "prompt-behavior-coverage",
         concern: "prompt-tests",
-        directive: "Never pin prose, prompt wording, or doc text with a test; test only machine-consumed values (parsed fields, sentinel tokens, shipped-copy equality). A pure-prose change ships with no new test.",
+        directive: "Never pin prose, prompt wording, or doc text with a test; test machine-consumed values only (parsed fields, sentinel tokens, shipped-copy equality). Pure-prose change = no new test.",
     },
     {
         id: "single-pass-runner",
         concern: "test-runner",
-        directive: "Run the relevant test command once and make that pass reliable; for Bun test targets, bun test must pass in a single run.",
+        directive: "Run the relevant test command once, make that pass reliable; Bun targets: bun test passes in a single run.",
     },
 ];
 export function buildTestDisciplineSection() {
@@ -44,20 +44,20 @@ export function buildTestDisciplineSection() {
  */
 export const APP_UNRUN_CHECK_RULE = "A check that did not run is covered by the evidence that did run; name it only when no other evidence supports the claim. Replies render in an app, so tool and hook feedback (comment-checker findings, language-server availability, internal notices) is for you to act on: it reaches the user only when it changes what they get, and an unavailable tool or hook never does by itself.";
 const CLAIM_AUDIT = {
-    terminal: "report only evidence-backed work, flag the unverified explicitly, and report failing tests with the output.",
-    app: `report only evidence-backed work and report failing tests with the output. ${APP_UNRUN_CHECK_RULE}`,
+    terminal: "evidence-backed work only, flag unverified explicitly, failing tests with output.",
+    app: `evidence-backed work only, failing tests with output. ${APP_UNRUN_CHECK_RULE}`,
 };
 export function buildVerificationSection(options = {}) {
     return `## Verification
 
 Tier the scope, never the rigor.
 
-- V1 (single-file non-behavioral edits): diagnostics on that file. Done.
-- 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.
+- V1 single-file non-behavioral edit: diagnostics on that file. Done.
+- V2 single-domain behavioral edit: diagnostics on changed files in parallel + related tests + one run of affected runnable entry point if any.
+- V3 multi-file / cross-cutting: diagnostics on every changed file + related tests + build + manual exercise of user-visible behavior through its real surface.
 
 ${buildTestDisciplineSection()}
 
-"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${CLAIM_AUDIT[terminalOrApp(options.surface ?? "terminal")]} Fix only issues your changes caused; note pre-existing failures separately.`;
+Before reporting progress: audit each claim against a tool result from this session; ${CLAIM_AUDIT[terminalOrApp(options.surface ?? "terminal")]} Fix only issues your changes caused; note pre-existing failures separately.`;
 }
 //# sourceMappingURL=verification.js.map

package/dist/core/dynamic-prompt/working-task.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_WORKING_TASK_OPENING = "Fire independent tool calls as one parallel wave - reads, searches, listings, diagnostics - and bias toward breadth when context is thin: pull in anything even loosely relevant now instead of serially later. Wasted reads cost almost nothing; stale assumptions cost the turn. Edits and result-dependent calls go one at a time, each compared with the state you meant to produce; when the result must be seen rather than read, render after each change and look before the next. Never fill missing parameters with placeholders.";
+export declare const DEFAULT_WORKING_TASK_OPENING = "Independent calls (reads, searches, listings, diagnostics) -> one parallel wave; thin context -> go wide now, pull anything loosely relevant, not serially later. Edits + result-dependent calls -> one at a time, each compared with intended state; result must be seen -> render after each change, look before next. Never fill missing parameters with placeholders.";
 export declare function buildWorkingTaskSection(options?: {
     opening?: string;
 }): string;

package/dist/core/dynamic-prompt/working-task.js

@@ -1,11 +1,11 @@
-export const DEFAULT_WORKING_TASK_OPENING = "Fire independent tool calls as one parallel wave - reads, searches, listings, diagnostics - and bias toward breadth when context is thin: pull in anything even loosely relevant now instead of serially later. Wasted reads cost almost nothing; stale assumptions cost the turn. Edits and result-dependent calls go one at a time, each compared with the state you meant to produce; when the result must be seen rather than read, render after each change and look before the next. Never fill missing parameters with placeholders.";
+export const DEFAULT_WORKING_TASK_OPENING = "Independent calls (reads, searches, listings, diagnostics) -> one parallel wave; thin context -> go wide now, pull anything loosely relevant, not serially later. Edits + result-dependent calls -> one at a time, each compared with intended state; result must be seen -> render after each change, look before next. Never fill missing parameters with placeholders.";
 export function buildWorkingTaskSection(options = {}) {
     return `## Working the Task
 
 ${options.opening ?? DEFAULT_WORKING_TASK_OPENING}
 
-Memory of file contents is unreliable - read before claiming, re-read before editing. Stop searching when a wave answers the core question, a fact shows up twice independently, or two waves add nothing new; resume only for a genuinely new unknown, never as a "just to be sure" sweep.
+Memory of file contents unreliable: read before claiming, re-read before editing. Stop searching when a wave answers the core question, a fact appears twice independently, or two waves add nothing; resume only for a genuinely new unknown, never a "just to be sure" sweep.
 
-Make one reasonable plan and execute it; reopen it only when new evidence contradicts it. Do not re-derive facts already established in the conversation or re-litigate decisions the user has made. When weighing a choice, give a recommendation, not a survey. When a delegation tool is available, hand sizeable independent tracks to subagents and keep working while they run; keep work you can finish in a few calls yourself.`;
+One reasonable plan, execute; reopen only when new evidence contradicts it. Don't re-derive established facts or re-litigate user decisions. Weighing a choice -> recommendation, not survey. Delegation tool available: hand sizeable independent tracks to subagents, keep working meanwhile; few-call work -> yourself.`;
 }
 //# sourceMappingURL=working-task.js.map

package/dist/core/dynamic-prompt/workstation.js

@@ -131,7 +131,7 @@ ${executors} on THIS workstation. Match commands, paths, package managers, and p
     codex: (executors) => `${executors} on this workstation; match commands, paths, and parallelism to it. Written code may target other platforms: executed code runs here.`,
     kimi: (executors) => `${executors} on this workstation: choose commands, paths, and parallelism that fit it. When writing code for another target platform, keep the code portable; only the execution happens here.`,
     gemini: (executors) => `${executors} on this workstation; match commands, paths, package managers, and parallel pool sizes to it. Code you write may target another machine; code you run always runs here.`,
-    default: (executors) => `**EXECUTION HAPPENS HERE.** ${executors} on THIS machine: you MUST match commands, paths, package managers, and parallel pool sizes to the workstation above. Code you WRITE may target a different machine; anything you RUN executes HERE.`,
+    default: (executors) => `**EXECUTION HAPPENS HERE.** ${executors} on THIS machine: match commands, paths, package managers, parallel pool sizes to the workstation above. Code you WRITE may target another machine; anything you RUN executes HERE.`,
 };
 /** Render the `<workstation>` facts block plus the dialect-tuned execution-context instruction. */
 export function buildWorkstationSection(options) {

package/dist/core/extensions/builtin/anthropic-subscription/session-registry-pump.d.ts

@@ -5,6 +5,13 @@ export type { SessionTurnResult } from "./session-turn-types.ts";
 export declare const DEFAULT_PRE_REPLAY_MAX_MESSAGES = 64;
 export declare const DEFAULT_PRE_REPLAY_MAX_BYTES: number;
 export declare const SESSION_TURN_ABORT_GRACE_MS = 1000;
+/**
+ * How long a turn submitted while the previous turn of the same session is still active waits for that turn to
+ * settle before the submission is refused. The common case settles within the abort grace above: the agent loop
+ * starts the next turn (a steer, a follow-up, a monitor notification) right after it interrupted or finished
+ * consuming the previous one, while the pump still waits for the SDK's terminal result of that turn.
+ */
+export declare const SESSION_TURN_ADMISSION_WAIT_MS = 10000;
 export interface SessionTurnRequest {
     message: SDKUserMessage["message"];
     signal?: AbortSignal;
@@ -16,5 +23,11 @@ export declare class ConcurrentSessionTurnAdmissionError extends Error {
     readonly code = "claude_sdk_oauth_concurrent_turn_admission";
     constructor(sessionId: string);
 }
+/**
+ * Waits for `settled`, bounded by SESSION_TURN_ADMISSION_WAIT_MS: "admitted" once it settles, "aborted" when
+ * `signal` aborts first, and a ConcurrentSessionTurnAdmissionError when the bound passes, so a stuck pump cannot
+ * hold the session's callers forever.
+ */
+export declare function waitForTurnAdmission(sessionId: string, settled: Promise<unknown>, signal: AbortSignal | undefined, schedule?: (callback: () => void, delayMs: number) => () => void): Promise<"admitted" | "aborted">;
 export declare function submitSessionTurn(registry: AnthropicSubscriptionSessionRegistry, entry: AnthropicSubscriptionSessionEntry, request: SessionTurnRequest, limits?: PreReplayBufferLimits): Promise<SessionTurnResult>;
 //# sourceMappingURL=session-registry-pump.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/session-registry-pump.js

@@ -8,6 +8,13 @@ import { SessionTurnAttributionError } from "./session-turn-types.js";
 export const DEFAULT_PRE_REPLAY_MAX_MESSAGES = 64;
 export const DEFAULT_PRE_REPLAY_MAX_BYTES = 256 * 1024;
 export const SESSION_TURN_ABORT_GRACE_MS = 1_000;
+/**
+ * How long a turn submitted while the previous turn of the same session is still active waits for that turn to
+ * settle before the submission is refused. The common case settles within the abort grace above: the agent loop
+ * starts the next turn (a steer, a follow-up, a monitor notification) right after it interrupted or finished
+ * consuming the previous one, while the pump still waits for the SDK's terminal result of that turn.
+ */
+export const SESSION_TURN_ADMISSION_WAIT_MS = 10_000;
 export class ConcurrentSessionTurnAdmissionError extends Error {
     constructor(sessionId) {
         super(`Concurrent Anthropic Subscription turn admission for session ${sessionId}`);
@@ -154,12 +161,66 @@ async function runPump(registry, entry) {
         failTurn(registry, entry, error instanceof Error ? error : new Error(String(error)));
     }
 }
+/**
+ * Waits for `settled`, bounded by SESSION_TURN_ADMISSION_WAIT_MS: "admitted" once it settles, "aborted" when
+ * `signal` aborts first, and a ConcurrentSessionTurnAdmissionError when the bound passes, so a stuck pump cannot
+ * hold the session's callers forever.
+ */
+export function waitForTurnAdmission(sessionId, settled, signal, schedule = scheduleAbort) {
+    return new Promise((resolve, reject) => {
+        let done = false;
+        let cancelTimer;
+        const finish = (run) => {
+            if (done)
+                return;
+            done = true;
+            cancelTimer?.();
+            signal?.removeEventListener("abort", onAbort);
+            run();
+        };
+        const onAbort = () => finish(() => resolve("aborted"));
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        // The scheduler may fire synchronously (tests inject one); `done` then stops every later step.
+        cancelTimer = schedule(() => finish(() => reject(new ConcurrentSessionTurnAdmissionError(sessionId))), SESSION_TURN_ADMISSION_WAIT_MS);
+        if (done)
+            return;
+        signal?.addEventListener("abort", onAbort, { once: true });
+        const admitted = () => finish(() => resolve("admitted"));
+        void settled.then(admitted, admitted);
+    });
+}
+/**
+ * A turn submitted while the session's previous turn is still active waits for that turn to settle, bounded by
+ * SESSION_TURN_ADMISSION_WAIT_MS, then submits. One SDK session runs one turn at a time, so the second request is
+ * logically after the first; refusing it (the behavior before this guard) surfaced as a provider failure and moved
+ * the session to a fallback model for no reason of the provider's. An abort of the waiting request resolves it as
+ * an aborted turn; a previous turn that does not settle in time keeps the refusal.
+ */
+async function admitAfter(registry, entry, active, settled, request, limits) {
+    const generation = entry.generation;
+    const outcome = await waitForTurnAdmission(entry.senpiSessionId, settled, request.signal, request.scheduleAbort);
+    if (outcome === "aborted")
+        return { uuid: createSessionUuid(), messages: [], aborted: true };
+    if (!registry.isCurrentGeneration(entry.senpiSessionId, generation)) {
+        throw new Error("Anthropic Subscription session closed while a turn waited for admission");
+    }
+    if (currentTurn(entry) === active)
+        entry.activeTurn = null;
+    return submitSessionTurn(registry, entry, request, limits);
+}
 export function submitSessionTurn(registry, entry, request, limits = {
     maxMessages: DEFAULT_PRE_REPLAY_MAX_MESSAGES,
     maxBytes: DEFAULT_PRE_REPLAY_MAX_BYTES,
 }) {
-    if (currentTurn(entry))
-        throw new ConcurrentSessionTurnAdmissionError(entry.senpiSessionId);
+    const active = currentTurn(entry);
+    if (active) {
+        if (!active.settled)
+            throw new ConcurrentSessionTurnAdmissionError(entry.senpiSessionId);
+        return admitAfter(registry, entry, active, active.settled, request, limits);
+    }
     if (entry.state === "STARTING")
         transitionToIdleSynced(entry);
     transitionToTurnWaiting(entry);
@@ -199,6 +260,7 @@ export function submitSessionTurn(registry, entry, request, limits = {
             limits,
         };
     });
+    turn.settled = promise.then(() => undefined, () => undefined);
     entry.activeTurn = turn;
     if (!entry.pumpTask)
         entry.pumpTask = runPump(registry, entry);

package/dist/core/extensions/builtin/anthropic-subscription/session-stream.js

@@ -12,7 +12,7 @@ import { bindingFromEntry, bindingInvalidationReason, getBinding } from "./sessi
 import { closeSession, getOrCreateSession, getSession, isIdleExpired, } from "./session-registry.js";
 import { admitRestoredBinding } from "./session-restored-admission.js";
 import { buildDeltaPromptBlocks, configFingerprint, sentHashesForEntry, sentMessageHashes, sentMessages, } from "./session-sync.js";
-import { createSessionTurnAttempt } from "./session-turn-attempt.js";
+import { createSessionTurnAttempt, waitForActiveTurn } from "./session-turn-attempt.js";
 function userMessage(content) {
     return { role: "user", content };
 }
@@ -46,6 +46,10 @@ async function createResidentAttempt(input, auth) {
     const sessionId = input.streamOptions.sessionId;
     const messages = sentMessages(input.context);
     const hashes = sentMessageHashes(messages);
+    // Continuity and the delta are read from the settled previous turn, never from one still in flight.
+    const pending = getSession(sessionId);
+    if (pending)
+        await waitForActiveTurn(pending, input.streamOptions.signal);
     const existing = getSession(sessionId);
     const fingerprint = configFingerprint(auth.options, input.context, auth.authLane, auth.accountName);
     const residentHashes = existing ? (sentHashesForEntry(existing) ?? hashes) : hashes;

package/dist/core/extensions/builtin/anthropic-subscription/session-turn-attempt.d.ts

@@ -4,6 +4,13 @@ import { type AnthropicSubscriptionSessionEntry } from "./session-registry.ts";
 type StagedContinuityDecision = {
     emit(): void;
 };
+/**
+ * Holds a new attempt until the attempt running the entry's previous turn finished and recorded the sent stream
+ * (`recordSyncedStream`), bounded and abortable like the pump's own admission wait. The caller decides
+ * continuity and the delta only after this, so the delta starts after the earlier turn's message instead of
+ * sending it again (senpi#5015 review).
+ */
+export declare function waitForActiveTurn(entry: AnthropicSubscriptionSessionEntry, signal: AbortSignal | undefined): Promise<void>;
 /** Claude Code's wording for a fork point absent from its transcript; the captured id is the dead one. */
 export declare const RESUME_MESSAGE_MISSING: RegExp;
 export declare function createSessionTurnAttempt(entry: AnthropicSubscriptionSessionEntry, message: SDKUserMessage["message"], hashes: readonly string[], signal: AbortSignal | undefined, staged: StagedContinuityDecision, 

package/dist/core/extensions/builtin/anthropic-subscription/session-turn-attempt.js

@@ -2,8 +2,24 @@ import { BoundedAsyncQueue, SESSION_STREAM_QUEUE_CAPACITY } from "./bounded-queu
 import { sdkResultFailure } from "./errors.js";
 import { bindingFromEntry, forgetBinding, rememberBinding } from "./session-reattach.js";
 import { closeSession, isCurrentGeneration, sessionRegistry, } from "./session-registry.js";
-import { submitSessionTurn } from "./session-registry-pump.js";
+import { submitSessionTurn, waitForTurnAdmission } from "./session-registry-pump.js";
 import { recordSyncedStream, sentHashPrefixDigest } from "./session-sync.js";
+/** Pending while the attempt that submitted the entry's latest turn has not yet recorded what that turn sent. */
+const attemptBookkeeping = new WeakMap();
+/**
+ * Holds a new attempt until the attempt running the entry's previous turn finished and recorded the sent stream
+ * (`recordSyncedStream`), bounded and abortable like the pump's own admission wait. The caller decides
+ * continuity and the delta only after this, so the delta starts after the earlier turn's message instead of
+ * sending it again (senpi#5015 review).
+ */
+export async function waitForActiveTurn(entry, signal) {
+    const pending = attemptBookkeeping.get(entry);
+    if (!pending)
+        return;
+    if ((await waitForTurnAdmission(entry.senpiSessionId, pending, signal)) === "aborted") {
+        throw new Error("Anthropic Subscription turn aborted while waiting for the previous turn");
+    }
+}
 function successfulTurn(messages) {
     return messages.some((message) => message.type === "result" && message.subtype === "success" && sdkResultFailure(message) === undefined);
 }
@@ -91,6 +107,16 @@ servedLineage) {
     return {
         messages: (async function* () {
             const queue = new BoundedAsyncQueue(SESSION_STREAM_QUEUE_CAPACITY);
+            let markBookkept;
+            const bookkeeping = new Promise((resolve) => {
+                markBookkept = resolve;
+            });
+            attemptBookkeeping.set(entry, bookkeeping);
+            const bookkept = () => {
+                if (attemptBookkeeping.get(entry) === bookkeeping)
+                    attemptBookkeeping.delete(entry);
+                markBookkept();
+            };
             const completion = submitSessionTurn(sessionRegistry, entry, {
                 message,
                 signal,
@@ -147,6 +173,7 @@ servedLineage) {
             finally {
                 // A consumer that stops reading early must not leave the pump waiting for room.
                 queue.close();
+                bookkept();
             }
         })(),
         discard: () => {

package/dist/core/extensions/builtin/anthropic-subscription/session-turn-types.d.ts

@@ -23,6 +23,8 @@ export interface ActiveTurn {
     resolve: (result: SessionTurnResult) => void;
     reject: (error: Error) => void;
     limits: PreReplayBufferLimits;
+    /** Settles (never rejects) once the turn resolved or rejected; a turn submitted behind it waits here. */
+    settled?: Promise<void>;
 }
 export interface PreReplayBufferLimits {
     maxMessages: number;

package/dist/core/extensions/builtin/bash-timeout/index.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "../../types.ts";
 export type { BashTimeoutDefaults, BashToolInputLike } from "./timeout.ts";
-export { applyBashTimeout, BASH_DEFAULT_TIMEOUT_SECONDS, BASH_MAX_TIMEOUT_SECONDS, buildBashTimeoutPrompt, resolveBashTimeoutDefaults, } from "./timeout.ts";
+export { applyBashTimeout, BASH_DEFAULT_TIMEOUT_SECONDS, resolveBashTimeoutDefaults } from "./timeout.ts";
 export default function bashTimeoutExtension(pi: ExtensionAPI): void;
 //# sourceMappingURL=index.d.ts.map