@co0ontty/wand 3.1.1 → 4.0.0

package/dist/models.js

@@ -1,16 +1,27 @@
-import { exec } from "node:child_process";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import Anthropic from "@anthropic-ai/sdk";
+import { buildChildEnv } from "./env-utils.js";
 import { extractSemver } from "./version-utils.js";
-const execAsync = promisify(exec);
-const CLAUDE_MODELS = [
-    { id: "default", label: "Sonnet 4.6 · claude-sonnet-4-6（Claude Code 默认）", alias: true },
-    { id: "opus", label: "opus（最新 Opus）", alias: true },
-    { id: "sonnet", label: "sonnet（最新 Sonnet）", alias: true },
-    { id: "haiku", label: "haiku（最新 Haiku）", alias: true },
-    { id: "claude-opus-4-7", label: "Opus 4.7 · claude-opus-4-7" },
-    { id: "claude-opus-4-6", label: "Opus 4.6 · claude-opus-4-6" },
-    { id: "claude-sonnet-4-6", label: "Sonnet 4.6 · claude-sonnet-4-6" },
-    { id: "claude-haiku-4-5-20251001", label: "Haiku 4.5 · claude-haiku-4-5-20251001" },
+const execFileAsync = promisify(execFile);
+const CLAUDE_VERIFICATION_CACHE_KEY = "claude-model-verifications-v1";
+const CLAUDE_VERIFICATION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const CLAUDE_PROBE_TIMEOUT_MS = 15_000;
+const MAX_CLAUDE_MODEL_PROBES = 12;
+const CLAUDE_PROBE_CONCURRENCY = 3;
+const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const CLAUDE_BUILTIN_MODELS = [
+    {
+        id: "default",
+        label: "跟随 Claude Code 默认",
+        alias: true,
+        source: "builtin",
+        availability: "default",
+        note: "不传 --model 参数",
+    },
+    { id: "opus", label: "opus（最新 Opus）", alias: true, source: "builtin", availability: "candidate" },
+    { id: "sonnet", label: "sonnet（最新 Sonnet）", alias: true, source: "builtin", availability: "candidate" },
+    { id: "haiku", label: "haiku（最新 Haiku）", alias: true, source: "builtin", availability: "candidate" },
 ];
 const CODEX_FALLBACK_MODELS = [
     { id: "default", label: "GPT-5.5 · gpt-5.5（Codex 默认）", alias: true },
@@ -19,40 +30,295 @@ const OPENCODE_FALLBACK_MODELS = [
     { id: "default", label: "跟随 OpenCode 默认", alias: true },
 ];
 let cache = null;
-function cloneClaudeModels() {
-    return CLAUDE_MODELS.map((m) => ({ ...m }));
+function cloneModels(models) {
+    return models.map((model) => ({ ...model }));
 }
-async function probeClaudeVersion() {
+function defaultCommandRunner(file, args, options) {
+    return execFileAsync(file, args, {
+        env: options.env,
+        timeout: options.timeout,
+        maxBuffer: 1024 * 1024,
+    }).then(({ stdout, stderr }) => ({ stdout: String(stdout), stderr: String(stderr) }));
+}
+function resolveProbeEnv(options) {
+    return options.env ?? buildChildEnv(options.inheritEnv !== false);
+}
+function normalizeClaudeModelId(value) {
+    if (typeof value !== "string")
+        return null;
+    const id = value.trim();
+    return MODEL_ID_PATTERN.test(id) ? id : null;
+}
+function formatClaudeModelLabel(id, displayName) {
+    const name = displayName?.trim();
+    return name && name !== id ? `${name} · ${id}` : id;
+}
+function sourcePriority(source) {
+    switch (source) {
+        case "configured": return 4;
+        case "verified-cache": return 3;
+        case "models-api": return 2;
+        case "builtin": return 1;
+    }
+}
+function loadClaudeVerifications(storage) {
+    if (!storage)
+        return [];
+    const raw = storage.getConfigValue(CLAUDE_VERIFICATION_CACHE_KEY);
+    if (!raw)
+        return [];
     try {
-        const { stdout } = await execAsync("claude --version", { timeout: 5000 });
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !Array.isArray(parsed.models))
+            return [];
+        const seen = new Set();
+        const models = [];
+        for (const entry of parsed.models) {
+            const id = normalizeClaudeModelId(entry?.id);
+            if (!id || seen.has(id) || typeof entry?.verifiedAt !== "string" || Number.isNaN(Date.parse(entry.verifiedAt))) {
+                continue;
+            }
+            seen.add(id);
+            models.push({
+                id,
+                ...(typeof entry.label === "string" && entry.label.trim() ? { label: entry.label.trim() } : {}),
+                verifiedAt: entry.verifiedAt,
+                claudeVersion: typeof entry.claudeVersion === "string" && entry.claudeVersion.trim()
+                    ? entry.claudeVersion.trim()
+                    : null,
+            });
+        }
+        return models;
+    }
+    catch {
+        return [];
+    }
+}
+function saveClaudeVerifications(storage, models) {
+    if (!storage)
+        return;
+    const sorted = [...models].sort((a, b) => a.id.localeCompare(b.id));
+    storage.setConfigValue(CLAUDE_VERIFICATION_CACHE_KEY, JSON.stringify({ version: 1, models: sorted }));
+}
+function verificationAvailability(verification, claudeVersion, now) {
+    if (!verification)
+        return "candidate";
+    const isFresh = now.getTime() - Date.parse(verification.verifiedAt) <= CLAUDE_VERIFICATION_TTL_MS;
+    const versionMatches = !claudeVersion || !verification.claudeVersion || claudeVersion === verification.claudeVersion;
+    return isFresh && versionMatches ? "verified" : "stale";
+}
+function candidateNote(candidate, availability, verification) {
+    if (availability === "verified")
+        return "已由 Claude Code 验证";
+    if (availability === "stale" && verification)
+        return `上次由 Claude Code 验证：${verification.verifiedAt}`;
+    if (candidate.source === "models-api")
+        return "API 目录候选，尚未验证 Claude Code 可用性";
+    if (candidate.source === "configured")
+        return "已配置，尚未验证 Claude Code 可用性";
+    return "尚未验证 Claude Code 可用性";
+}
+function candidateFromModel(model) {
+    const id = normalizeClaudeModelId(model.id);
+    if (!id || id === "default")
+        return null;
+    const source = model.source === "configured" || model.source === "verified-cache" || model.source === "models-api"
+        ? model.source
+        : "builtin";
+    return { id, label: model.label || id, alias: model.alias, source };
+}
+function buildClaudeModels(options) {
+    const candidates = new Map();
+    const add = (candidate) => {
+        const id = normalizeClaudeModelId(candidate.id);
+        if (!id || id === "default")
+            return;
+        const normalized = { ...candidate, id, label: candidate.label || id };
+        const existing = candidates.get(id);
+        if (!existing || sourcePriority(normalized.source) >= sourcePriority(existing.source)) {
+            candidates.set(id, normalized);
+        }
+    };
+    for (const model of CLAUDE_BUILTIN_MODELS) {
+        const candidate = candidateFromModel(model);
+        if (candidate)
+            add(candidate);
+    }
+    for (const model of options.existingModels ?? []) {
+        const candidate = candidateFromModel(model);
+        if (candidate)
+            add(candidate);
+    }
+    for (const model of options.apiModels ?? []) {
+        const id = normalizeClaudeModelId(model.id);
+        if (id)
+            add({ id, label: formatClaudeModelLabel(id, model.display_name), source: "models-api" });
+    }
+    for (const verification of options.verifications) {
+        add({ id: verification.id, label: verification.label || verification.id, source: "verified-cache" });
+    }
+    for (const value of options.configuredClaudeModels ?? []) {
+        const id = normalizeClaudeModelId(value);
+        if (id && id !== "default")
+            add({ id, label: id, source: "configured" });
+    }
+    const verificationById = new Map(options.verifications.map((entry) => [entry.id, entry]));
+    const models = [cloneModels(CLAUDE_BUILTIN_MODELS)[0]];
+    for (const candidate of candidates.values()) {
+        const verification = verificationById.get(candidate.id);
+        const availability = verificationAvailability(verification, options.claudeVersion, options.now);
+        models.push({
+            id: candidate.id,
+            label: candidate.label,
+            ...(candidate.alias ? { alias: true } : {}),
+            source: candidate.source,
+            availability,
+            ...(verification ? {
+                lastVerifiedAt: verification.verifiedAt,
+                ...(verification.claudeVersion ? { verifiedWithClaudeVersion: verification.claudeVersion } : {}),
+            } : {}),
+            ...(candidateNote(candidate, availability, verification) ? { note: candidateNote(candidate, availability, verification) } : {}),
+        });
+    }
+    return models;
+}
+function createInitialCache(options) {
+    const now = options.now?.() ?? new Date();
+    return {
+        models: buildClaudeModels({
+            configuredClaudeModels: options.configuredClaudeModels,
+            verifications: loadClaudeVerifications(options.storage),
+            claudeVersion: null,
+            now,
+        }),
+        codexModels: cloneModels(CODEX_FALLBACK_MODELS),
+        opencodeModels: cloneModels(OPENCODE_FALLBACK_MODELS),
+        claudeVersion: null,
+        opencodeVersion: null,
+        refreshedAt: now.toISOString(),
+    };
+}
+function refreshCachedClaudeModels(options) {
+    if (!cache)
+        return;
+    const now = options.now?.() ?? new Date();
+    cache.models = buildClaudeModels({
+        configuredClaudeModels: options.configuredClaudeModels,
+        existingModels: cache.models,
+        verifications: loadClaudeVerifications(options.storage),
+        claudeVersion: cache.claudeVersion,
+        now,
+    });
+}
+async function probeClaudeVersion(runner, env) {
+    try {
+        const { stdout } = await runner("claude", ["--version"], { env, timeout: 5000 });
         return extractSemver(stdout) ?? (stdout.trim().slice(0, 64) || null);
     }
     catch {
         return null;
     }
 }
-async function probeCodexModels() {
+async function probeClaudeModel(id, runner, env) {
+    try {
+        await runner("claude", ["--model", id, "-p", "Reply with exactly: ok"], {
+            env,
+            timeout: CLAUDE_PROBE_TIMEOUT_MS,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function probeCodexModels(runner, env) {
     try {
-        const { stdout } = await execAsync("codex debug models", { timeout: 8000 });
+        const { stdout } = await runner("codex", ["debug", "models"], { env, timeout: 8000 });
         return parseCodexModels(stdout);
     }
     catch {
-        return CODEX_FALLBACK_MODELS.map((m) => ({ ...m }));
+        return cloneModels(CODEX_FALLBACK_MODELS);
     }
 }
-async function probeOpenCode() {
+async function probeOpenCode(runner, env) {
     const [modelsResult, versionResult] = await Promise.allSettled([
-        execAsync("opencode models", { timeout: 8000 }),
-        execAsync("opencode --version", { timeout: 5000 }),
+        runner("opencode", ["models"], { env, timeout: 8000 }),
+        runner("opencode", ["--version"], { env, timeout: 5000 }),
     ]);
     const models = modelsResult.status === "fulfilled"
         ? parseOpenCodeModels(modelsResult.value.stdout)
-        : OPENCODE_FALLBACK_MODELS.map((m) => ({ ...m }));
+        : cloneModels(OPENCODE_FALLBACK_MODELS);
     const version = versionResult.status === "fulfilled"
         ? extractSemver(versionResult.value.stdout) ?? (versionResult.value.stdout.trim().slice(0, 64) || null)
         : null;
     return { models, version };
 }
+function createOfficialModelsApi(apiKey) {
+    const client = new Anthropic({ apiKey });
+    return {
+        list: () => client.models.list({ limit: 100 }),
+    };
+}
+async function listClaudeModelsFromApi(options, env) {
+    const apiKey = options.apiKey?.trim() || env.ANTHROPIC_API_KEY?.trim();
+    if (!apiKey)
+        return [];
+    try {
+        const api = options.modelsApi ?? createOfficialModelsApi(apiKey);
+        const models = [];
+        for await (const model of api.list()) {
+            const id = normalizeClaudeModelId(model?.id);
+            if (id)
+                models.push({ id, ...(typeof model.display_name === "string" ? { display_name: model.display_name } : {}) });
+        }
+        return models;
+    }
+    catch {
+        return [];
+    }
+}
+function probePriority(model) {
+    if (model.source === "configured")
+        return 0;
+    if (model.availability === "stale")
+        return 1;
+    if (model.source === "verified-cache")
+        return 2;
+    if (model.source === "builtin")
+        return 3;
+    return 4;
+}
+async function verifyClaudeCandidates(models, runner, env) {
+    const candidates = models
+        .filter((model) => model.id !== "default" && model.availability !== "verified")
+        .sort((a, b) => probePriority(a) - probePriority(b) || a.id.localeCompare(b.id))
+        .slice(0, MAX_CLAUDE_MODEL_PROBES);
+    const verified = new Set();
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < candidates.length) {
+            const candidate = candidates[nextIndex++];
+            if (candidate && await probeClaudeModel(candidate.id, runner, env)) {
+                verified.add(candidate.id);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CLAUDE_PROBE_CONCURRENCY, candidates.length) }, worker));
+    return verified;
+}
+function mergeVerifications(previous, models, verifiedIds, claudeVersion, now) {
+    const byId = new Map(previous.map((entry) => [entry.id, entry]));
+    for (const id of verifiedIds) {
+        const model = models.find((entry) => entry.id === id);
+        byId.set(id, {
+            id,
+            ...(model?.label ? { label: model.label } : {}),
+            verifiedAt: now.toISOString(),
+            claudeVersion,
+        });
+    }
+    return [...byId.values()];
+}
 /** Parse `opencode models`, whose stable machine-friendly output is one provider/model id per line. */
 export function parseOpenCodeModels(stdout) {
     const ids = Array.from(new Set(stdout
@@ -60,7 +326,7 @@ export function parseOpenCodeModels(stdout) {
         .map((line) => line.replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, "").trim())
         .filter((line) => /^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._:/-]*$/i.test(line))));
     if (!ids.length)
-        return OPENCODE_FALLBACK_MODELS.map((m) => ({ ...m }));
+        return cloneModels(OPENCODE_FALLBACK_MODELS);
     return [
         { id: "default", label: "跟随 OpenCode 默认", alias: true },
         ...ids.map((id) => ({ id, label: id })),
@@ -71,11 +337,11 @@ export function parseCodexModels(stdout) {
     try {
         const data = JSON.parse(stdout);
         const visible = (Array.isArray(data.models) ? data.models : [])
-            .filter((m) => typeof m.slug === "string" && m.slug.length > 0)
-            .filter((m) => m.visibility === "list")
+            .filter((model) => typeof model.slug === "string" && model.slug.length > 0)
+            .filter((model) => model.visibility === "list")
             .sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99));
         if (!visible.length)
-            return CODEX_FALLBACK_MODELS.map((m) => ({ ...m }));
+            return cloneModels(CODEX_FALLBACK_MODELS);
         const defaultModel = visible[0];
         const defaultLabel = formatCodexModelLabel(defaultModel);
         const result = [
@@ -86,17 +352,17 @@ export function parseCodexModels(stdout) {
                 ...codexReasoningMetadata(defaultModel),
             },
         ];
-        for (const m of visible) {
+        for (const model of visible) {
             result.push({
-                id: m.slug,
-                label: formatCodexModelLabel(m),
-                ...codexReasoningMetadata(m),
+                id: model.slug,
+                label: formatCodexModelLabel(model),
+                ...codexReasoningMetadata(model),
             });
         }
         return result;
     }
     catch {
-        return CODEX_FALLBACK_MODELS.map((m) => ({ ...m }));
+        return cloneModels(CODEX_FALLBACK_MODELS);
     }
 }
 function codexReasoningMetadata(model) {
@@ -118,32 +384,52 @@ function formatCodexModelLabel(model) {
         ? `${model.display_name} · ${model.slug}`
         : model.slug;
 }
-export function getCachedModels() {
+export function getCachedModels(options = {}) {
     if (!cache) {
-        cache = {
-            models: cloneClaudeModels(),
-            codexModels: CODEX_FALLBACK_MODELS.map((m) => ({ ...m })),
-            opencodeModels: OPENCODE_FALLBACK_MODELS.map((m) => ({ ...m })),
-            claudeVersion: null,
-            opencodeVersion: null,
-            refreshedAt: new Date().toISOString(),
-        };
+        cache = createInitialCache(options);
+    }
+    else if (options.storage || options.configuredClaudeModels) {
+        refreshCachedClaudeModels(options);
     }
     return cache;
 }
-export async function refreshModels() {
-    const [version, codexModels, opencode] = await Promise.all([
-        probeClaudeVersion(),
-        probeCodexModels(),
-        probeOpenCode(),
+export async function refreshModels(options = {}) {
+    const now = options.now?.() ?? new Date();
+    const env = resolveProbeEnv(options);
+    const runner = options.commandRunner ?? defaultCommandRunner;
+    const [claudeVersion, codexModels, opencode, apiModels] = await Promise.all([
+        probeClaudeVersion(runner, env),
+        probeCodexModels(runner, env),
+        probeOpenCode(runner, env),
+        listClaudeModelsFromApi(options, env),
     ]);
+    const priorVerifications = loadClaudeVerifications(options.storage);
+    const initialModels = buildClaudeModels({
+        configuredClaudeModels: options.configuredClaudeModels,
+        apiModels,
+        verifications: priorVerifications,
+        claudeVersion,
+        now,
+    });
+    const verifiedIds = options.verifyClaudeCandidates
+        ? await verifyClaudeCandidates(initialModels, runner, env)
+        : new Set();
+    const verifications = mergeVerifications(priorVerifications, initialModels, verifiedIds, claudeVersion, now);
+    if (verifiedIds.size > 0)
+        saveClaudeVerifications(options.storage, verifications);
     cache = {
-        models: cloneClaudeModels(),
+        models: buildClaudeModels({
+            configuredClaudeModels: options.configuredClaudeModels,
+            apiModels,
+            verifications,
+            claudeVersion,
+            now,
+        }),
         codexModels,
         opencodeModels: opencode.models,
-        claudeVersion: version,
+        claudeVersion,
         opencodeVersion: opencode.version,
-        refreshedAt: new Date().toISOString(),
+        refreshedAt: now.toISOString(),
     };
     return cache;
 }

package/dist/process-manager.d.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from "node:events";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode, ProcessEventHandler, SessionProvider, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
+import { type PermissionResolution } from "./claude-pty-bridge.js";
+import { type ClaudeHistorySession, type CodexHistorySession } from "./provider-history-scanner.js";
+export type { ClaudeHistorySession, CodexHistorySession } from "./provider-history-scanner.js";
+/** Exported for focused policy tests. */
+export declare function isCommandAllowedByPrefixes(command: string, allowedPrefixes: readonly string[]): boolean;
 export type { ProcessEvent, ProcessEventHandler } from "./types.js";
 export declare class SessionInputError extends Error {
     readonly code: "SESSION_NOT_FOUND" | "SESSION_NOT_RUNNING" | "SESSION_NO_PTY";
@@ -8,49 +13,30 @@ export declare class SessionInputError extends Error {
     readonly sessionStatus?: SessionSnapshot["status"] | undefined;
     constructor(message: string, code: "SESSION_NOT_FOUND" | "SESSION_NOT_RUNNING" | "SESSION_NO_PTY", sessionId: string, sessionStatus?: SessionSnapshot["status"] | undefined);
 }
-/** A Claude Code session discovered by scanning ~/.claude/projects/ directories. */
-export interface ClaudeHistorySession {
-    claudeSessionId: string;
-    projectDir: string;
-    cwd: string;
-    firstUserMessage: string;
-    timestamp: string;
-    mtimeMs: number;
-    hasConversation: boolean;
-    managedByWand: boolean;
-}
-/** A Codex session discovered by scanning ~/.codex/sessions/ rollout files. */
-export interface CodexHistorySession {
-    /** Codex thread id（存进 claudeSessionId 字段以复用前端/路由）。 */
-    claudeSessionId: string;
-    cwd: string;
-    firstUserMessage: string;
-    firstUserAt: string;
-    timestamp: string;
-    mtimeMs: number;
-    hasUser: boolean;
-    hasConversation: boolean;
-    managedByWand: boolean;
-    provider: "codex";
-}
 export declare class ProcessManager extends EventEmitter {
     private readonly config;
     private readonly storage;
     private readonly sessions;
     private readonly logger;
+    private readonly providerHistory;
     /** 24h archive scan timer */
     private archiveTimer;
     /** Per-session debounce timers for throttled persist calls */
     private readonly persistDebounceTimers;
     /** Last persisted message state per session — used to skip redundant message writes */
     private readonly lastPersistedMessageState;
+    /** Columns that changed since the last per-session checkpoint. */
+    private readonly dirtySessions;
     /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数（旧服务器进程已死） */
     private orphanRecoveredCount;
     private readonly topicRequests;
+    private disposed;
     constructor(config: WandConfig, storage: WandStorage, configDir?: string);
     on(_event: "process", listener: ProcessEventHandler): this;
     /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数量（仅用于启动摘要展示）。 */
     getOrphanRecoveredCount(): number;
+    /** Stop all live work and flush pending state before storage is closed. */
+    dispose(): void;
     private emitEvent;
     private cleanupOldSessions;
     start(command: string, cwd: string | undefined, mode: ExecutionMode, initialInput?: string, opts?: {
@@ -70,20 +56,19 @@ export declare class ProcessManager extends EventEmitter {
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
     hasClaudeSessionFile(cwd: string, claudeSessionId: string): boolean;
-    private claudeHistoryCache;
-    private static readonly HISTORY_CACHE_TTL_MS;
     listClaudeHistorySessions(): ClaudeHistorySession[];
     deleteClaudeHistoryFiles(sessions: {
         claudeSessionId: string;
         cwd: string;
     }[]): number;
-    private codexHistoryCache;
     listCodexHistorySessions(): CodexHistorySession[];
     hasCodexSessionFile(threadId: string): boolean;
     deleteCodexHistoryFiles(threadIds: string[]): number;
     private captureCodexSessionId;
     private captureClaudeSessionId;
     get(id: string): SessionSnapshot | null;
+    /** Return only a session owned by this manager, without the SQLite fallback used by get(). */
+    getOwned(id: string): SessionSnapshot | null;
     getPtyTranscript(id: string): string | null;
     /**
      * Set the Claude model for an existing PTY session. Persists the selection
@@ -116,9 +101,15 @@ export declare class ProcessManager extends EventEmitter {
     private snapshotSlim;
     private isPermissionBlocked;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
+    /**
+     * Persist worktree merge progress through the manager that owns the live
+     * session record. Returning null lets callers fall back to another owner (or
+     * directly to storage for a row that is not currently loaded by a manager).
+     */
+    setWorktreeMergeState(id: string, status: SessionSnapshot["worktreeMergeStatus"], info: SessionSnapshot["worktreeMergeInfo"]): SessionSnapshot | null;
     private maybeGenerateSessionTopic;
     private defaultAutonomyPolicy;
-    resolveEscalation(id: string, requestId: string, resolution?: "approve_once" | "approve_turn" | "deny"): SessionSnapshot;
+    resolveEscalation(id: string, requestId: string, resolution?: PermissionResolution): SessionSnapshot;
     approvePermission(id: string): SessionSnapshot;
     denyPermission(id: string): SessionSnapshot;
     toggleAutoApprove(id: string): SessionSnapshot;
@@ -128,8 +119,9 @@ export declare class ProcessManager extends EventEmitter {
      * @param resolution - "approve_once", "approve_turn", or "deny"
      * @param requestId - Optional escalation request ID for validation
      */
-    resolvePermission(id: string, resolution: "approve_once" | "approve_turn" | "deny", requestId?: string): SessionSnapshot;
+    resolvePermission(id: string, resolution: PermissionResolution, requestId?: string): SessionSnapshot;
     private persist;
+    private markDirty;
     /**
      * Schedule a debounced persist call for the given record.
      * Multiple calls within the debounce window are coalesced into a single write.