@cjhyy/code-shell-core 0.6.0-rc.9 → 0.7.0

package/dist/cc-orchestrator/session-history.js

@@ -19,23 +19,28 @@ function toolsOf(content) {
             const inp = p.input ?? {};
             const summary = inp.command ?? inp.file_path ?? inp.path ?? inp.url ?? inp.pattern ?? inp.query ?? "";
             const args = inp && typeof inp === "object" && Object.keys(inp).length > 0 ? inp : undefined;
-            out.push({ name: typeof p.name === "string" ? p.name : "tool", summary: String(summary).slice(0, 120), args });
+            out.push({
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: String(summary).slice(0, 120),
+                args,
+            });
         }
     }
     return out;
 }
-/** Read the last `limit` user/assistant messages from a claude session jsonl. */
-export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
-    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
-    if (!existsSync(file))
-        return { messages: [], hasMore: false, totalCount: 0 };
-    let raw;
-    try {
-        raw = readFileSync(file, "utf-8");
-    }
-    catch {
-        return { messages: [], hasMore: false, totalCount: 0 };
-    }
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => typeof part === "string" ? part : typeof part?.text === "string" ? part.text : "")
+        .join("");
+}
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export function parseRecentHistory(raw, limit) {
     const all = [];
     for (const line of raw.split("\n")) {
         if (!line.trim())
@@ -51,17 +56,95 @@ export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homed
             const t = textOf(d.message?.content).trim();
             if (!t || NOISE.some((n) => t.startsWith(n)))
                 continue;
-            all.push({ role: "user", text: t.slice(0, 4000) });
+            all.push({ role: "user", text: t });
         }
         else if (d.type === "assistant") {
             const t = textOf(d.message?.content).trim();
             const tools = toolsOf(d.message?.content);
             if (!t && tools.length === 0)
                 continue;
-            all.push({ role: "assistant", text: t.slice(0, 4000), tools: tools.length ? tools : undefined });
+            all.push({ role: "assistant", text: t, tools: tools.length ? tools : undefined });
         }
     }
     const lim = limit > 0 ? limit : 20;
     const start = Math.max(0, all.length - lim);
     return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
 }
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export function parseClaudeTranscriptLine(line) {
+    let d;
+    try {
+        d = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    if (d.type === "user") {
+        const content = d.message?.content;
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                if (part?.type !== "tool_result")
+                    continue;
+                out.push({
+                    type: "tool_result",
+                    id: typeof part.tool_use_id === "string" ? part.tool_use_id : undefined,
+                    result: toolResultText(part.content).slice(0, 4000),
+                    isError: Boolean(part.is_error),
+                });
+            }
+        }
+        const text = textOf(content).trim();
+        if (text && !NOISE.some((noise) => text.startsWith(noise))) {
+            out.unshift({ type: "user", text });
+        }
+        return out;
+    }
+    if (d.type === "assistant" && Array.isArray(d.message?.content)) {
+        for (const part of d.message.content) {
+            if (part?.type === "text" && typeof part.text === "string" && part.text) {
+                out.push({ type: "assistant", text: part.text });
+            }
+            else if (part?.type === "tool_use") {
+                const input = part.input && typeof part.input === "object"
+                    ? part.input
+                    : undefined;
+                out.push({
+                    type: "tool",
+                    id: typeof part.id === "string" ? part.id : undefined,
+                    name: typeof part.name === "string" ? part.name : "tool",
+                    summary: toolsOf([part])[0]?.summary ?? "",
+                    args: input,
+                });
+            }
+        }
+        if (d.message.stop_reason === "end_turn") {
+            out.push({ type: "turn_end", reason: "completed" });
+        }
+        return out;
+    }
+    if (d.type === "result") {
+        return [
+            {
+                type: "turn_end",
+                reason: typeof d.subtype === "string" ? d.subtype : "completed",
+            },
+        ];
+    }
+    return [];
+}
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return { messages: [], hasMore: false, totalCount: 0 };
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return { messages: [], hasMore: false, totalCount: 0 };
+    }
+    return parseRecentHistory(raw, limit);
+}

