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

package/dist/core/auth-store-load-error.js

@@ -0,0 +1,74 @@
+import { stripBom } from "../utils/text.js";
+import { CredentialStoreBusyError } from "./lockfile-policy.js";
+export class AuthStoreUnreadableError extends Error {
+    constructor(loadError) {
+        super(`Your sign-in store (auth.json) could not be read: ${loadError.reason}. Nothing was changed; repair or move auth.json in the agent directory, then sign in again.`);
+        this.name = "AuthStoreUnreadableError";
+        this.loadError = loadError;
+    }
+}
+/**
+ * A store load that failed after auth.json was read and parsed: saving its repaired or migrated copy
+ * failed (`wroteBack`), or the lock was lost once the read was done. Neither means the file is unreadable.
+ */
+class AuthStoreAfterReadError extends Error {
+    constructor(cause, wroteBack) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        super(wroteBack
+            ? `auth.json was read, but saving its repaired or migrated copy failed: ${detail}`
+            : `auth.json was read, but its lock was lost before the read finished: ${detail}`, { cause });
+        this.name = "AuthStoreAfterReadError";
+        this.wroteBack = wroteBack;
+    }
+}
+/** The top-level object of an auth.json document; anything else is refused rather than read as empty. */
+export function parseAuthDocument(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripBom(content));
+    }
+    catch {
+        throw new AuthStoreUnreadableError({ kind: "malformed_json", reason: "it is not valid JSON" });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new AuthStoreUnreadableError({ kind: "invalid_format", reason: "it does not hold a JSON object" });
+    }
+    return parsed;
+}
+/**
+ * The load error a failed store read stands for, or undefined when the failure says nothing about
+ * the file: a lock held by another writer, a read the caller aborted, or a lock lost after a clean read.
+ */
+export function describeAuthStoreLoadFailure(error) {
+    if (error instanceof AuthStoreUnreadableError)
+        return error.loadError;
+    if (error instanceof CredentialStoreBusyError)
+        return undefined;
+    if (error instanceof Error && error.name === "AbortError")
+        return undefined;
+    if (error instanceof AuthStoreAfterReadError) {
+        if (!error.wroteBack)
+            return undefined;
+        const code = errnoCode(error.cause);
+        const reason = "it was read, but its repaired or migrated copy could not be saved";
+        return { kind: "write_back_failed", reason: code ? `${reason} (${code})` : reason };
+    }
+    const code = errnoCode(error);
+    return {
+        kind: "unreadable",
+        reason: code ? `the file could not be read (${code})` : "the file could not be read",
+    };
+}
+/**
+ * The error a store load surfaces: once auth.json parsed, a later failure (a write-back or a lost lock)
+ * becomes an AuthStoreAfterReadError so it is never reported as an unreadable file. Aborts pass through.
+ */
+export function failureAfterRead(error, load) {
+    if (!load.parsed || (error instanceof Error && error.name === "AbortError"))
+        return error;
+    return new AuthStoreAfterReadError(error, load.writeBack);
+}
+function errnoCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
+}
+//# sourceMappingURL=auth-store-load-error.js.map

package/dist/core/brand.d.ts

