@code-yeongyu/senpi 2026.10.16-2 → 2026.10.16-4

package/dist/core/agent-session.js

@@ -122,6 +122,7 @@ import { composeFilesystemPolicies } from "./tools/filesystem-policy.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { TranscriptWriteFailures } from "./transcript-write-failures.js";
+import { AgentDeadlineTracker, resolveTurnDeadlineSettings, TURN_DEADLINE_ENTRY_TYPE, } from "./turn-deadline.js";
 import { commandShapedName, findUnknownCommand } from "./unknown-command.js";
 import { addUsageToTotals, combineUsage, createUsageTotals } from "./usage-totals.js";
 import { keepsTextBlocksVerbatim, userTextContent } from "./user-text-blocks.js";
@@ -324,6 +325,8 @@ export class AgentSession {
         this._continueWithQueuedInput = false;
         /** True while a reload's `session_start` handlers run; a nested reload would retire the runner they run on. */
         this._sessionStartDispatching = false;
+        /** Waiters for the moment no prompt start is pending and no session start is dispatching (applyProjectTrustChange). */
+        this._admissionIdleWaiters = [];
         this._engineTurnStarts = [];
         this._engineTurnPauseRecorded = false;
         this._nextInputId = 0;
@@ -659,6 +662,10 @@ export class AgentSession {
                 activeToolNames: this._initialActiveToolNames,
                 includeAllExtensionTools: true,
             });
+            this._deadlineTracker = new AgentDeadlineTracker(this, () => resolveTurnDeadlineSettings({
+                turn_inactivity_ms: this.settingsManager.getTurnInactivityMs(),
+                turn_max_runtime_ms: this.settingsManager.getTurnMaxRuntimeMs(),
+            }));
             // Last, so a construction that throws never leaves a hold only dispose() could release.
             this._fallbackCircuitsLease = acquireFallbackCircuits(this._agentDir);
         }
@@ -1788,6 +1795,7 @@ export class AgentSession {
             }
         }
         this.releaseSettledSessionMemory();