package/dist/cli/agent-server-stdio.js

@@ -50,6 +50,7 @@ import { logger } from "../logging/logger.js";
 import { cronScheduler } from "../automation/scheduler.js";
 import { CronStore, defaultCronStorePath } from "../automation/store.js";
 import { resolveLLMConfigForTag } from "../engine/resolve-llm-config.js";
+import { createIpcCredentialAccess, setDefaultCredentialAccess } from "../credentials/access.js";
 /**
  * Resolve per-session agent config: protocol slice overrides win, else fall
  * back to disk settings.agent.*. Fixes the bug where settings.agent.* never
@@ -106,8 +107,7 @@ catch (err) {
 // knob; imageDetail from settings.images.detail).
 const seedLlm = resolveLLMConfigForTag(settings, "text", settings.defaults?.text);
 if (!seedLlm) {
-    console.error(`[agent-server] 没有可用的文本模型连接(defaults.text=${settings.defaults?.text ?? "未设置"})。` +
-        `请在「连接」页添加并填写凭证。`);
+    console.error(`[agent-server] 没有可用的文本模型连接(defaults.text=${settings.defaults?.text ?? "未设置"})。` + `请在「连接」页添加并填写凭证。`);
     process.exit(1);
 }
 const llmConfig = seedLlm;
@@ -115,6 +115,10 @@ const llmConfig = seedLlm;
 const seedEngine = new Engine({
     llm: llmConfig,
     cwd,
+    preset: settings.agent.preset,
+    enabledBuiltinTools: settings.agent.enabledBuiltinTools,
+    disabledBuiltinTools: settings.agent.disabledBuiltinTools,
+    builtinToolHost: "desktop",
     settingsScope: "full",
     // No runtime — Engine.populateModelPoolFromSettings() runs in ctor.
 });
@@ -217,6 +221,7 @@ const chatManager = new ChatSessionManager({
             // This stdio worker exists only to serve the desktop app, so every
             // session it creates is a desktop-origin session.
             origin: "desktop",
+            builtinToolHost: "desktop",
             // Inherit full scope so spawned subagents read user config too.
             settingsScope: "full",
             // MCP servers from settings — the worker reads the full disk
@@ -270,6 +275,7 @@ cronScheduler.setExecutionEnabled(false);
 cronScheduler.loadJobs();
 // ─── Step 5: AgentServer over stdio ──────────────────────────────
 const stdioTransport = new StdioTransport(process.stdin, process.stdout);
+setDefaultCredentialAccess(createIpcCredentialAccess(stdioTransport));
 // Cron jobs are persisted by this worker but only main arms/executes their
 // timers (this worker keeps setExecutionEnabled(false) above). When an AI tool
 // creates/deletes a cron job here, notify main over stdio so it reloads the
@@ -286,6 +292,7 @@ const goalDiskReader = new SessionManager();
 const agentServer = new AgentServer({
     chatManager,
     transport: stdioTransport,
+    workspaceBridge: true,
     // Config hot-reload (layer 2) reads disk through the SAME closure the
     // engineFactory uses for new sessions, so a reloaded running session and a
     // newly-created session converge on identical disk config (no divergence).

package/dist/context/compaction.d.ts

@@ -10,7 +10,7 @@
  * All slicing functions use adjustIndexToPreserveAPIInvariants()
  * to prevent splitting tool_use / tool_result pairs.
  */
-import type { Message } from "../types.js";
+import type { ContentBlock, Message } from "../types.js";
 /**
  * Estimate token count from messages.
  * Uses per-block-type estimation with 33% overhead padding.
@@ -34,6 +34,12 @@ export interface DowngradeImageHistoryResult {
     messages: Message[];
     replacedCount: number;
 }
+export interface Base64ImageHistoryEntry {
+    imageNumber: number;
+    block: ContentBlock;
+}
+export declare function collectBase64Images(messages: Message[]): Base64ImageHistoryEntry[];
+export declare function findImageByNumber(messages: Message[], imageNumber: number): Base64ImageHistoryEntry | undefined;
 /**
  * Replace already-consumed image payload blocks with compact text markers.
  *
@@ -45,6 +51,7 @@ export interface DowngradeImageHistoryResult {
  */
 export declare function downgradeImagePayloadsInHistory(messages: Message[], options?: DowngradeImageHistoryOptions): DowngradeImageHistoryResult;
 export declare function messageHasBase64ImagePayload(message: Message): boolean;
