@code-yeongyu/senpi 2026.11.10 → 2026.11.11

package/dist/core/config-reference-redaction.js

@@ -1,21 +1,101 @@
+/**
+ * Resolved-value registry shared by every copy of this module in one JavaScript realm (omo#12965).
+ *
+ * A process can evaluate this module more than once (the bundle's shared chunk, its self-contained session-worker
+ * entry, and the SDK graph an in-process child loads), so the values are not kept in a module-local set: the first
+ * copy pins a frozen registry on `globalThis` under `SLOT_KEY` (non-writable, non-configurable, non-enumerable) and
+ * every later copy adopts it. The backing `Set` lives only in the installing copy's closure; the registry offers no
+ * delete, clear or setter, so in-realm code cannot remove a value, replace the slot or turn redaction off. Any
+ * in-realm code can `add` a string, which can only over-redact. This is a stopgap until one engine instance serves
+ * the whole process; other realms (workers, `vm` contexts, child processes) keep their own registry.
+ *
+ * Compatibility contract, permanent: the key string never changes. The v1 members `version` (1), `add(value)`,
+ * `size` (an accessor reporting the live count) and `values()` (a fresh array) are never removed or repurposed; a
+ * later contract keeps writing through this same slot and only adds members, and adopters ignore members they do not
+ * know. A copy adopts only a slot pinned the way `pin` pins it, frozen, with those four members; anything else (a
+ * slot planted before the first copy loaded, an accessor, another version) makes the import throw
+ * `ConfigReferenceRedactionSlotError`, because a copy running with a private set is the leak this registry removes.
+ */
+const SLOT_KEY_NAME = "@code-yeongyu/senpi/config-reference-redaction/v1";
+const SLOT_KEY = Symbol.for(SLOT_KEY_NAME);
 const MIN_REDACTED_LENGTH = 4;
-const resolvedValues = new Set();
-let redactionForms;
+/** The largest `$file` reference value (`config-reference-file.ts`); longer strings are never remembered. */
+const MAX_REMEMBERED_LENGTH = 65_536;
+class ConfigReferenceRedactionSlotError extends Error {
+    constructor(cause) {
+        super(`The process-wide redaction registry ${SLOT_KEY_NAME} was not installed by senpi or is incompatible; restart the process.`, cause === undefined ? undefined : { cause });
+        this.name = "ConfigReferenceRedactionSlotError";
+        this.code = "SENPI_REDACTION_SLOT_INCOMPATIBLE";
+    }
+}
+function createRegistry() {
+    const values = new Set();
+    return Object.freeze({
+        version: 1,
+        add(value) {
+            if (typeof value !== "string" || value.length < MIN_REDACTED_LENGTH || value.length > MAX_REMEMBERED_LENGTH)
+                return;
+            values.add(value);
+        },
+        get size() {
+            return values.size;
+        },
+        values: () => [...values],
+    });
+}
+function isFrozenV1Registry(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.isFrozen(value) &&
+        Reflect.get(value, "version") === 1 &&
+        typeof Reflect.get(value, "add") === "function" &&
+        typeof Reflect.get(value, "values") === "function" &&
+        typeof Reflect.get(value, "size") === "number");
+}
+function pin(registry) {
+    try {
+        Object.defineProperty(globalThis, SLOT_KEY, {
+            value: registry,
+            writable: false,
+            configurable: false,
+            enumerable: false,
+        });
+    }
+    catch (error) {
+        throw new ConfigReferenceRedactionSlotError(error);
+    }
+    return registry;
+}
+function sharedRegistry() {
+    const slot = Reflect.getOwnPropertyDescriptor(globalThis, SLOT_KEY);
+    if (slot === undefined)
+        return pin(createRegistry());
+    const value = slot.value;
+    if (slot.writable !== false || slot.configurable !== false || !isFrozenV1Registry(value)) {
+        throw new ConfigReferenceRedactionSlotError();
+    }
+    return value;
+}
+const registry = sharedRegistry();
+let redactionForms = [];
+let formsSize = 0;
 /** Every value a reference resolves to is kept for the process lifetime, including rotated ones: no cap, no eviction. */
 export function rememberResolvedReferenceValue(value) {
-    if (value.length < MIN_REDACTED_LENGTH || resolvedValues.has(value))
-        return;
-    resolvedValues.add(value);
-    redactionForms = undefined;
+    registry.add(value);
 }
 function encodings(value) {
     const form = new URLSearchParams([["", value]]).toString().slice(1);
     return [value, JSON.stringify(value).slice(1, -1), encodeURIComponent(value), encodeURI(value), form];
 }
