@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/engine/file-history-hook.d.ts

@@ -0,0 +1,11 @@
+import type { HookRegistry } from "../hooks/registry.js";
+import type { RunScopedDisposer } from "./run-types.js";
+import type { CapabilityFileHistoryContribution } from "../capabilities/index.js";
+export interface RegisterFileHistoryHookOptions {
+    hooks: Pick<HookRegistry, "register" | "unregister">;
+    sessionDir: string;
+    cwd: string;
+    getTurnSeq: () => number | undefined;
+    contributions?: readonly CapabilityFileHistoryContribution[];
+}
+export declare function registerFileHistoryHook(options: RegisterFileHistoryHookOptions): RunScopedDisposer;

package/dist/engine/file-history-hook.js

@@ -0,0 +1,31 @@
+import { FileHistory } from "../session/file-history.js";
+export function registerFileHistoryHook(options) {
+    const history = FileHistory.loadFromDir(options.sessionDir);
+    const handler = async (context) => {
+        const toolName = context.data?.toolName;
+        const args = context.data?.args;
+        const turnSeq = options.getTurnSeq();
+        if ((toolName === "Write" || toolName === "Edit") && typeof args?.file_path === "string") {
+            if (history.saveSnapshot(args.file_path, turnSeq) === null && turnSeq !== undefined) {
+                history.recordCreated(args.file_path, turnSeq);
+            }
+        }
+        else if (args) {
+            const contribution = options.contributions?.find((item) => item.toolName === toolName);
+            for (const target of contribution?.resolveTargets(args, options.cwd) ?? []) {
+                history.saveSnapshot(target, turnSeq);
+            }
+        }
+        return {};
+    };
+    options.hooks.register("on_tool_start", handler, 100, "file_history_backup");
+    let disposed = false;
+    return {
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            options.hooks.unregister("on_tool_start", handler);
+        },
+    };
+}

package/dist/engine/goal-judge-context.d.ts

@@ -0,0 +1,9 @@
+import type { GoalJudgeRuntimeContext } from "../hooks/goal-stop-hook.js";
+import type { Message } from "../types.js";
+export interface BuildGoalJudgeContextOptions {
+    maxRounds?: number;
+    maxEstimatedTokens?: number;
+    maxChars?: number;
+    sensitiveToolResultRedactions?: ReadonlyMap<string, string>;
+}
+export declare function buildGoalJudgeRuntimeContext(messages: readonly Message[], options?: BuildGoalJudgeContextOptions): GoalJudgeRuntimeContext;

package/dist/engine/goal-judge-context.js