@@ -46,6 +46,8 @@ export interface BrandProfile {
     readonly userAgent: string;
     /** Product token used as the provider-side originator, when the distribution overrides it. */
     readonly originator?: string;
+    /** Product logo for the sign-in result pages, as a base64 image data URI. */
+    readonly logo?: string;
     /** Update channel of the branded product; absent means the product manages updates itself. */
     readonly update?: BrandUpdateChannel;
     readonly changelog?: BrandChangelog;

package/dist/core/brand.js

@@ -91,6 +91,7 @@ export function parseBrandProfile(raw) {
         envPrefix: (readString(source, "envPrefix") || name).toUpperCase(),
         userAgent: readString(source, "userAgent") || name,
         originator: readString(source, "originator"),
+        logo: readString(source, "logo"),
         update: readUpdateChannel(source),
         ...(changelog ? { changelog } : {}),
     };

package/dist/core/credential-pool/classify.d.ts

@@ -31,8 +31,9 @@ export type CredentialAction = {
 };
 /**
  * Per-slot exponential cooldown with the server hint as a FLOOR, never an
- * override: a hint can only lengthen the wait the failure count already earned,
- * and everything caps at 48 hours with the capping recorded.
+ * override: a hint can only lengthen the wait the failure count already earned.
+ * The guessed backoff stops growing at GUESSED_BACKOFF_CAP_MS; everything caps at
+ * 48 hours with the capping recorded.
  */
 export declare function rateLimitCooldown(failureCount: number, serverHintMs?: number, policy?: {
     baseMs?: number;

package/dist/core/credential-pool/classify.js

@@ -11,6 +11,12 @@ import { usageLimitResetMs } from "./reset-time.js";
 import { isAccountUsageLimitText } from "./usage-limit.js";
 export const COOLDOWN_BASE_MS = DEFAULT_SLOT_BLOCK_MS;
 export const COOLDOWN_CAP_MS = MAX_SLOT_BLOCK_MS;
+/**
+ * The longest a guessed backoff may grow. A block with no provider-stated reset is only a guess, so
+ * the slot is re-probed at least this often: doubling to the 48 h cap across failed probes kept a
+ * spent account blocked for hours after its provider window had reset (senpi#4091).
+ */
+const GUESSED_BACKOFF_CAP_MS = 30 * 60 * 1_000;
 export const RETRY_SAME_MAX_ATTEMPTS = 2;
 /**
  * Carried by every refusal a provider that runs its own account pool (Anthropic Subscription) makes
@@ -22,13 +28,14 @@ export const RETRY_SAME_MAX_ATTEMPTS = 2;
 export const ACCOUNT_POOL_REFUSAL_NOTE = "No request was sent: the account pool refused it locally.";
 /**
  * Per-slot exponential cooldown with the server hint as a FLOOR, never an
- * override: a hint can only lengthen the wait the failure count already earned,
- * and everything caps at 48 hours with the capping recorded.
+ * override: a hint can only lengthen the wait the failure count already earned.
+ * The guessed backoff stops growing at GUESSED_BACKOFF_CAP_MS; everything caps at
+ * 48 hours with the capping recorded.
  */
 export function rateLimitCooldown(failureCount, serverHintMs, policy = {}) {
     const cap = policy.capMs ?? COOLDOWN_CAP_MS;
     const base = policy.baseMs ?? COOLDOWN_BASE_MS;
-    const backoff = Math.min(cap, base * 2 ** Math.max(0, failureCount));
+    const backoff = Math.min(cap, GUESSED_BACKOFF_CAP_MS, base * 2 ** Math.max(0, failureCount));
     const floored = serverHintMs === undefined ? backoff : Math.max(backoff, serverHintMs);
     return {
         cooldownMs: Math.min(cap, floored),

package/dist/core/credential-pool/failover.d.ts

@@ -82,6 +82,14 @@ export declare class CredentialFailoverError extends Error {
     });
 }
 export declare function isAvailable(slot: Pick<RunSlot, "blockReason" | "blockedUntil">, now: number): boolean;
+/**
+ * The slots a request's next attempt may pick from: the untried, unblocked ones, else the cooling
+ * probe. Empty means the request is refused. Shared by the stream and by auxiliary callers that
+ * resolve the session's account outside it (senpi#3924), so both treat an all-blocked pool alike.
+ */
+export declare function attemptCandidates<TSlot extends RunSlot>(slots: readonly TSlot[], attempted: ReadonlySet<string>, now: number): TSlot[];
+/** The refusal a request gets when {@link attemptCandidates} is empty before any attempt ran. */
+export declare function noSlotsError(slots: readonly RunSlot[], now: number): CredentialFailoverError;
 /**
  * Generic in-lane credential failover. Runs at most one failover attempt per
  * slot per request, retries provider-scoped faults on the SAME slot up to the

package/dist/core/credential-pool/failover.js

@@ -46,6 +46,20 @@ function coolingProbe(slots, attempted) {
     const soonest = cooling.reduce((best, slot) => (best === undefined || (slot.blockedUntil ?? 0) < (best.blockedUntil ?? 0) ? slot : best), undefined);
     return soonest === undefined ? [] : [soonest];
 }
+/**
+ * The slots a request's next attempt may pick from: the untried, unblocked ones, else the cooling
+ * probe. Empty means the request is refused. Shared by the stream and by auxiliary callers that
+ * resolve the session's account outside it (senpi#3924), so both treat an all-blocked pool alike.
+ */
+export function attemptCandidates(slots, attempted, now) {
+    const available = slots.filter((slot) => !attempted.has(slot.name) && isAvailable(slot, now));
+    return available.length > 0 ? available : coolingProbe(slots, attempted);
+}
+/** The refusal a request gets when {@link attemptCandidates} is empty before any attempt ran. */
+export function noSlotsError(slots, now) {
+    const retryAt = soonestRetryAt(slots, now);
+    return new CredentialFailoverError({ kind: "fail_request" }, new Error(noSlotsMessage(slots, now)), retryAt === undefined ? {} : { retryAt });
+}
 /**
  * A slot's due-back time as the reader's local clock shows it, followed by the ISO instant that the goal
  * provider-retry scan (`providerRetryAt`) and turn-end liveness read from this text (senpi#4329).
@@ -134,17 +148,16 @@ export async function* runCredentialFailover(options) {
     try {
         while (true) {
             const slots = await options.listSlots();
-            const available = slots.filter((slot) => !attempted.has(slot.name) && isAvailable(slot, now()));
-            const candidates = available.length > 0 ? available : coolingProbe(slots, attempted);
+            const candidates = attemptCandidates(slots, attempted, now());
             if (candidates.length === 0) {
                 if (lastTerminalEvent !== undefined) {
                     yield lastTerminalEvent;
                     return;
                 }
+                if (lastError === undefined || lastOriginal === undefined)
+                    throw noSlotsError(slots, now());
                 const retryAt = soonestRetryAt(slots, now());
-                throw lastError !== undefined && lastOriginal !== undefined
-                    ? new CredentialFailoverError(lastError.action, lastOriginal, retryAt === undefined ? {} : { retryAt })
-                    : new CredentialFailoverError({ kind: "fail_request" }, new Error(noSlotsMessage(slots, now())), retryAt === undefined ? {} : { retryAt });
+                throw new CredentialFailoverError(lastError.action, lastOriginal, retryAt === undefined ? {} : { retryAt });
             }
             const slot = options.select(candidates);
             unsettled = slot;

package/dist/core/credential-pool/rotation-stream.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
-import { type SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
+import type { SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
 import { type RotationSlot, type RotationSources } from "./rotation-slots.ts";
 export { listRotationSlots, type RotationLane, type RotationSlot, type RotationSources } from "./rotation-slots.ts";
 /** The exact hash the claude-sdk-oauth affinity oracle uses, so pools never remap. */

package/dist/core/credential-pool/rotation-stream.js

@@ -1,5 +1,4 @@
 import { createHash, randomUUID } from "node:crypto";
-import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
 import { emitProviderAccountFailover, emitProviderAccountsChanged, } from "../extensions/builtin/anthropic-subscription/account-events.js";
 import { AUTH_BLOCK_REPROBE_MS } from "./auth-reprobe.js";
 import { classifyCredentialFailure } from "./classify.js";
@@ -8,6 +7,7 @@ import { STORE_BUSY, writeHealthUnlessStoreBusy } from "./health-write.js";
 import { modelBlockKey, pruneModelBlocks, withModelBlock } from "./model-scope.js";
 import { isCommittedRotationOutput, isRotationStreamStart, rotationErrorFromEvent } from "./rotation-events.js";
 import { listRotationSlots, releaseProbeLease } from "./rotation-slots.js";
+import { pickRotationSlot } from "./session-slot.js";
 export { listRotationSlots } from "./rotation-slots.js";
 /** The exact hash the claude-sdk-oauth affinity oracle uses, so pools never remap. */
 export const sha256SlotHasher = (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0);
@@ -79,12 +79,7 @@ export function streamWithCredentialRotation(options) {
     return runCredentialFailover({
         listSlots: () => listRotationSlots(sources, options.modelId === undefined ? {} : { modelId: options.modelId }),
         select: (candidates) => {
-            const pinned = candidates.find((candidate) => candidate.pinned === true);
-            if (pinned)
-                return pinned;
-            const ranked = useAffinity ? rendezvousOrder(affinityKey, candidates, hasher) : candidates;
-            const ordered = applyAccountOrder(pooled?.order, ranked);
-            const winner = ordered[0];
+            const winner = pickRotationSlot(candidates, { affinityKey, useAffinity, hasher, order: pooled?.order });
             if (!winner)
                 throw new Error("credential rotation selected from an empty candidate set");
             return winner;

package/dist/core/credential-pool/session-slot.d.ts

@@ -0,0 +1,20 @@
+import { type SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
+import type { RotationSlot } from "./rotation-slots.ts";
+export type SlotPickPolicy = {
+    affinityKey: string;
+    useAffinity: boolean;
+    hasher: SlotHasher;
+    /** The pool's user account order, applied after the pin (senpi#3591). */
+    order?: readonly string[];
+};
+/** The pin when present, else the first account of the affinity order with the user's order applied. */
+export declare function pickRotationSlot<TSlot extends RotationSlot>(candidates: readonly TSlot[], policy: SlotPickPolicy): TSlot | undefined;
+/**
+ * The account a session's next streamed request starts on, for callers that send a resolved key
+ * outside the rotation stream (compaction, /btw, look-at, cache keepalive). It is the stream's own
+ * first pick: the same candidates (unblocked accounts, else the rate-limited one due back first) and
+ * the same order. When the stream would refuse, this throws the stream's refusal, so an auxiliary
+ * request never authenticates as an account the stream would not use.
+ */
+export declare function selectSessionSlot<TSlot extends RotationSlot>(slots: readonly TSlot[], policy: SlotPickPolicy, now: number): TSlot | undefined;
+//# sourceMappingURL=session-slot.d.ts.map

package/dist/core/credential-pool/session-slot.js

@@ -0,0 +1,26 @@
+import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
+import { attemptCandidates, noSlotsError } from "./failover.js";
+/** The pin when present, else the first account of the affinity order with the user's order applied. */
+export function pickRotationSlot(candidates, policy) {
+    const pinned = candidates.find((candidate) => candidate.pinned === true);
+    if (pinned)
+        return pinned;
+    const ranked = policy.useAffinity ? rendezvousOrder(policy.affinityKey, candidates, policy.hasher) : candidates;
+    return applyAccountOrder(policy.order, ranked)[0];
+}
+/**
+ * The account a session's next streamed request starts on, for callers that send a resolved key
+ * outside the rotation stream (compaction, /btw, look-at, cache keepalive). It is the stream's own
+ * first pick: the same candidates (unblocked accounts, else the rate-limited one due back first) and
+ * the same order. When the stream would refuse, this throws the stream's refusal, so an auxiliary
+ * request never authenticates as an account the stream would not use.
+ */
+export function selectSessionSlot(slots, policy, now) {
+    if (slots.length === 0)
+        return undefined;
+    const candidates = attemptCandidates(slots, new Set(), now);
+    if (candidates.length === 0)
+        throw noSlotsError(slots, now);
+    return pickRotationSlot(candidates, policy);
+}
+//# sourceMappingURL=session-slot.js.map

package/dist/core/credential-recovery-revision.d.ts

@@ -0,0 +1,10 @@
+import type { AuthStorage } from "./auth-storage.ts";
+/**
+ * The retry-fallback recovery revision of `provider` (senpi#4099): the `loginId` the last sign-in
+ * stored, or "" when none did. A token refresh keeps the id or drops it to "" and never mints one, so
+ * only a sign-in moves it to a new non-empty value. The
+ * metadata read reloads another process's write without resolving key references. An unreadable
+ * store answers `undefined`, which never releases anything.
+ */
+export declare function credentialRecoveryRevision(storage: AuthStorage | undefined, provider: string): Promise<string | undefined>;
+//# sourceMappingURL=credential-recovery-revision.d.ts.map

package/dist/core/credential-recovery-revision.js

@@ -0,0 +1,19 @@
+/**
+ * The retry-fallback recovery revision of `provider` (senpi#4099): the `loginId` the last sign-in
+ * stored, or "" when none did. A token refresh keeps the id or drops it to "" and never mints one, so
+ * only a sign-in moves it to a new non-empty value. The
+ * metadata read reloads another process's write without resolving key references. An unreadable
+ * store answers `undefined`, which never releases anything.
+ */
+export async function credentialRecoveryRevision(storage, provider) {
+    if (!storage)
+        return undefined;
+    try {
+        await storage.list();
+        return storage.get(provider)?.loginId ?? "";
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=credential-recovery-revision.js.map

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;
 /**