+export declare function isBase64ImageBlock(block: ContentBlock): boolean;
 /**
  * Reconcile user-supplied compaction ratios into a safe ordering.
  *

package/dist/context/compaction.js

@@ -20,6 +20,36 @@ export function estimateTokens(messages) {
 }
 export const IMAGE_HISTORY_PLACEHOLDER_PREFIX = "[image #";
 export const IMAGE_HISTORY_PLACEHOLDER_SUFFIX = ", 已处理 / already provided earlier]";
+export function collectBase64Images(messages) {
+    const entries = [];
+    let nextImageNumber = 1;
+    const visitBlocks = (blocks) => {
+        for (const block of blocks) {
+            const placeholderNumber = imageHistoryPlaceholderNumber(block);
+            if (placeholderNumber !== undefined) {
+                nextImageNumber = Math.max(nextImageNumber, placeholderNumber + 1);
+                continue;
+            }
+            if (isBase64ImageBlock(block)) {
+                entries.push({ imageNumber: nextImageNumber++, block });
+                continue;
+            }
+            if (block.type === "tool_result" && Array.isArray(block.content)) {
+                visitBlocks(block.content);
+            }
+        }
+    };
+    for (const msg of messages) {
+        if (Array.isArray(msg.content))
+            visitBlocks(msg.content);
+    }
+    return entries;
+}
+export function findImageByNumber(messages, imageNumber) {
+    if (!Number.isSafeInteger(imageNumber) || imageNumber <= 0)
+        return undefined;
+    return collectBase64Images(messages).find((entry) => entry.imageNumber === imageNumber);
+}
 /**
  * Replace already-consumed image payload blocks with compact text markers.
  *
@@ -30,9 +60,23 @@ export const IMAGE_HISTORY_PLACEHOLDER_SUFFIX = ", 已处理 / already provided
  * nested inside tool_result.content arrays (view_image / browser screenshots).
  */
 export function downgradeImagePayloadsInHistory(messages, options = {}) {
-    let nextImageNumber = 1;
     let replacedCount = 0;
     let changed = false;
+    const imageNumberQueues = new WeakMap();
+    for (const entry of collectBase64Images(messages)) {
+        const key = entry.block;
+        const existing = imageNumberQueues.get(key);
+        if (existing) {
+            existing.push(entry.imageNumber);
+        }
+        else {
+            imageNumberQueues.set(key, [entry.imageNumber]);
+        }
+    }
+    const takeImageNumber = (block) => {
+        const queue = imageNumberQueues.get(block);
+        return queue?.shift();
+    };
     const placeholderFor = (imageNumber) => ({
         type: "text",
         text: `${IMAGE_HISTORY_PLACEHOLDER_PREFIX}${imageNumber}${IMAGE_HISTORY_PLACEHOLDER_SUFFIX}`,
@@ -42,11 +86,12 @@ export function downgradeImagePayloadsInHistory(messages, options = {}) {
         const out = blocks.map((block) => {
             const placeholderNumber = imageHistoryPlaceholderNumber(block);
             if (placeholderNumber !== undefined) {
-                nextImageNumber = Math.max(nextImageNumber, placeholderNumber + 1);
                 return block;
             }
             if (isBase64ImageBlock(block)) {
-                const imageNumber = nextImageNumber++;
+                const imageNumber = takeImageNumber(block);
+                if (imageNumber === undefined)
+                    return block;
                 if (preserve)
                     return block;
                 replacedCount++;
@@ -99,7 +144,7 @@ function imageHistoryPlaceholderNumber(block) {
     const n = Number(match[1]);
     return Number.isSafeInteger(n) && n > 0 ? n : undefined;
 }
-function isBase64ImageBlock(block) {
+export function isBase64ImageBlock(block) {
     if (block.type === "image" &&
         block.source?.type === "base64" &&
         typeof block.source.data === "string" &&

package/dist/context/manager.d.ts

@@ -5,7 +5,7 @@
  * Tier 2: LLM summary (async) — generate summary of older messages via model call
  * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
  */
-import type { Message } from "../types.js";
+import type { Message, ContextUsageAnchor, PromptTokenConfidence, PromptTokenSource } from "../types.js";
 export interface ContextManagerConfig {
     maxTokens: number;
     compactAtRatio: number;
@@ -48,6 +48,11 @@ export declare class ContextManager {
     private lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     private lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    private lastActualAnchorEstimate;
+    private lastActualRecordedAt;
+    private lastActualProvider;
+    private lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     private transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -65,11 +70,18 @@ export declare class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens: number, messageCount: number): void;
+    recordActualUsage(inputTokens: number, messageCount: number, messages?: Message[]): ContextUsageAnchor | undefined;
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor: ContextUsageAnchor | undefined): ContextUsageAnchor | undefined;
+    getActualUsageAnchor(): ContextUsageAnchor | undefined;
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
+    private estimateTokensHybridInfo;
     private estimateTokensHybrid;
     /**
      * Set the summarize function (injected by Engine).
@@ -139,5 +151,7 @@ export declare class ContextManager {
         ratio: number;
         needsCompact: boolean;
         needsEmergency: boolean;
+        promptTokensSource: PromptTokenSource;
+        promptTokensConfidence: PromptTokenConfidence;
     };
 }

package/dist/context/manager.js

@@ -37,6 +37,9 @@ const DEFAULT_CONFIG = {
 function defaultKeepRecent(maxTokens) {
     return Math.max(5, Math.floor(maxTokens / 100_000));
 }
+function positiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 export class ContextManager {
     config;
     summarizeFn;
@@ -48,6 +51,11 @@ export class ContextManager {
     lastActualTokens;
     /** Message count at the time lastActualTokens was recorded. */
     lastActualAtMessageCount;
+    /** Heuristic token estimate for the same messages as lastActualTokens. */
+    lastActualAnchorEstimate;
+    lastActualRecordedAt;
+    lastActualProvider;
+    lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -69,23 +77,84 @@ export class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens, messageCount) {
-        this.lastActualTokens = inputTokens;
-        this.lastActualAtMessageCount = messageCount;
+    recordActualUsage(inputTokens, messageCount, messages) {
+        const estimateAtAnchor = messages ? estimateTokens(messages) : undefined;
+        return this.seedActualUsage({
+            promptTokens: inputTokens,
+            messageCount,
+            ...(estimateAtAnchor !== undefined ? { estimateAtAnchor } : {}),
+            recordedAt: Date.now(),
+        });
+    }
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor) {
+        if (!anchor)
+            return undefined;
+        if (!positiveFinite(anchor.promptTokens))
+            return undefined;
+        if (!Number.isSafeInteger(anchor.messageCount) || anchor.messageCount <= 0) {
+            return undefined;
+        }
+        if (anchor.estimateAtAnchor !== undefined && !positiveFinite(anchor.estimateAtAnchor)) {
+            return undefined;
+        }
+        this.lastActualTokens = anchor.promptTokens;
+        this.lastActualAtMessageCount = anchor.messageCount;
+        this.lastActualAnchorEstimate = anchor.estimateAtAnchor;
+        this.lastActualRecordedAt = positiveFinite(anchor.recordedAt) ? anchor.recordedAt : Date.now();
+        this.lastActualProvider = anchor.provider;
+        this.lastActualModel = anchor.model;
+        return this.getActualUsageAnchor();
+    }
+    getActualUsageAnchor() {
+        if (this.lastActualTokens === undefined ||
+            this.lastActualAtMessageCount === undefined ||
+            this.lastActualRecordedAt === undefined) {
+            return undefined;
+        }
+        return {
+            promptTokens: this.lastActualTokens,
+            messageCount: this.lastActualAtMessageCount,
+            ...(this.lastActualAnchorEstimate !== undefined
+                ? { estimateAtAnchor: this.lastActualAnchorEstimate }
+                : {}),
+            recordedAt: this.lastActualRecordedAt,
+            ...(this.lastActualProvider ? { provider: this.lastActualProvider } : {}),
+            ...(this.lastActualModel ? { model: this.lastActualModel } : {}),
+        };
     }
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
-    estimateTokensHybrid(messages) {
+    estimateTokensHybridInfo(messages) {
+        const currentEstimate = estimateTokens(messages);
         if (this.lastActualTokens !== undefined &&
-            this.lastActualAtMessageCount !== undefined &&
-            this.lastActualAtMessageCount < messages.length) {
-            const newMessages = messages.slice(this.lastActualAtMessageCount);
-            const newTokens = estimateTokens(newMessages);
-            return this.lastActualTokens + newTokens;
+            this.lastActualAtMessageCount !== undefined) {
+            if (this.lastActualAtMessageCount < messages.length) {
+                const newMessages = messages.slice(this.lastActualAtMessageCount);
+                const newTokens = estimateTokens(newMessages);
+                return {
+                    tokens: this.lastActualTokens + newTokens,
+                    source: "anchor_delta",
+                    confidence: "medium",
+                };
+            }
+            if (this.lastActualAnchorEstimate !== undefined && this.lastActualAnchorEstimate > 0) {
+                return {
+                    tokens: Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate)),
+                    source: "anchor_rescale",
+                    confidence: "medium",
+                };
+            }
         }
-        return estimateTokens(messages);
+        return { tokens: currentEstimate, source: "heuristic_estimate", confidence: "low" };
+    }
+    estimateTokensHybrid(messages) {
+        return this.estimateTokensHybridInfo(messages).tokens;
     }
     /**
      * Set the summarize function (injected by Engine).
@@ -119,7 +188,7 @@ export class ContextManager {
                 return { messages, tokens: before, compacted: false, noProgress: true };
             }
             const compacted = applySummaryCompaction(messages, summary, keepRecentN, this.transcriptPath);
-            const after = estimateTokens(compacted);
+            const after = this.estimateTokensHybrid(compacted);
             if (after >= before) {
                 this.consecutiveSummaryFailures++;
                 logger.warn("context.summary_no_progress", {
@@ -298,6 +367,17 @@ export class ContextManager {
         result = this.truncateToolResults(result);
         // Tier 0c: Aggregate tool result budget (per-message)
         result = applyToolResultBudget(result);
+        // Tier 0d: same always-on waste-removal passes as manage().
+        const dedup = dedupeFileReads(result);
+        if (dedup.clearedCount > 0) {
+            result = dedup.messages;
+            logger.info("context.dedupe_file_reads", { cleared: dedup.clearedCount });
+        }
+        const masked = maskOldObservations(result);
+        if (masked.maskedCount > 0) {
+            result = masked.messages;
+            logger.info("context.mask_browser_snapshots", { masked: masked.maskedCount });
+        }
         // Tier 1: microcompact — see manage() for the rationale on the floor.
         const preTier1Tokens = this.estimateTokensHybrid(result);
         const microFloorGate = this.config.maxTokens * this.config.microcompactFloorRatio;
@@ -342,6 +422,9 @@ export class ContextManager {
             ratio >= this.config.microcompactFloorRatio &&
             ratio < this.config.compactAtRatio;
         const shouldEscalateNoOpMicro = noOpMicroSpinBand && !this.suppressNoOpMicroSummaryUntilCompact;
+        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
+        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
+        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
         // Tier 2: LLM summary if approaching limit, or if micro was the only tier
         // available in the 0.70-0.85 band and it freed nothing.
         if (ratio >= this.config.compactAtRatio || shouldEscalateNoOpMicro) {
@@ -350,7 +433,8 @@ export class ContextManager {
             tokens = summarized.tokens;
             if (summarized.compacted) {
                 this.suppressNoOpMicroSummaryUntilCompact = false;
-                return result;
+                if (tokens <= snipGate)
+                    return result;
             }
             if (shouldEscalateNoOpMicro && summarized.noProgress) {
                 this.suppressNoOpMicroSummaryUntilCompact = true;
@@ -362,13 +446,10 @@ export class ContextManager {
                 });
             }
         }
-        // Reuse the `tokens` we already computed above. We only get here if no
-        // summary compacted the prompt (no summarizeFn, too many failures, a
-        // thrown error, or a generated summary that did not shrink anything).
+        // Reuse the `tokens` we already computed above. We get here if no summary
+        // compacted the prompt, or if summary helped but the hybrid estimate is
+        // still above the fallback gate.
         let live = tokens;
-        const snipGate = this.config.maxTokens * this.config.compactAtRatio;
-        const windowGate = this.config.maxTokens * (this.config.compactAtRatio + 0.05);
-        const emergencyGate = this.config.maxTokens * this.config.summarizeAtRatio;
         // Tier 2 fallback: snip first (cheapest sync option)
         if (live > snipGate) {
             const before = live;
@@ -507,13 +588,16 @@ export class ContextManager {
      * Check if context is approaching limits.
      */
     checkLimits(messages) {
-        const tokens = this.estimateTokensHybrid(messages);
+        const estimate = this.estimateTokensHybridInfo(messages);
+        const tokens = estimate.tokens;
         const ratio = tokens / this.config.maxTokens;
         return {
             tokens,
             ratio,
             needsCompact: ratio >= this.config.compactAtRatio,
             needsEmergency: ratio >= this.config.summarizeAtRatio,
+            promptTokensSource: estimate.source,
+            promptTokensConfidence: estimate.confidence,
         };
     }
 }

package/dist/credentials/access.d.ts

@@ -0,0 +1,57 @@
+import type { Credential, CredentialType } from "./types.js";
+import type { SettingsScope } from "../settings/manager.js";
+import type { Transport } from "../protocol/transport.js";
+export type CredentialAccessScope = "full" | "project";
+export interface CredentialMetadata {
+    id: string;
+    type: CredentialType;
+    label: string;
+    autoUseByAI?: boolean;
+    autoInjectByAI?: boolean;
+    exposeAsEnv?: string;
+    meta?: Credential["meta"];
+    hasSecret: boolean;
+    secretHint?: string;
+    oauthStatus?: import("./types.js").OAuthCredentialPublicStatus;
+}
+export interface CredentialAccess {
+    listMasked(cwd: string | undefined, scope: CredentialAccessScope): CredentialMetadata[];
+    resolveMeta(cwd: string | undefined, id: string, scope: CredentialAccessScope): CredentialMetadata | undefined;
+    envExposures(cwd: string | undefined, scope: CredentialAccessScope): Record<string, string>;
+    resolveValue?(req: {
+        cwd?: string;
+        id: string;
+        scope: CredentialAccessScope;
+        purpose: "use" | "mcp";
+    }): Promise<string>;
+    materializeCookie?(req: {
+        cwd?: string;
+        id: string;
+        scope: CredentialAccessScope;
+    }): Promise<{
+        cookiesFile: string;
+        count: number;
+    }>;
+}
+export interface CredentialSnapshotEntry {
+    cwd?: string;
+    full: CredentialMetadata[];
+    project: CredentialMetadata[];
+    envFull: Record<string, string>;
+    envProject: Record<string, string>;
+}
+export interface CredentialSnapshot {
+    revision: number;
+    entries: CredentialSnapshotEntry[];
+}
+export declare function setDefaultCredentialAccess(access: CredentialAccess | null | undefined): void;
+export declare function getCredentialAccess(): CredentialAccess;
+export declare function createIpcCredentialAccess(transport: Pick<Transport, "send" | "onMessage">): CredentialAccess;
+export declare function credentialAccessScope(scope: SettingsScope | undefined): CredentialAccessScope;
+export declare function isCredentialSecretAvailable(secret: string | undefined): secret is string;
+export declare const localCredentialAccess: CredentialAccess;
+export declare function materializeCookieSecret(credentialId: string, secret: string): {
+    cookiesFile: string;
+    count: number;
+};
+export declare function sweepStaleCredentialCookieFiles(now?: number): void;