@@ -0,0 +1,234 @@
+import { createHash } from "node:crypto";
+import { estimateTokens, groupMessagesByApiRound } from "../context/compaction.js";
+import { sanitizeMessages } from "../logging/sanitize-messages.js";
+import { scrubSecrets, scrubSecretValue } from "../utils/secret-scrubber.js";
+const DEFAULT_MAX_ROUNDS = 6;
+const DEFAULT_MAX_ESTIMATED_TOKENS = 3_000;
+const DEFAULT_MAX_CHARS = 12_000;
+function sanitizeNestedBlocks(blocks) {
+    return blocks.map((block) => {
+        if (block.type === "reasoning") {
+            return { type: "reasoning", text: "[reasoning omitted]" };
+        }
+        if (block.type === "image" && block.source?.type === "base64") {
+            return {
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: block.source.media_type,
+                    bytes: block.source.data?.length ?? 0,
+                    omitted: true,
+                },
+            };
+        }
+        if (block.type === "tool_result" && Array.isArray(block.content)) {
+            return scrubSecretValue({
+                ...block,
+                content: sanitizeNestedBlocks(block.content),
+            });
+        }
+        return scrubSecretValue({ ...block });
+    });
+}
+function sanitizeConversation(messages, sensitiveToolResultRedactions) {
+    return sanitizeMessages(messages, { sensitiveToolResultRedactions }).map((message) => ({
+        ...message,
+        content: typeof message.content === "string"
+            ? scrubSecrets(message.content)
+            : sanitizeNestedBlocks(message.content),
+    }));
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    }
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? "null" : serialized;
+}
+function renderBlock(block, role) {
+    const roleLabel = role.toUpperCase();
+    if (block.type === "text")
+        return `${roleLabel}:\n${block.text ?? ""}`;
+    if (block.type === "reasoning")
+        return `${roleLabel}:\n[reasoning omitted]`;
+    if (block.type === "tool_use") {
+        return `${roleLabel} TOOL_USE id=${block.id ?? "(missing)"} name=${block.name ?? "(missing)"} input=${stableJson(block.input ?? {})}`;
+    }
+    if (block.type === "tool_result") {
+        const content = Array.isArray(block.content)
+            ? block.content.map((entry) => renderBlock(entry, role)).join("\n")
+            : (block.content ?? "");
+        return `TOOL_RESULT tool_use_id=${block.tool_use_id ?? "(missing)"} error=${block.is_error === true}:\n${content}`;
+    }
+    if (block.type === "image") {
+        const source = block.source;
+        return `${roleLabel} IMAGE media_type=${source?.media_type ?? "unknown"} bytes=${source?.bytes ?? 0} omitted=true`;
+    }
+    return `${roleLabel}:\n[unsupported content omitted]`;
+}
+function renderConversation(rounds) {
+    if (rounds.length === 0)
+        return "(无最近对话)";
+    return rounds
+        .map((round, index) => {
+        const renderedMessages = round.map((message) => {
+            if (typeof message.content === "string") {
+                return `${message.role.toUpperCase()}:\n${message.content}`;
+            }
+            return message.content.map((block) => renderBlock(block, message.role)).join("\n");
+        });
+        return `[round ${index + 1}]\n${renderedMessages.join("\n")}`;
+    })
+        .join("\n\n");
+}
+function truncationMarker(originalChars) {
+    return `[truncated for goal judge; originalChars=${originalChars}]`;
+}
+function truncateString(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    const marker = truncationMarker(value.length);
+    if (maxChars <= marker.length)
+        return marker;
+    return `${value.slice(0, maxChars - marker.length)}${marker}`;
+}
+function truncateUnknown(value, maxChars) {
+    if (typeof value === "string")
+        return truncateString(value, maxChars);
+    if (Array.isArray(value))
+        return value.map((entry) => truncateUnknown(entry, maxChars));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            truncateUnknown(entry, maxChars),
+        ]));
+    }
+    return value;
+}
+function truncateBlock(block, maxChars) {
+    if (block.type === "text")
+        return { ...block, text: truncateString(block.text ?? "", maxChars) };
+    if (block.type === "tool_use") {
+        return {
+            ...block,
+            input: truncateUnknown(block.input ?? {}, maxChars),
+        };
+    }
+    if (block.type === "tool_result") {
+        return {
+            ...block,
+            content: Array.isArray(block.content)
+                ? block.content.map((entry) => truncateBlock(entry, maxChars))
+                : truncateString(block.content ?? "", maxChars),
+        };
+    }
+    return { ...block };
+}
+function emergencyTruncate(round, maxChars, maxTokens) {
+    let fieldBudget = Math.max(48, Math.floor(maxChars / 3));
+    let candidate = round;
+    for (let attempt = 0; attempt < 16; attempt++) {
+        candidate = round.map((message) => ({
+            ...message,
+            content: typeof message.content === "string"
+                ? truncateString(message.content, fieldBudget)
+                : message.content.map((block) => truncateBlock(block, fieldBudget)),
+        }));
+        if (renderConversation([candidate]).length <= maxChars &&
+            estimateTokens(candidate) <= maxTokens) {
+            return candidate;
+        }
+        fieldBudget = Math.max(0, Math.floor(fieldBudget / 2));
+    }
+    return candidate;
+}
+function structuralFallback(round, maxChars, maxTokens) {
+    const perMessageBudget = Math.max(0, Math.floor(maxChars / Math.max(1, round.length)) - 32);
+    const candidate = round.map((message) => {
+        if (typeof message.content === "string") {
+            return { ...message, content: truncateString(message.content, perMessageBudget) };
+        }
+        const text = message.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text ?? "")
+            .join("\n");
+        const blocks = [];
+        if (text)
+            blocks.push({ type: "text", text: truncateString(text, perMessageBudget) });
+        for (const block of message.content) {
+            if (block.type === "text")
+                continue;
+            if (block.type === "tool_use") {
+                blocks.push({ ...block, input: {} });
+            }
+            else if (block.type === "tool_result") {
+                blocks.push({ ...block, content: "" });
+            }
+            else {
+                blocks.push({ ...block });
+            }
+        }
+        return { ...message, content: blocks };
+    });
+    return renderConversation([candidate]).length <= maxChars && estimateTokens(candidate) <= maxTokens
+        ? candidate
+        : [];
+}
+export function buildGoalJudgeRuntimeContext(messages, options = {}) {
+    const maxRounds = Math.max(1, options.maxRounds ?? DEFAULT_MAX_ROUNDS);
+    const maxEstimatedTokens = Math.max(1, options.maxEstimatedTokens ?? DEFAULT_MAX_ESTIMATED_TOKENS);
+    const maxChars = Math.max(1, options.maxChars ?? DEFAULT_MAX_CHARS);
+    const sanitized = sanitizeConversation(messages, options.sensitiveToolResultRedactions);
+    const allRounds = groupMessagesByApiRound(sanitized);
+    let selected = allRounds.slice(-maxRounds);
+    let truncated = selected.length !== allRounds.length;
+    while (selected.length > 1) {
+        const conversation = selected.flat();
+        if (estimateTokens(conversation) <= maxEstimatedTokens &&
+            renderConversation(selected).length <= maxChars) {
+            break;
+        }
+        selected = selected.slice(1);
+        truncated = true;
+    }
+    if (selected.length === 1) {
+        const conversation = selected[0];
+        if (estimateTokens(conversation) > maxEstimatedTokens ||
+            renderConversation(selected).length > maxChars) {
+            selected = [emergencyTruncate(conversation, maxChars, maxEstimatedTokens)];
+            truncated = true;
+            if (estimateTokens(selected[0]) > maxEstimatedTokens ||
+                renderConversation(selected).length > maxChars) {
+                const fallback = structuralFallback(conversation, maxChars, maxEstimatedTokens);
+                selected = fallback.length > 0 ? [fallback] : [];
+            }
+        }
+    }
+    let conversation = selected.flat();
+    let renderedConversation = renderConversation(selected);
+    // Absolute postcondition: even pathological structural overhead must not
+    // escape the advertised hard limits. The ellipsis is deterministic and the
+    // empty conversation has zero estimated tokens.
+    if (renderedConversation.length > maxChars ||
+        estimateTokens(conversation) > maxEstimatedTokens) {
+        selected = [];
+        conversation = [];
+        renderedConversation = "…".slice(0, maxChars);
+        truncated = true;
+    }
+    return {
+        conversation,
+        renderedConversation,
+        digest: createHash("sha256").update(renderedConversation).digest("hex").slice(0, 16),
+        selectedRoundCount: selected.length,
+        sourceRoundCount: allRounds.length,
+        estimatedTokens: estimateTokens(conversation),
+        chars: renderedConversation.length,
+        truncated,
+    };
+}