+/** The registry is append-only, so a changed size is the only way its content can change. */
 function forms() {
-    redactionForms ??= [...new Set([...resolvedValues].flatMap(encodings))]
-        .filter((form) => form.length >= MIN_REDACTED_LENGTH)
-        .sort((left, right) => right.length - left.length);
+    const size = registry.size;
+    if (size !== formsSize) {
+        redactionForms = [...new Set(registry.values().flatMap(encodings))]
+            .filter((form) => form.length >= MIN_REDACTED_LENGTH)
+            .sort((left, right) => right.length - left.length);
+        formsSize = size;
+    }
     return redactionForms;
 }
 /** Replaces every resolved reference value, raw or encoded, before text reaches a sink outside the process. */
@@ -134,7 +214,7 @@ function isProtocolValue(key, value) {
     return Object.hasOwn(PROTOCOL_VALUES, key) && PROTOCOL_VALUES[key]?.has(value) === true;
 }
 export function redactResolvedReferenceData(value) {
-    if (resolvedValues.size === 0)
+    if (registry.size === 0)
         return value;
     const copies = new WeakMap();
     const pending = [];

package/dist/core/context-files.d.ts

@@ -16,6 +16,16 @@ export type ContextFiles = ContextFile[] & {
 export interface ContextFileLimits {
     maxBytesPerFile?: number;
     maxTotalBytes?: number;
+    /**
+     * The global (user-scope) context file to load instead of the agent-dir probe (senpi#5567).
+     * Honored from the user's own settings only (`SettingsManager.getGlobalContextFilePath`); a
+     * project's settings never set it. A leading `~` is expanded; a relative path resolves against
+     * the agent dir, like other paths in global settings; a directory runs the same candidate probe
+     * as the agent dir. Unset or blank keeps the agent-dir file. A path that is set but missing,
+     * unreadable, a special file, or a directory with no candidate falls back to the agent-dir probe
+     * and reports one warning diagnostic instead of erroring.
+     */
+    globalPath?: string;
 }
 export declare const DEFAULT_CONTEXT_FILE_MAX_BYTES: number;
 export declare const DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES: number;

package/dist/core/context-files.js

@@ -29,6 +29,47 @@ function loadContextFileFromDir(dir) {
     }
     return null;
 }
+/**
+ * The global user-scope context file (senpi#5567). `contextFiles.globalPath` names a file (or a
+ * directory to probe for the usual candidates) to load in place of the agent-dir file. Precedence
+ * is defined and never errors: a blank or unset path keeps the agent-dir probe silently; a
+ * configured target that is missing, unreadable, a special file, or a directory with no candidates
+ * falls back to the agent-dir probe and returns one warning naming the configured path.
+ */
+function loadGlobalContextFile(agentDir, globalPath) {
+    const explicit = typeof globalPath === "string" ? globalPath.trim() : "";
+    if (explicit === "")
+        return { file: loadContextFileFromDir(agentDir) };
+    const resolved = resolvePath(explicit, agentDir);
+    const fallBack = (problem) => ({
+        file: loadContextFileFromDir(agentDir),
+        diagnostic: {
+            type: "warning",
+            path: resolved,
+            message: `contextFiles.globalPath ${problem}; using the global context file from ${agentDir} instead.`,
+        },
+    });
+    let stats;
+    try {
+        stats = statSync(resolved);
+    }
+    catch (error) {
+        const code = error.code;
+        return fallBack(code === "ENOENT" || code === "ENOTDIR" ? "does not exist" : `could not be read (${String(error)})`);
+    }
+    if (stats.isDirectory()) {
+        const file = loadContextFileFromDir(resolved);
+        return file ? { file } : fallBack("is a directory with no AGENTS.md or CLAUDE.md");
+    }
+    if (!stats.isFile())
+        return fallBack("is not a regular file or directory");
+    try {
+        return { file: { path: resolved, content: stripBom(readFileSync(resolved, "utf-8")) } };
+    }
+    catch (error) {
+        return fallBack(`could not be read (${String(error)})`);
+    }
+}
 /**
  * The main repo's context file that a nested linked worktree's own copy shadows: both
  * occupy the same logical repository scope, so loading both applies that context twice. Returns
@@ -142,21 +183,22 @@ function applyContextFileLimits(files, limits) {
     }
     return Object.assign(kept, { diagnostics });
 }
-/** Compares directories by their real path, ignoring case where the filesystem does (Windows). */
-function directoryKey(dir) {
-    const real = canonicalizePath(resolvePath(dir));
+/** Compares files and directories by their real path, ignoring case where the filesystem does (Windows). */
+function pathKey(path) {
+    const real = canonicalizePath(resolvePath(path));
     return process.platform === "win32" ? real.toLowerCase() : real;
 }
 export function loadProjectContextFiles(options) {
     const resolvedCwd = resolvePath(options.cwd);
     const resolvedAgentDir = resolvePath(options.agentDir);
-    const homeKey = directoryKey(options.homeDir ?? homedir());
+    const homeKey = pathKey(options.homeDir ?? homedir());
     const contextFiles = [];
+    // Real-path keys: a symlinked ancestor file that points at an already loaded file is the same file.
     const seenPaths = new Set();
-    const globalContext = loadContextFileFromDir(resolvedAgentDir);
-    if (globalContext) {
-        contextFiles.push({ ...globalContext, scope: "user" });
-        seenPaths.add(globalContext.path);
+    const globalContext = loadGlobalContextFile(resolvedAgentDir, options.globalPath);
+    if (globalContext.file) {
+        contextFiles.push({ ...globalContext.file, scope: "user" });
+        seenPaths.add(pathKey(globalContext.file.path));
     }
     const ancestorContextFiles = [];
     const shadowedContextFile = findShadowedContextFile(resolvedCwd);
@@ -164,9 +206,10 @@ export function loadProjectContextFiles(options) {
     while (true) {
         const contextFile = loadContextFileFromDir(currentDir);
         const isShadowed = shadowedContextFile !== undefined && canonicalizePath(contextFile?.path ?? "") === shadowedContextFile;
-        if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
-            ancestorContextFiles.unshift(directoryKey(currentDir) === homeKey ? { ...contextFile, scope: "user" } : contextFile);
-            seenPaths.add(contextFile.path);
+        const contextFileKey = contextFile ? pathKey(contextFile.path) : undefined;
+        if (contextFile && contextFileKey !== undefined && !isShadowed && !seenPaths.has(contextFileKey)) {
+            ancestorContextFiles.unshift(pathKey(currentDir) === homeKey ? { ...contextFile, scope: "user" } : contextFile);
+            seenPaths.add(contextFileKey);
         }
         const parentDir = dirname(currentDir);
         if (parentDir === currentDir)
@@ -174,6 +217,9 @@ export function loadProjectContextFiles(options) {
         currentDir = parentDir;
     }
     contextFiles.push(...ancestorContextFiles);
-    return applyContextFileLimits(contextFiles, options);
+    const limited = applyContextFileLimits(contextFiles, options);
+    if (globalContext.diagnostic)
+        limited.diagnostics.unshift(globalContext.diagnostic);
+    return limited;
 }
 //# sourceMappingURL=context-files.js.map

package/dist/core/credential-accounts.d.ts

@@ -53,6 +53,8 @@ export type CredentialAccountCheck = {
     readonly model: string;
     readonly outcome: "ok" | "failed";
     readonly reason?: string;
+    readonly message?: string;
+    readonly status?: number;
     readonly at: number;
 };
 export declare function assertValidAccountName(name: string): void;

package/dist/core/credential-accounts.js

@@ -38,7 +38,16 @@ function storedCheck(slot) {
     if (model === undefined || at === undefined || (outcome !== "ok" && outcome !== "failed"))
         return undefined;
     const reason = stringField(check, "reason");
-    return { model, outcome, ...(reason === undefined ? {} : { reason }), at };
+    const message = stringField(check, "message");
+    const status = numberField(check, "status");
+    return {
+        model,
+        outcome,
+        ...(reason === undefined ? {} : { reason }),
+        ...(message === undefined ? {} : { message }),
+        ...(status === undefined ? {} : { status }),
+        at,
+    };
 }
 /** The listing fields of a stored `claude-cli` slot, read defensively: auth.json is a trust boundary. */
 function claudeCliSlotFields(slot) {

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

@@ -24,7 +24,7 @@ const ROUTE_RULES = {
     full: `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.
 
 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.
 
@@ -32,7 +32,7 @@ Derive intent from the latest user turn alone: a new direction drops the stale p
     diet: `Route by true intent, not surface form:
 - 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.
+- Change ask (implement, add, fix this error): build, or diagnose + fix at the cause, exactly at asked scope = what fully satisfies an open-ended goal, nothing beyond; name ambiguity, resolve from context when possible.
 
 Deliver at asked scope; never quietly narrow, widen, swap. Routine calls: decide yourself; ask only when readings diverge into materially different work.
 

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

@@ -4,7 +4,7 @@ export function buildStyleSection(options = {}) {
     if (options.sharedSections === "full") {
         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.
+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. Prefer a targeted edit over rewriting a file when the result is 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.
 
@@ -16,7 +16,7 @@ Do not stop, summarize, or suggest a new session on account of context limits: t
     }
     return `## Style
 
-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.
+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. Defect in the code you are changing -> fix it now; elsewhere -> follow-up in your summary. 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; 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.
 

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

@@ -69,7 +69,7 @@ Tier the scope, never the rigor.
 
 ${buildTestDisciplineSection("full")}
 
-"Should pass" is not verification - run the validator. Before reporting progress, audit each claim against a tool result from this session: ${FULL_CLAIM_AUDIT[terminalOrApp(options.surface ?? "terminal")]} 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: ${FULL_CLAIM_AUDIT[terminalOrApp(options.surface ?? "terminal")]} Fix failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.`;
     }
     return `## Verification
 
@@ -81,6 +81,6 @@ Tier the scope, never the rigor.
 
 ${buildTestDisciplineSection()}
 
-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 failures your change caused and any that sit in the code you changed; note other pre-existing failures separately.`;
 }
 //# sourceMappingURL=verification.js.map

package/dist/core/egress/wire.d.ts

@@ -168,11 +168,24 @@ export interface HookModelRequest {
     readonly claim: SignedPlacementClaim;
     readonly input: HookModelRequestInput;
 }
+/** A user hook's failure on the hand: reported with the reply, as a fused session reports it, never thrown. */
+export interface HookFailure {
+    readonly extensionPath: string;
+    readonly event: string;
+    readonly error: string;
+}
 export interface HookModelRequestReply {
     readonly t: "hook.model_request.reply";
     readonly sessionId: string;
     readonly stepId: string;
     readonly output: HookModelRequestInput;
+    /** The hooks that failed; `output` is what the others produced. Absent: none failed. */
+    readonly errors?: readonly HookFailure[];
+    /** The messages and notices the hooks sent during the call, as on every loop-hook reply (S33). Absent: none. */
+    readonly sent?: readonly WireJson[];
+    readonly notices?: readonly WireJson[];
+    /** Late messages and notices the hand dropped past its per-session bound. Absent: none. */
+    readonly droppedLate?: number;
 }
 export interface HandSessionAdvertisement {
     readonly t: "hand.session.advertise";

package/dist/core/extensions/builtin/anthropic-subscription/accounts.d.ts

@@ -36,6 +36,9 @@ export type ClaudeCliAccountCheck = {
     model: string;
     outcome: "ok" | "failed";
     reason?: string;
+    /** Provider diagnostics, redacted before they enter the credential store. */
+    message?: string;
+    status?: number;
     at: number;
 };
 /**

package/dist/core/extensions/builtin/anthropic-subscription/auth-lane.js

@@ -12,7 +12,7 @@ import { accountDirFor, claudeCliSharedRoot, ensureAccountDir } from "./claude-c
 import { buildClaudeCliEnvironment } from "./claude-cli-environment.js";
 import { profileChanged, verifyClaudeCliInitialization } from "./claude-cli-token-source.js";
 import { writeConfigDirCredential } from "./config-dir-credentials.js";
-import { asksLegacyLongContext, CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW } from "./context-window.js";
+import { asksLegacyLongContext, CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW, claudeCodeMaxContextTokens, } from "./context-window.js";
 import { isExtraUsageExhausted } from "./errors.js";
 import { runFailover } from "./failover.js";
 import { logContinuityEvent } from "./session-observability.js";
@@ -153,7 +153,8 @@ export async function* queryWithAuthLane(input) {
             options.model = options.model?.replace(/\[1m\]$/, "");
             options.env = {
                 ...options.env,
-                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW),
+                // Claude Code then refuses only past the 200k window itself; the prompt-plus-output check below keeps the fit.
+                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(claudeCodeMaxContextTokens(CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW, outputReserveTokens)),
                 // Reserve and request the same output budget, not the model catalog's ceiling.
                 CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(outputReserveTokens),
             };

package/dist/core/extensions/builtin/anthropic-subscription/claude-cli-account-test.js

@@ -61,7 +61,9 @@ export async function testClaudeCliAccount(input) {
             return stored;
         return {
             ...credential,
-            accounts: (credential.accounts ?? []).map((slot) => slot.name === input.name ? checkedSlot(slot, check) : slot),
+            accounts: (credential.accounts ?? []).map((slot) => slot.name === input.name && slot.store === "claude-cli" && slot.dirId === before.dirId
+                ? checkedSlot(slot, check)
+                : slot),
         };
     });
     return check;

package/dist/core/extensions/builtin/anthropic-subscription/claude-cli-connection-test.d.ts

@@ -4,6 +4,8 @@ export type DefaultModelSelection = {
     readonly provider?: string;
     readonly model?: string;
 };
+/** auth.json keeps the redacted provider message for the UI; a proxy's HTML error page must not bloat it. */
+export declare const STORED_CHECK_MESSAGE_MAX_CHARS = 2000;
 /**
  * The model the sign-in connection test runs on: the default model when the default provider is this one, else the
  * provider's own default (`defaultModelPerProvider`), so the test exercises the model the user's turns will use.
@@ -21,7 +23,7 @@ export type ClaudeCliConnectionTestInput = {
 };
 /**
  * One "Reply with OK" turn on the named account, pinned with account fallback off, no tools, no setting sources and
- * no persisted session. The outcome is classified with the turn classifiers; only the kind is kept, never error text.
+ * no persisted session. The outcome uses the turn classifiers and retains the provider status and redacted message.
  */
 export declare function runClaudeCliConnectionTest(input: ClaudeCliConnectionTestInput): Promise<ClaudeCliAccountCheck>;
 //# sourceMappingURL=claude-cli-connection-test.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/claude-cli-connection-test.js

@@ -1,11 +1,25 @@
 import { defaultModelPerProvider } from "../../../model-resolver.js";
+import { redactSecrets } from "../../../sensitive-output.js";
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "./account-management.js";
 import { queryWithAuthLane } from "./auth-lane.js";
-import { classifySdkError, sdkAssistantFailure, sdkResultFailure } from "./errors.js";
+import { classifySdkError, errorText, sdkAssistantFailure, sdkResultFailure } from "./errors.js";
 import { refusalError } from "./refusal.js";
 import { getSdkBoundary, loadClaudeAgentSdk } from "./sdk-boundary.js";
 const CONNECTION_TEST_PROMPT = "Reply with OK";
 const CONNECTION_TEST_TIMEOUT_MS = 60_000;
+/** auth.json keeps the redacted provider message for the UI; a proxy's HTML error page must not bloat it. */
+export const STORED_CHECK_MESSAGE_MAX_CHARS = 2_000;
+function storedMessage(error) {
+    const message = redactSecrets(errorText(error));
+    if (message.length <= STORED_CHECK_MESSAGE_MAX_CHARS)
+        return message;
+    let end = STORED_CHECK_MESSAGE_MAX_CHARS - 1;
+    // Never end on the first half of a surrogate pair.
+    const last = message.charCodeAt(end - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        end -= 1;
+    return `${message.slice(0, end)}…`;
+}
 /**
  * The model the sign-in connection test runs on: the default model when the default provider is this one, else the
  * provider's own default (`defaultModelPerProvider`), so the test exercises the model the user's turns will use.
@@ -20,7 +34,7 @@ export function connectionTestModel(defaults) {
 }
 /**
  * One "Reply with OK" turn on the named account, pinned with account fallback off, no tools, no setting sources and
- * no persisted session. The outcome is classified with the turn classifiers; only the kind is kept, never error text.
+ * no persisted session. The outcome uses the turn classifiers and retains the provider status and redacted message.
  */
 export async function runClaudeCliConnectionTest(input) {
     const now = input.now ?? Date.now;
@@ -29,12 +43,27 @@ export async function runClaudeCliConnectionTest(input) {
     let handle;
     const closeOnAbort = () => handle?.close();
     signal.addEventListener("abort", closeOnAbort, { once: true });
-    const finish = (outcome, reason) => ({
-        model: input.model,
-        outcome,
-        ...(reason === undefined ? {} : { reason }),
-        at: now(),
-    });
+    const finish = (failure) => {
+        if (failure === undefined)
+            return { model: input.model, outcome: "ok", at: now() };
+        const { reason, error } = failure;
+        const status = failure.providerStatus ??
+            (error !== null && typeof error === "object" && "status" in error ? error.status : undefined);
+        return {
+            model: input.model,
+            outcome: "failed",
+            reason,
+            message: storedMessage(error),
+            ...(typeof status === "number" ? { status } : {}),
+            at: now(),
+        };
+    };
+    // The deadline and the caller's cancel win over whatever the SDK reports after close().
+    const abortedCheck = () => deadline.aborted
+        ? finish({ reason: "timeout", error: "Connection test timed out." })
+        : input.signal?.aborted
+            ? finish({ reason: "cancelled", error: "Connection test was cancelled." })
+            : undefined;
     try {
         await loadClaudeAgentSdk();
         const messages = queryWithAuthLane({
@@ -69,18 +98,20 @@ export async function runClaudeCliConnectionTest(input) {
                         ? sdkResultFailure(message)
                         : undefined);
             if (failure)
-                throw failure;
+                return (abortedCheck() ??
+                    finish({
+                        reason: classifySdkError(failure).kind,
+                        error: failure,
+                        providerStatus: message.type === "result" && "api_error_status" in message ? message.api_error_status : undefined,
+                    }));
             if (message.type === "result")
-                return finish("ok");
+                return finish();
         }
-        return finish("failed", signal.aborted ? (deadline.aborted ? "timeout" : "cancelled") : "no_result");
+        return (abortedCheck() ??
+            finish({ reason: "no_result", error: "Claude Code ended the connection test without a result." }));
     }
     catch (error) {
-        if (deadline.aborted)
-            return finish("failed", "timeout");
-        if (input.signal?.aborted)
-            return finish("failed", "cancelled");
-        return finish("failed", classifySdkError(error).kind);
+        return abortedCheck() ?? finish({ reason: classifySdkError(error).kind, error });
     }
     finally {
         signal.removeEventListener("abort", closeOnAbort);

package/dist/core/extensions/builtin/anthropic-subscription/claude-cli-login-slots.d.ts

@@ -6,7 +6,7 @@ import type { ClaudeCliProfile } from "./claude-cli-auth-status.ts";
  */
 export declare function signedInSlot(previous: AccountSlot | undefined, name: string, dirId: string, profile: ClaudeCliProfile, at: number): ClaudeCliAccountSlot;
 export declare function withSlot(credential: AnthropicSubscriptionCredential, slot: AccountSlot): AnthropicSubscriptionCredential;
-export declare function withCheck(credential: AnthropicSubscriptionCredential, name: string, check: ClaudeCliAccountCheck): AnthropicSubscriptionCredential;
+export declare function withCheck(credential: AnthropicSubscriptionCredential, name: string, check: ClaudeCliAccountCheck, dirId: string): AnthropicSubscriptionCredential;
 /**
  * The accounts with this login taken back. Only a slot that still points at this login's dir is touched: a new
  * account's slot is removed. For a re-login the login-bound fields always return to their previous values; every

package/dist/core/extensions/builtin/anthropic-subscription/claude-cli-login-slots.js

@@ -27,10 +27,12 @@ export function withSlot(credential, slot) {
         ? { ...credential, accounts: accounts.map((candidate) => (candidate.name === slot.name ? slot : candidate)) }
         : { ...credential, accounts: [...accounts, slot] };
 }
-export function withCheck(credential, name, check) {
+export function withCheck(credential, name, check, dirId) {
     return {
         ...credential,
-        accounts: (credential.accounts ?? []).map((candidate) => candidate.name === name && candidate.store === "claude-cli" ? { ...candidate, check } : candidate),
+        accounts: (credential.accounts ?? []).map((candidate) => candidate.name === name && candidate.store === "claude-cli" && candidate.dirId === dirId
+            ? { ...candidate, check }
+            : candidate),
     };
 }
 /**

package/dist/core/extensions/builtin/anthropic-subscription/claude-settings-env.d.ts

@@ -0,0 +1,20 @@
+import type { ResolveSettingsOptions, ResolvedSettings, SettingSource } from "@anthropic-ai/claude-agent-sdk";
+import { type AnthropicSubscriptionProviderSettings } from "./settings.ts";
+export type ClaudeSettingsEnvResolver = (options: ResolveSettingsOptions) => Promise<ResolvedSettings>;
+/**
+ * Read the effective `env` block Claude Code will apply from the settings files a query loads (senpi#2988 item 4).
+ * Uses the SDK's own settings merge engine, so the files, lookup rules and precedence are the CLI's, not a re-read.
+ * Returns undefined when no loaded settings file sets an `env` block, or when the merge fails — the caller then pins
+ * as if no settings lifetime existed, instead of failing the turn.
+ */
+export declare function resolveClaudeSettingsEnv(input: {
+    cwd: string;
+    settingSources: SettingSource[];
+}, resolveSettings?: ClaudeSettingsEnvResolver): Promise<Readonly<Record<string, string>> | undefined>;
+/**
+ * The settings env for one stream's queries. An explicit `settingSources` list applies to every lane; otherwise only
+ * a preset-append ambient attempt loads user/project settings (the same rule `buildAnthropicSubscriptionQueryOptions`
+ * uses), so anything else resolves to nothing and no merge runs.
+ */
+export declare function resolveQuerySettingsEnv(cwd: string, providerSettings: AnthropicSubscriptionProviderSettings): Promise<Readonly<Record<string, string>> | undefined>;
+//# sourceMappingURL=claude-settings-env.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/claude-settings-env.js

@@ -0,0 +1,39 @@
+import { loadedClaudeAgentSdk } from "./sdk-boundary.lazy.js";
+import { resolveSystemPromptMode } from "./settings.js";
+async function defaultResolveSettings(options) {
+    const sdk = loadedClaudeAgentSdk();
+    if (!sdk) {
+        throw new Error(`Claude Agent SDK was not preloaded before 'resolveSettings'. ` +
+            `Await loadClaudeAgentSdk() on the entry path before reaching the SDK boundary.`);
+    }
+    return sdk.resolveSettings(options);
+}
+/**
+ * Read the effective `env` block Claude Code will apply from the settings files a query loads (senpi#2988 item 4).
+ * Uses the SDK's own settings merge engine, so the files, lookup rules and precedence are the CLI's, not a re-read.
+ * Returns undefined when no loaded settings file sets an `env` block, or when the merge fails — the caller then pins
+ * as if no settings lifetime existed, instead of failing the turn.
+ */
+export async function resolveClaudeSettingsEnv(input, resolveSettings = defaultResolveSettings) {
+    try {
+        const resolved = await resolveSettings({ cwd: input.cwd, settingSources: input.settingSources });
+        const env = resolved.effective.env;
+        return env !== undefined && Object.keys(env).length > 0 ? env : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The settings env for one stream's queries. An explicit `settingSources` list applies to every lane; otherwise only
+ * a preset-append ambient attempt loads user/project settings (the same rule `buildAnthropicSubscriptionQueryOptions`
+ * uses), so anything else resolves to nothing and no merge runs.
+ */
+export async function resolveQuerySettingsEnv(cwd, providerSettings) {
+    const settingSources = providerSettings.settingSources ??
+        (resolveSystemPromptMode(providerSettings).mode === "preset-append" ? ["user", "project"] : []);
+    if (settingSources.length === 0)
+        return undefined;
+    return resolveClaudeSettingsEnv({ cwd, settingSources });
+}
+//# sourceMappingURL=claude-settings-env.js.map

package/dist/core/extensions/builtin/anthropic-subscription/context-window.d.ts

@@ -1,6 +1,23 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 /** Claude Code's default window when a request does not ask for the long context. */
 export declare const CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW = 200000;
+/**
+ * The `CLAUDE_CODE_MAX_CONTEXT_TOKENS` that makes Claude Code accept a conversation up to `window`.
+ *
+ * With `DISABLE_COMPACT` set, Claude Code takes that variable as the model's window, then refuses a
+ * request on its own, with no API call, once the conversation passes the window minus its output reserve
+ * (the request's output budget, capped at 20k) minus a 3k buffer. Handing it the bare planned window put
+ * that limit 23k below the window senpi compacts against, so every turn between the two failed in
+ * milliseconds with "Prompt is too long", and so did the summarization request of the recovery
+ * compaction. senpi keeps its own output reserve below `window`, so the variable carries the window plus
+ * Claude Code's reserve and Claude Code's limit lands on `window` itself.
+ *
+ * `outputTokens` is the output budget Claude Code reserves for the request. Without an explicit
+ * `CLAUDE_CODE_MAX_OUTPUT_TOKENS` it is the model's own default, which is at least the cap for every
+ * Claude model, so the cap is the default here; a larger addition only lets a request reach the API's own
+ * window check, whose error senpi's overflow recovery already parses.
+ */
+export declare function claudeCodeMaxContextTokens(window: number, outputTokens?: number): number;
 /**
  * Models whose 1M window is reachable only through Claude Code's `[1m]` opt-in, which sends the legacy
  * `context-1m-2025-08-07` beta that a subscription without extra usage refuses. These are the rows of