+        this._deadlineTracker.disarm();
         this._emit({ type: "agent_idle" });
     }
     async _promptAgent(messages, deferredTurnClaim, onQueuedInput) {
@@ -1795,6 +1803,8 @@ export class AgentSession {
         if (!this._isAgentRunActive)
             this.externalAdmission.beginTurn();
         this._isAgentRunActive = true;
+        // A new turn admitted: arm the inactivity lease and the hard max-runtime cap.
+        this._deadlineTracker.arm();
         // A new prompt replaces any retry that compaction before it scheduled.
         this._failedResponse = undefined;
         this._recordSelection();
@@ -2188,6 +2198,9 @@ export class AgentSession {
             ? withProviderFailure({
                 ...event,
                 willRetry: agentEndWillRetry,
+                ...(this._deadlineTracker.current !== undefined
+                    ? { aborted: true, abortSource: "system", deadline: this._deadlineTracker.current }
+                    : {}),
                 ...(abortCause === undefined ? {} : { abortCause }),
             })
             : event.type === "message_update"
@@ -2245,7 +2258,7 @@ export class AgentSession {
                     assistantMsg.stopReason !== "aborted" &&
                     !isClassifierRefusal(assistantMsg);
                 if (succeeded)
-                    this._retryFallback.probes.accept(`${assistantMsg.provider}/${assistantMsg.model}`);
+                    this._retryFallback.noteServed(`${assistantMsg.provider}/${assistantMsg.model}`);
                 if (succeeded && assistantMsg.stopReason !== "length") {
                     this._overflowRecoveryRungs = 0;
                 }
@@ -2755,6 +2768,7 @@ export class AgentSession {
             }
         }
         else if (event.type === "tool_execution_start") {
+            this._deadlineTracker.renew();
             const extensionEvent = {
                 type: "tool_execution_start",
                 toolCallId: event.toolCallId,
@@ -2764,6 +2778,7 @@ export class AgentSession {
             await this._extensionRunner.emit(extensionEvent);
         }
         else if (event.type === "tool_execution_update") {
+            this._deadlineTracker.renew();
             const extensionEvent = {
                 type: "tool_execution_update",
                 toolCallId: event.toolCallId,
@@ -2774,6 +2789,7 @@ export class AgentSession {
             await this._extensionRunner.emit(extensionEvent);
         }
         else if (event.type === "tool_execution_end") {
+            this._deadlineTracker.renew();
             const extensionEvent = {
                 type: "tool_execution_end",
                 toolCallId: event.toolCallId,
@@ -2838,6 +2854,7 @@ export class AgentSession {
      */
     dispose() {
         this._disposed = true;
+        this._deadlineTracker.disarm();
         for (const dispose of this._toolContextDisposers)
             dispose();
         try {
@@ -3008,6 +3025,10 @@ export class AgentSession {
     get isStreaming() {
         return this._isAgentRunActive;
     }
+    /** True while a provider retry is in flight; the deadline lease treats it as turn progress. */
+    get isRetryInFlight() {
+        return this._retryPromise !== undefined;
+    }
     /** Whether the session has no active agent run, retry, or queued continuation. */
     get isIdle() {
         return !this._isAgentRunActive;
@@ -3043,6 +3064,27 @@ export class AgentSession {
     get currentAbortSource() {
         return this._abortProvenance.currentSource;
     }
+    /** The deadline that stopped the current turn, when the lease fired (senpi#3227). */
+    get currentDeadline() {
+        return this._deadlineTracker.current;
+    }
+    /** Adapter for the deadline owner interface: a deadline stop that could not complete. */
+    _warnDeadline(event, detail) {
+        this._sessionLogger.warn(event, { detail });
+    }
+    /** Adapter for the deadline owner interface: end the turn through the normal system abort. */
+    async abortTurnForDeadline() {
+        await this._abortActiveAgentAndRetry("system");
+    }
+    /** Record a deadline stop durably so the goal engine holds off until admitted user input. */
+    _recordDeadlineStop(deadline) {
+        this._emitEntryAppended(this.sessionManager.appendCustomEntry(TURN_DEADLINE_ENTRY_TYPE, {
+            kind: deadline.kind,
+            limitMs: deadline.limitMs,
+            elapsedMs: deadline.elapsedMs,
+            at: Date.now(),
+        }));
+    }
     /**
      * Get the names of currently active tools.
      * Returns the names of tools currently set on the agent. Tools with `search` or `eval` exposure
@@ -3557,8 +3599,10 @@ export class AgentSession {
             submittedByCommand: options?.source === "extension",
         });
         try {
-            if (options?.source !== "extension")
+            if (options?.source !== "extension") {
                 emitUserActivity(this, "prompt");
+                this._deadlineTracker.clearHold();
+            }
             await this._prompt(text, {
                 ...options,
                 promptDisposition: (disposition) => {
@@ -3643,6 +3687,7 @@ export class AgentSession {
                 return;
             claim.started = started;
             this._promptStartPending = false;
+            this._notifyAdmissionIdle();
             if (!started && claim.joined === true && !this.isStreaming)
                 this._drainJoinedInput();
         };
@@ -4209,8 +4254,10 @@ export class AgentSession {
      * `input` handlers, skill/template expansion, then the recovery-ordered enqueue.
      */
     async _queueUserInput(text, images, behavior, options) {
-        if (options?.source !== "extension")
+        if (options?.source !== "extension") {
             emitUserActivity(this, "prompt");
+            this._deadlineTracker.clearHold();
+        }
         // Check for extension commands (cannot be queued)
         if (text.startsWith("/")) {
             this._throwIfExtensionCommand(text);
@@ -8058,6 +8105,34 @@ export class AgentSession {
             finishReloadWork();
         }
     }
+    /**
+     * Loads or unloads the project's code after the session's project trust changed (Full access left or
+     * re-entered, senpi#3420): rebuilds the runtime exactly like reload(), but nothing can cancel it. No
+     * `session_before_reload` handler runs (a project extension must not keep itself loaded); a prompt
+     * that is being admitted, or a session start in dispatch, is waited out instead of cancelling, and
+     * prompts admitted after that wait for the rebuilt runtime. A reload already in flight sees the trust
+     * epoch move and loads again before it installs anything.
+     */
+    async applyProjectTrustChange() {
+        while (this._promptStartPending || this._sessionStartDispatching) {
+            await new Promise((resolve) => this._admissionIdleWaiters.push(resolve));
+        }
+        const finishReloadWork = this._sessionWorkBarrier.begin();
+        try {
+            await this._rebuildRuntimeForReload();
+        }
+        finally {
+            finishReloadWork();
+        }
+    }
+    _notifyAdmissionIdle() {
+        if (this._promptStartPending || this._sessionStartDispatching)
+            return;
+        const waiters = this._admissionIdleWaiters;
+        this._admissionIdleWaiters = [];
+        for (const resolve of waiters)
+            resolve();
+    }
     async _rebuildRuntimeForReload(options) {
         resetTimings("reload");
         const oldExtensionRunner = this._extensionRunner;
@@ -8076,6 +8151,7 @@ export class AgentSession {
         });
         time("shutdown", "reload");
         const previousDefaultTools = new Set(this._usesDefaultTools ? (this.settingsManager.getDefaultTools() ?? DEFAULT_TOOL_NAMES) : []);
+        let trustEpoch = this.settingsManager.getTrustEpoch();
         await this.settingsManager.reload();
         this._delegatedCompactionKey = undefined;
         // Activate tools newly added to defaultTools. Removed ones stay active, and tools disabled
@@ -8114,6 +8190,14 @@ export class AgentSession {
         await this._resourceLoader.reload({
             settingsAlreadyReloadedFor: this.settingsManager,
         });
+        // The project trust changed while this rebuild ran (senpi#3420): what it loaded matches the old
+        // trust, so it loads again under the current one. Nothing is installed until a load matches the
+        // trust at install time; the check and the install below run in one synchronous step.
+        while (this.settingsManager.getTrustEpoch() !== trustEpoch) {
+            trustEpoch = this.settingsManager.getTrustEpoch();
+            await this.settingsManager.reload();
+            await this._resourceLoader.reload({ settingsAlreadyReloadedFor: this.settingsManager });
+        }
         time("resources", "reload");
         try {
             this._buildRuntime({
@@ -8167,6 +8251,7 @@ export class AgentSession {
             finally {
                 this._sessionStartDispatching = false;
                 settleSessionStart();
+                this._notifyAdmissionIdle();
             }
         }
         time("lifecycle", "reload");

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

@@ -0,0 +1,21 @@
+import type { ResourceDiagnostic } from "./diagnostics.ts";
+export interface ContextFile {
+    path: string;
+    content: string;
+}
+/** Preserve the public array API while returning diagnostics to the owning mode. */
+export type ContextFiles = ContextFile[] & {
+    readonly diagnostics: ResourceDiagnostic[];
+};
+/** Size limits for AGENTS.md / CLAUDE.md context files, which ride along on every model request. */
+export interface ContextFileLimits {
+    maxBytesPerFile?: number;
+    maxTotalBytes?: number;
+}
+export declare const DEFAULT_CONTEXT_FILE_MAX_BYTES: number;
+export declare const DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES: number;
+export declare function loadProjectContextFiles(options: {
+    cwd: string;
+    agentDir: string;
+} & ContextFileLimits): ContextFiles;
+//# sourceMappingURL=context-files.d.ts.map

package/dist/core/context-files.js

@@ -0,0 +1,175 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, sep } from "node:path";
+import chalk from "chalk";
+import { canonicalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
+import { findGitPaths } from "./footer-data-provider.js";
+export const DEFAULT_CONTEXT_FILE_MAX_BYTES = 64 * 1024;
+export const DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES = 128 * 1024;
+const MIN_USEFUL_BYTES = 1024;
+function loadContextFileFromDir(dir) {
+    const candidates = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+    for (const filename of candidates) {
+        const filePath = join(dir, filename);
+        if (existsSync(filePath)) {
+            try {
+                if (!statSync(filePath).isFile()) {
+                    continue;
+                }
+                return {
+                    path: filePath,
+                    content: stripBom(readFileSync(filePath, "utf-8")),
+                };
+            }
+            catch (error) {
+                console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 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
+ * undefined when nothing is shadowed, leaving normal ancestor inheritance alone.
+ *
+ * Returned canonicalized (realpath), because `git worktree add` writes the `.git`
+ * file's `gitdir:` target in realpath form while cwd may still be symlinked
+ * (macOS `/tmp` -> `/private/tmp`).
+ */
+function findShadowedContextFile(cwd) {
+    const gitPaths = findGitPaths(cwd);
+    if (!gitPaths)
+        return undefined;
+    const commonGitDir = canonicalizePath(gitPaths.commonGitDir);
+    const worktreeRoot = canonicalizePath(gitPaths.repoDir);
+    const mainRepoRoot = dirname(commonGitDir);
+    // False for an ordinary repo, where the two are the same dir, and for a sibling
+    // worktree (`git worktree add ../feat`), whose main repo is not an ancestor.
+    if (!worktreeRoot.startsWith(`${mainRepoRoot}${sep}`))
+        return undefined;
+    // dirname of the common git dir is the main worktree root only when that dir is
+    // itself checked out from the same repo. In a bare layout (`proj/.bare` +
+    // `proj/main`) it is just the directory holding `.bare`, which tracks nothing; a
+    // submodule's gitdir has no `commondir`, so it lands under `.git/modules`.
+    if (canonicalizePath(join(mainRepoRoot, ".git")) !== commonGitDir)
+        return undefined;
+    const worktreeContextFile = loadContextFileFromDir(worktreeRoot);
+    return worktreeContextFile ? join(mainRepoRoot, basename(worktreeContextFile.path)) : undefined;
+}
+function kib(bytes) {
+    const value = bytes / 1024;
+    return Number.isInteger(value) ? `${value} KiB` : `${value.toFixed(1)} KiB`;
+}
+function utf8Prefix(content, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    const bytes = Buffer.from(content, "utf8");
+    let end = Math.min(maxBytes, bytes.length);
+    while (end > 0 && end < bytes.length && ((bytes[end] ?? 0) & 0xc0) === 0x80)
+        end--;
+    const newline = bytes.lastIndexOf(10, end - 1);
+    if (newline >= maxBytes * 0.75)
+        end = newline + 1;
+    return bytes.subarray(0, end).toString("utf8");
+}
+function positiveLimit(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+/**
+ * Bound what the context files add to every request. Files are given budget nearest-first
+ * (the cwd's file before its ancestors, the global file last), so the most specific
+ * instructions survive; every cut or skipped file is named in a warning.
+ */
+function applyContextFileLimits(files, limits) {
+    const perFile = positiveLimit(limits.maxBytesPerFile, DEFAULT_CONTEXT_FILE_MAX_BYTES);
+    const total = positiveLimit(limits.maxTotalBytes, DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES);
+    const limitText = `limit ${kib(perFile)} per file, ${kib(total)} total; raise contextFiles.maxBytesPerFile / contextFiles.maxTotalBytes in settings to load more`;
+    const kept = [];
+    const diagnostics = [];
+    let remaining = total;
+    for (const file of [...files].reverse()) {
+        const size = Buffer.byteLength(file.content, "utf8");
+        const allowed = Math.min(perFile, remaining);
+        if (size <= allowed) {
+            kept.unshift(file);
+            remaining -= size;
+            continue;
+        }
+        if (allowed < MIN_USEFUL_BYTES) {
+            const reason = perFile < MIN_USEFUL_BYTES ? "the per-file limit is too small" : "nearer context files used the budget";
+            diagnostics.push({
+                type: "warning",
+                category: "size-limit",
+                path: file.path,
+                message: `Context file (${kib(size)}) was not loaded: ${reason} (${limitText}).`,
+            });
+            continue;
+        }
+        const note = `\n\n[This file was truncated from ${kib(size)}.]`;
+        const contentBudget = allowed - Buffer.byteLength(note);
+        let prefix = utf8Prefix(file.content, contentBudget);
+        let content;
+        while (true) {
+            let openFence;
+            for (const match of prefix.matchAll(/^[ \t]*(`{3,}|~{3,})([^\n]*)$/gm)) {
+                const marker = match[1];
+                if (!marker)
+                    continue;
+                if (openFence === undefined)
+                    openFence = marker;
+                else if (marker[0] === openFence[0] && marker.length >= openFence.length && match[2]?.trim() === "") {
+                    openFence = undefined;
+                }
+            }
+            const closingFence = openFence ? `${prefix.endsWith("\n") ? "" : "\n"}${openFence}\n` : "";
+            content = `${prefix}${closingFence}${note}`;
+            if (Buffer.byteLength(content) <= allowed)
+                break;
+            // A longer closing marker can expose another opener when the prefix shrinks.
+            prefix = utf8Prefix(prefix, Math.max(0, contentBudget - Buffer.byteLength(closingFence)));
+        }
+        const loaded = Buffer.byteLength(prefix, "utf8");
+        diagnostics.push({
+            type: "warning",
+            category: "size-limit",
+            path: file.path,
+            message: `Context file is ${kib(size)}; only the first ${kib(loaded)} was loaded (${limitText}).`,
+        });
+        kept.unshift({
+            path: file.path,
+            content,
+        });
+        remaining -= Buffer.byteLength(content);
+    }
+    return Object.assign(kept, { diagnostics });
+}
+export function loadProjectContextFiles(options) {
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvedAgentDir);
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const ancestorContextFiles = [];
+    const shadowedContextFile = findShadowedContextFile(resolvedCwd);
+    let currentDir = resolvedCwd;
+    while (true) {
+        const contextFile = loadContextFileFromDir(currentDir);
+        const isShadowed = shadowedContextFile !== undefined && canonicalizePath(contextFile?.path ?? "") === shadowedContextFile;
+        if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    return applyContextFileLimits(contextFiles, options);
+}
+//# sourceMappingURL=context-files.js.map

package/dist/core/diagnostics.d.ts

@@ -8,6 +8,7 @@ export interface ResourceCollision {
 }
 export interface ResourceDiagnostic {
     type: "warning" | "error" | "collision";
+    category?: "size-limit";
     message: string;
     path?: string;
     collision?: ResourceCollision;

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

@@ -1,6 +1,9 @@
 import type { AvailableTool, PromptSurface } from "./types.ts";
+export declare const DEFAULT_ROUTING_LINE_RULE = "The line keeps your reading transparent";
 export declare function buildIntentGate(config: {
     tools: AvailableTool[];
     surface?: PromptSurface;
+    /** Terminal-only: the clause before "only the user's explicit request commits you"; presets replace it. */
+    routingLineRule?: string;
 }): string;
 //# sourceMappingURL=intent-gate.d.ts.map

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

@@ -6,16 +6,17 @@ 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`;
 }
-const TERMINAL_ROUTING = `Open every turn with one short routing line:
+export const DEFAULT_ROUTING_LINE_RULE = "The 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].
 
-The line keeps your reading transparent; 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.`;
+${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.`;
 export function buildIntentGate(config) {
     return `## Intent Gate
 
-${(config.surface ?? "terminal") === "terminal" ? TERMINAL_ROUTING : APP_ROUTING}
+${(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.

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

@@ -1,2 +1,5 @@
-export declare function buildPoliciesSection(): string;
+export declare const DEFAULT_ERROR_RULE = "Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.";
+export declare function buildPoliciesSection(options?: {
+    errorRule?: string;
+}): string;
 //# sourceMappingURL=policies.d.ts.map

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

@@ -1,11 +1,12 @@
-export function buildPoliciesSection() {
+export const DEFAULT_ERROR_RULE = "Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.";
+export function buildPoliciesSection(options = {}) {
     return `## Policies
 
 ### 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.
-- Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.
+- ${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.`;
 }
 //# sourceMappingURL=policies.js.map

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

@@ -1,2 +1,5 @@
-export declare function buildWorkingTaskSection(): string;
+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 function buildWorkingTaskSection(options?: {
+    opening?: string;
+}): string;
 //# sourceMappingURL=working-task.d.ts.map

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

@@ -1,7 +1,8 @@
-export function buildWorkingTaskSection() {
+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 function buildWorkingTaskSection(options = {}) {
     return `## Working the Task
 
-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.
+${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.
 

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

@@ -18,10 +18,11 @@ export interface WorkstationFacts {
  * Families follow the prompt-preset conventions: Claude/GLM take direct
  * imperatives in a tagged block, GPT (codex) takes terse bounded rules, Kimi
  * takes positive operational constraints (all-caps directives make K2.x
- * overthink), and `default` is the maximum-emphasis fallback for unmatched
- * models.
+ * overthink), the `gemini` dialect takes one plain sentence pair (the
+ * provider's guidance: direct instructions, no persuasive emphasis), and `default` is
+ * the maximum-emphasis fallback for unmatched models.
  */
-export type WorkstationDialect = "default" | "claude" | "codex" | "kimi";
+export type WorkstationDialect = "default" | "claude" | "codex" | "kimi" | "gemini";
 /** Collect host facts once per process; every call after the first is free. */
 export declare function collectWorkstationFacts(): WorkstationFacts;
 export interface BuildWorkstationSectionOptions {

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

@@ -62,6 +62,7 @@ ${executors} on THIS workstation. Match commands, paths, package managers, and p
 </execution_context>`,
     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.`,
 };
 /** Render the `<workstation>` facts block plus the dialect-tuned execution-context instruction. */

package/dist/core/extensions/builtin/anthropic-subscription/account-command.js

@@ -3,7 +3,7 @@ import { describeModelBlocks } from "../../../credential-pool/model-scope.js";
 import { accountDisplayNameCommand, promptAccountDisplayName } from "../account-display-name.js";
 import { createExtensionLoginInteraction, LOGIN_CANCELLED_MESSAGE } from "../oauth-login-interaction.js";
 import { emitProviderAccountsChanged } from "./account-events.js";
-import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, pinProviderAccount, removeProviderAccount } from "./account-management.js";
+import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, pinProviderAccount, removeProviderAccount, unblockProviderAccount, } from "./account-management.js";
 import { emptyCredential, listAccounts } from "./accounts.js";
 import { selectAccount } from "./affinity.js";
 import { loadAnthropicSubscriptionProviderSettingsFromDisk, } from "./settings.js";
@@ -65,7 +65,7 @@ export function registerClaudeAccountCommand(pi, deps = {}) {
     });
     pi.registerCommand("claude-account", {
         description: "List and manage Anthropic Subscription accounts.",
-        argumentHint: "[add | remove <id> | pin <id> | unpin | rename <id> <display name...> | clear-name <id>]",
+        argumentHint: "[add | remove <id> | pin <id> | unpin | unblock <id> | rename <id> <display name...> | clear-name <id>]",
         requiresArguments: false,
         handler: async (rawArgs, ctx) => {
             if (await accountDisplayNameCommand(ctx, ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, rawArgs))
@@ -92,7 +92,11 @@ export function registerClaudeAccountCommand(pi, deps = {}) {
                 await unpinAccount(ctx);
                 return;
             }
-            ctx.ui.notify("Usage: /claude-account [add | remove <id> | pin <id> | unpin | rename <id> <display name...> | clear-name <id>]", "error");
+            if (action === "unblock") {
+                await unblockNamedAccount(ctx, args[1], environment);
+                return;
+            }
+            ctx.ui.notify("Usage: /claude-account [add | remove <id> | pin <id> | unpin | unblock <id> | rename <id> <display name...> | clear-name <id>]", "error");
         },
     });
 }
@@ -194,6 +198,25 @@ async function pinNamedAccount(ctx, name, environment) {
         ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
     }
 }
+async function unblockNamedAccount(ctx, name, environment) {
+    if (!name) {
+        ctx.ui.notify("Usage: /claude-account unblock <name>", "error");
+        return;
+    }
+    if (!readAccounts(ctx, environment).accounts.some((account) => account.name === name)) {
+        return accountError(ctx, name);
+    }
+    try {
+        const env = new Proxy({}, { get: (_target, key) => environment(String(key)) });
+        const lifted = await unblockProviderAccount(ctx.modelRegistry.authStorage, ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, name, env);
+        ctx.ui.notify(lifted
+            ? `Unblocked Anthropic Subscription account: ${name}. The next turn may use it.`
+            : `Anthropic Subscription account '${name}' has no usage block to lift.`, "info");
+    }
+    catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+    }
+}
 async function unpinAccount(ctx) {
     const credential = asCredential(ctx.modelRegistry.authStorage.get(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID));
     if (!credential?.pinned) {

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

@@ -11,4 +11,9 @@ export type ProviderAccountSummary = {
 export declare function getProviderAccounts(storage: AuthStorage, provider: string, env?: NodeJS.ProcessEnv): ProviderAccountSummary[];
 export declare function pinProviderAccount(storage: AuthStorage, provider: string, name: string | null, env?: NodeJS.ProcessEnv): Promise<void>;
 export declare function removeProviderAccount(storage: AuthStorage, provider: string, name: string): Promise<void>;
+/**
+ * Lifts a usage or rate-limit block the user knows is wrong (extra usage bought, a misread reset).
+ * Auth blocks stay: only a login or the re-probe can lift those. Returns whether a block was lifted.
+ */
+export declare function unblockProviderAccount(storage: AuthStorage, provider: string, name: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
 //# sourceMappingURL=account-management.d.ts.map