package/dist/engine/injected-context-cache.d.ts

@@ -0,0 +1,6 @@
+import type { Message } from "../types.js";
+/**
+ * Remove run-scoped context messages before caching the durable conversation.
+ * Identity checks are intentional: equal user-authored content must survive.
+ */
+export declare function stripInjectedContextMessages(messages: Message[], userContextMsg: Message | null, dynamicContextMsg: Message | null): Message[];

package/dist/engine/injected-context-cache.js

@@ -0,0 +1,13 @@
+/**
+ * Remove run-scoped context messages before caching the durable conversation.
+ * Identity checks are intentional: equal user-authored content must survive.
+ */
+export function stripInjectedContextMessages(messages, userContextMsg, dynamicContextMsg) {
+    const withoutDynamicContext = dynamicContextMsg
+        ? messages.filter((message) => message !== dynamicContextMsg)
+        : [...messages];
+    if (!userContextMsg || messages[0] !== userContextMsg) {
+        return withoutDynamicContext;
+    }
+    return withoutDynamicContext.slice(1);
+}

package/dist/engine/input-attachments.d.ts

@@ -1,4 +1,4 @@
-import type { InputAttachmentMeta } from "../protocol/types.js";
+import type { InputAttachmentMeta } from "../types.js";
 import type { ParsedImage } from "./parse-task.js";
 export interface InputAttachmentContext {
     text: string;

package/dist/engine/model-facade.d.ts

@@ -4,6 +4,7 @@
 import type { LLMClientBase } from "../llm/client-base.js";
 import type { Message, ToolDefinition, LLMResponse, StreamCallback } from "../types.js";
 import { Transcript } from "../session/transcript.js";
+import { type PromptPrefixFingerprint } from "./prompt-cache-diagnostics.js";
 export interface ModelCallRecordingOptions {
     sensitiveToolResultRedactions?: ReadonlyMap<string, string>;
 }
@@ -21,15 +22,14 @@ export declare class ModelFacade {
     private readonly client;
     private readonly transcript;
     constructor(client: LLMClientBase, transcript: Transcript);
+    getPromptPrefixFingerprint(systemPrompt: string, tools: readonly ToolDefinition[]): PromptPrefixFingerprint;
     call(systemPrompt: string, messages: Message[], tools: ToolDefinition[], onStream?: StreamCallback, signal?: AbortSignal, recordingOptions?: ModelCallRecordingOptions): Promise<LLMResponse>;
     /**
      * Call without streaming — used as fallback when streaming fails.
      */
     callWithoutStreaming(systemPrompt: string, messages: Message[], tools: ToolDefinition[], signal?: AbortSignal, recordingOptions?: ModelCallRecordingOptions): Promise<LLMResponse>;
-    /** Record API timing and token usage to bootstrap state. */
-    private recordUsage;
     /** Optional summarize function for tool use summaries. */
-    summarize?: (systemPrompt: string, userMessage: string) => Promise<string>;
+    summarize?: (systemPrompt: string, userMessage: string, signal?: AbortSignal) => Promise<string>;
     /** Get cumulative output tokens (for token budget). */
     getOutputTokens?(): number;
     private recordResponse;

package/dist/engine/model-facade.js

@@ -4,8 +4,8 @@
 import { logger, getCurrentSid } from "../logging/logger.js";
 import { recordLLMError, recordLLMRequest, recordLLMResponse, } from "../logging/session-recorder.js";
 import { sanitizeMessages } from "../logging/sanitize-messages.js";
-import { addAPIDuration, addToModelUsage, addInputTokens, addOutputTokens } from "../state.js";
-import { cacheHitRateFromUsage } from "./session-usage.js";
+import { cacheHitRateFromUsage } from "../session/usage.js";
+import { createPromptPrefixFingerprint, } from "./prompt-cache-diagnostics.js";
 let _reqSeq = 0;
 function nextReqId() {
     _reqSeq += 1;
@@ -30,6 +30,15 @@ export class ModelFacade {
         this.client = client;
         this.transcript = transcript;
     }
+    getPromptPrefixFingerprint(systemPrompt, tools) {
+        const client = this.client;
+        const fallbackIdentity = {
+            provider: client.provider ?? "unknown",
+            model: client.model ?? "unknown",
+            identityVersion: "legacy-client-v1",
+        };
+        return createPromptPrefixFingerprint(systemPrompt, tools, client.getPromptCacheConfigIdentity?.() ?? fallbackIdentity, client.getPromptCacheScopeIdentity?.() ?? fallbackIdentity);
+    }
     async call(systemPrompt, messages, tools, onStream, signal, recordingOptions) {
         const startMs = Date.now();
         const msgCount = messages.length;
@@ -87,6 +96,7 @@ export class ModelFacade {
             throw err;
         }
         const latencyMs = Date.now() - startMs;
+        const promptPrefix = this.getPromptPrefixFingerprint(systemPrompt, tools);
         logger.info("llm.request", {
             stream: true,
             latencyMs,
@@ -96,6 +106,7 @@ export class ModelFacade {
             textLen: response.text?.length ?? 0,
             usage: response.usage,
             cacheHitRate: cacheHitRate(response.usage),
+            promptPrefix,
         });
         recordLLMResponse(sid, {
             text: response.text,
@@ -104,7 +115,6 @@ export class ModelFacade {
             usage: response.usage,
             durationMs: latencyMs,
         }, reqId);
-        this.recordUsage(response, latencyMs);
         this.recordResponse(response);
         return response;
     }
@@ -141,6 +151,7 @@ export class ModelFacade {
             throw err;
         }
         const latencyMs = Date.now() - startMs;
+        const promptPrefix = this.getPromptPrefixFingerprint(systemPrompt, tools);
         logger.info("llm.request", {
             stream: false,
             latencyMs,
@@ -150,6 +161,7 @@ export class ModelFacade {
             textLen: response.text?.length ?? 0,
             usage: response.usage,
             cacheHitRate: cacheHitRate(response.usage),
+            promptPrefix,
         });
         recordLLMResponse(sid, {
             text: response.text,
@@ -158,20 +170,9 @@ export class ModelFacade {
             usage: response.usage,
             durationMs: latencyMs,
         }, reqId);
-        this.recordUsage(response, latencyMs);
         this.recordResponse(response);
         return response;
     }
-    /** Record API timing and token usage to bootstrap state. */
-    recordUsage(response, latencyMs) {
-        addAPIDuration(latencyMs);
-        const u = response.usage;
-        if (u) {
-            addInputTokens(u.promptTokens ?? 0);
-            addOutputTokens(u.completionTokens ?? 0);
-            addToModelUsage(this.client.model ?? "unknown", u.promptTokens ?? 0, u.completionTokens ?? 0, u.cacheReadTokens ?? 0, u.cacheCreationTokens ?? 0);
-        }
-    }
     /** Optional summarize function for tool use summaries. */
     summarize;
     recordResponse(response) {

package/dist/engine/permission-controller.d.ts

@@ -0,0 +1,55 @@
+import type { PermissionRule } from "../types.js";
+import { type ApprovalBackend, type ApprovalRouter, type PermissionClassifier } from "../tool-system/permission.js";
+import type { EngineConfig } from "./types.js";
+type PermissionMode = NonNullable<EngineConfig["permissionMode"]>;
+export interface ComposePermissionRulesOptions {
+    mode: PermissionMode;
+    cwd: string;
+    presetRules: readonly PermissionRule[];
+    settingsScope?: EngineConfig["settingsScope"];
+    projectTrusted?: boolean;
+}
+/**
+ * Compose the permission rule list for a session: preset rules, the standing
+ * memory-scope carve-outs, mode-derived rules, and finally the user's own
+ * `settings.permissions.rules` at highest precedence.
+ *
+ * Extracted from {@link PermissionController.build} so that a non-Engine caller
+ * — notably `SessionToolHost`, which exposes tools to an external Agent Runtime
+ * — composes rules the SAME way instead of being handed the obligation and
+ * silently getting it wrong. That mattered concretely: a user rule denying a
+ * tool lives only in settings, so a path that skips this leaves the user's
+ * explicit "no" unenforced for the external runtime while the Native Engine
+ * honors it.
+ */
+export declare function composePermissionRules(options: ComposePermissionRulesOptions): PermissionRule[];
+export declare class PermissionController {
+    private readonly deps;
+    private mode;
+    private inPlanMode;
+    private pendingMode;
+    private pendingPlanMode;
+    private activePermission;
+    private activeApprovalRouter;
+    private readonly interactiveBackends;
+    constructor(deps: {
+        config: () => EngineConfig;
+        updateConfig: (next: EngineConfig) => void;
+        presetRules: () => PermissionRule[];
+        runInProgress: () => boolean;
+    });
+    get permissionMode(): PermissionMode;
+    get planMode(): boolean;
+    attach(permission: PermissionClassifier, approvalRouter?: ApprovalRouter): void;
+    build(mode: PermissionMode, cwd: string, approvalRouter?: ApprovalRouter): {
+        rules: PermissionRule[];
+        backend: ApprovalBackend;
+    };
+    setPermissionMode(mode: PermissionMode): void;
+    applyPending(): void;
+    getPermissionMode(): PermissionMode;
+    getPermissionRules(): PermissionRule[];
+    setPlanMode(value: boolean): void;
+    private apply;
+}
+export {};

package/dist/engine/permission-controller.js

@@ -0,0 +1,148 @@
+import { SettingsManager } from "../settings/manager.js";
+import { AutoApprovalBackend, HeadlessApprovalBackend, InteractiveApprovalBackend, getInteractiveApprovalBackend, } from "../tool-system/permission.js";
+/**
+ * Compose the permission rule list for a session: preset rules, the standing
+ * memory-scope carve-outs, mode-derived rules, and finally the user's own
+ * `settings.permissions.rules` at highest precedence.
+ *
+ * Extracted from {@link PermissionController.build} so that a non-Engine caller
+ * — notably `SessionToolHost`, which exposes tools to an external Agent Runtime
+ * — composes rules the SAME way instead of being handed the obligation and
+ * silently getting it wrong. That mattered concretely: a user rule denying a
+ * tool lives only in settings, so a path that skips this leaves the user's
+ * explicit "no" unenforced for the external runtime while the Native Engine
+ * honors it.
+ */
+export function composePermissionRules(options) {
+    const { mode, cwd } = options;
+    const rules = [...options.presetRules];
+    rules.push({
+        tool: "MemorySave",
+        argsPattern: { scope: "^dream$" },
+        decision: "allow",
+        reason: "Dream scope is the LLM's auto-consolidation workspace",
+    });
+    rules.push({
+        tool: "MemoryDelete",
+        argsPattern: { scope: "^dream$" },
+        decision: "allow",
+        reason: "Dream scope is the LLM's auto-consolidation workspace",
+    });
+    if (mode === "acceptEdits" || mode === "bypassPermissions") {
+        rules.push({ tool: "Write", decision: "allow" });
+        rules.push({ tool: "Edit", decision: "allow" });
+    }
+    if (mode === "bypassPermissions")
+        rules.push({ tool: "Bash", decision: "allow" });
+    try {
+        const settings = new SettingsManager(cwd, options.settingsScope ?? "project", options.projectTrusted !== false).get();
+        // unshift: the user's own rules outrank every default.
+        if (settings.permissions?.rules?.length)
+            rules.unshift(...settings.permissions.rules);
+    }
+    catch {
+        // Settings are optional; preset and mode defaults remain usable.
+    }
+    return rules;
+}
+export class PermissionController {
+    deps;
+    mode;
+    inPlanMode;
+    pendingMode = null;
+    pendingPlanMode = null;
+    activePermission;
+    activeApprovalRouter;
+    interactiveBackends = new WeakMap();
+    constructor(deps) {
+        this.deps = deps;
+        this.mode = deps.config().permissionMode ?? "acceptEdits";
+        this.inPlanMode = this.mode === "plan";
+    }
+    get permissionMode() {
+        return this.mode;
+    }
+    get planMode() {
+        return this.inPlanMode;
+    }
+    attach(permission, approvalRouter) {
+        this.activePermission = permission;
+        this.activeApprovalRouter = approvalRouter;
+    }
+    build(mode, cwd, approvalRouter) {
+        const config = this.deps.config();
+        const rules = composePermissionRules({
+            mode,
+            cwd,
+            presetRules: this.deps.presetRules(),
+            settingsScope: config.settingsScope,
+            projectTrusted: config.projectTrusted,
+        });
+        if (config.approvalBackend) {
+            return {
+                rules,
+                backend: mode === "auto"
+                    ? new AutoApprovalBackend(config.approvalBackend)
+                    : config.approvalBackend,
+            };
+        }
+        if (mode === "auto")
+            return { rules, backend: new AutoApprovalBackend() };
+        let interactive;
+        if (approvalRouter) {
+            interactive =
+                this.interactiveBackends.get(approvalRouter) ??
+                    new InteractiveApprovalBackend(approvalRouter);
+            this.interactiveBackends.set(approvalRouter, interactive);
+        }
+        else {
+            interactive = getInteractiveApprovalBackend();
+        }
+        const backend = interactive.hasPromptFn()
+            ? interactive
+            : new HeadlessApprovalBackend(mode === "bypassPermissions" ? "approve-all" : "deny-all");
+        return { rules, backend };
+    }
+    setPermissionMode(mode) {
+        if (this.deps.runInProgress()) {
+            this.pendingMode = mode;
+            this.pendingPlanMode = mode === "plan";
+            return;
+        }
+        this.apply(mode, mode === "plan");
+    }
+    applyPending() {
+        if (this.pendingMode === null)
+            return;
+        const mode = this.pendingMode;
+        const planMode = this.pendingPlanMode ?? mode === "plan";
+        this.pendingMode = null;
+        this.pendingPlanMode = null;
+        this.apply(mode, planMode);
+    }
+    getPermissionMode() {
+        return this.deps.config().permissionMode ?? "acceptEdits";
+    }
+    getPermissionRules() {
+        const config = this.deps.config();
+        return this.build(this.getPermissionMode(), config.cwd ?? process.cwd(), this.activeApprovalRouter).rules;
+    }
+    setPlanMode(value) {
+        if (value) {
+            this.setPermissionMode("plan");
+        }
+        else if ((this.pendingMode ?? this.mode) === "plan") {
+            this.setPermissionMode("acceptEdits");
+        }
+    }
+    apply(mode, planMode) {
+        const config = { ...this.deps.config(), permissionMode: mode };
+        this.deps.updateConfig(config);
+        this.mode = mode;
+        this.inPlanMode = planMode;
+        if (!this.activePermission)
+            return;
+        const { rules, backend } = this.build(mode, config.cwd ?? process.cwd(), this.activeApprovalRouter);
+        this.activePermission.reconfigure(mode, backend, rules);
+    }
+}