@ikarmic/forge-core 4.5.0 → 5.1.0

package/dist/browser/session.js

@@ -156,4 +156,3 @@ export class BrowserSession {
         this.console = [];
     }
 }
-//# sourceMappingURL=session.js.map

package/dist/checkpoints/index.d.ts

@@ -9,4 +9,3 @@
  */
 export { CheckpointStore, type CheckpointStoreLimits } from './store.js';
 export type { CaptureOptions, Checkpoint, CheckpointFile, CheckpointFileStatus, CheckpointSummary, CheckpointTrigger, PruneResult, RestoreResult, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/checkpoints/index.js

@@ -8,4 +8,3 @@
  * surfaces list/show/restore/prune via `forge checkpoint …`.
  */
 export { CheckpointStore } from './store.js';
-//# sourceMappingURL=index.js.map

package/dist/checkpoints/store.d.ts

@@ -86,4 +86,3 @@ export declare class CheckpointStore {
     /** Delete every checkpoint for this session. Called on session reset. */
     clear(): Promise<void>;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/checkpoints/store.js

@@ -16,6 +16,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { snapshotWorktreeContext } from '../worktree/worktree.js';
+import { isOutsideRel } from '../tools/shared.js';
 const MANIFEST_FILENAME = 'manifest.json';
 const FILES_SUBDIR = 'files';
 /** Default retention for prune. Keeps the last 20 checkpoints. */
@@ -128,7 +129,7 @@ export class CheckpointStore {
             const abs = path.resolve(this.cwd, options.focusPath);
             const rel = path.relative(this.cwd, abs);
             // Skip files outside cwd (security: never capture /etc/passwd).
-            if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
+            if (!isOutsideRel(rel)) {
                 await this.captureFile(rel, files, dir);
             }
         }
@@ -316,6 +317,9 @@ export class CheckpointStore {
         };
         for (const file of checkpoint.files) {
             const abs = path.join(this.cwd, file.path);
+            // A manifest is data on disk: an entry leading out of the workspace (damaged or edited) is never written or removed.
+            if (isOutsideRel(path.relative(this.cwd, abs)))
+                continue;
             const contentPath = path.join(dir, FILES_SUBDIR, encodePath(file.path));
             if (file.status === 'deleted') {
                 if (existsSync(abs)) {
@@ -408,4 +412,3 @@ function defaultDescription(options) {
     }
     return 'manual checkpoint';
 }
-//# sourceMappingURL=store.js.map

package/dist/checkpoints/types.d.ts

@@ -159,4 +159,3 @@ export interface CaptureOptions {
      */
     worktreeContextOverride?: import('./types.js').CheckpointWorktreeContext | null;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/checkpoints/types.js

@@ -18,4 +18,3 @@
  * checkpoints travel with sessions when they're saved / resumed.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/code-index/builder.d.ts

@@ -6,4 +6,3 @@ import type { IndexManifest } from './types.js';
  * (only when something actually changed): never once per file.
  */
 export declare function ensureFresh(cwd: string): Promise<IndexManifest>;
-//# sourceMappingURL=builder.d.ts.map

package/dist/code-index/builder.js

@@ -64,4 +64,3 @@ export async function ensureFresh(cwd) {
         await saveManifest(cwd, manifest);
     return manifest;
 }
-//# sourceMappingURL=builder.js.map

package/dist/code-index/index-store.d.ts

@@ -9,4 +9,3 @@ export declare function saveManifest(cwd: string, manifest: IndexManifest): Prom
 export declare function getEntry(manifest: IndexManifest, relPath: string): IndexFileEntry | undefined;
 export declare function setEntry(manifest: IndexManifest, relPath: string, entry: IndexFileEntry): void;
 export declare function deleteEntry(manifest: IndexManifest, relPath: string): void;
-//# sourceMappingURL=index-store.d.ts.map

package/dist/code-index/index-store.js

@@ -41,4 +41,3 @@ function isValidManifest(value) {
     const v = value;
     return v.version === 1 && typeof v.files === 'object' && v.files !== null;
 }
-//# sourceMappingURL=index-store.js.map

package/dist/code-index/parser.d.ts

@@ -19,4 +19,3 @@ export interface SyntaxProblem {
  * and an empty array when the file parses cleanly.
  */
 export declare function findSyntaxErrors(source: string, ext: string): Promise<SyntaxProblem[] | null>;
-//# sourceMappingURL=parser.d.ts.map

package/dist/code-index/parser.js

@@ -286,4 +286,3 @@ function unwrapExport(node) {
     const inner = node.namedChildren.find((c) => c && c.type !== 'export_clause' && c.type !== 'string');
     return inner ?? node;
 }
-//# sourceMappingURL=parser.js.map

package/dist/code-index/types.d.ts

@@ -21,4 +21,3 @@ export interface IndexManifest {
     version: 1;
     files: Record<string, IndexFileEntry>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/code-index/types.js

@@ -3,4 +3,3 @@
  * list_symbols, find_references) and the index that backs them.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/commands/custom-commands.d.ts

@@ -2,6 +2,14 @@ export interface CustomCommand {
     /** Lowercase name used after the slash. */
     name: string;
     description?: string;
+    /** Front matter `agent`: the agent (mode) this command runs as. */
+    agent?: string;
+    /** Front matter `model`: a model for this command. */
+    model?: string;
+    /** Front matter `variant`: reasoning effort for this command. */
+    variant?: 'low' | 'medium' | 'high';
+    /** Front matter `subtask: true`: hand the work to `agent` through sub_agent instead of switching to it. */
+    subtask?: boolean;
     template: string;
     source: 'user' | 'project';
     /** Absolute path of the template file. */
@@ -12,14 +20,10 @@ export declare function commandDirs(cwd: string, home?: string): Array<{
     source: 'user' | 'project';
 }>;
 /** Split optional `---` front matter from the body and read its `description`. */
-export declare function parseCommandFile(text: string): {
-    description?: string;
-    template: string;
-};
+export declare function parseCommandFile(text: string): Pick<CustomCommand, 'description' | 'agent' | 'model' | 'variant' | 'subtask' | 'template'>;
 /** Every custom command, keyed by name; project commands replace personal ones. */
 export declare function loadCustomCommands(cwd: string, home?: string): Promise<Map<string, CustomCommand>>;
 /** The message a command sends for these arguments. */
 export declare function expandCustomCommand(command: Pick<CustomCommand, 'template'>, args: string): string;
 /** `/name — description` lines for help output. */
 export declare function formatCustomCommands(commands: Map<string, CustomCommand>): string;
-//# sourceMappingURL=custom-commands.d.ts.map

package/dist/commands/custom-commands.js

@@ -34,8 +34,19 @@ export function parseCommandFile(text) {
     const m = /^---\n([\s\S]*?)\n---\n?/.exec(normalized);
     if (!m)
         return { template: normalized.trim() };
-    const desc = /^description:\s*(.+)$/m.exec(m[1])?.[1]?.trim().replace(/^(['"])(.*)\1$/, '$2');
-    return { ...(desc ? { description: desc } : {}), template: normalized.slice(m[0].length).trim() };
+    const field = (key) => new RegExp('^' + key + ':\\s*(.+)$', 'm').exec(m[1])?.[1]?.trim().replace(/^(['"])(.*)\1$/, '$2');
+    const desc = field('description');
+    const agent = field('agent');
+    const model = field('model');
+    const variant = field('variant');
+    return {
+        ...(desc ? { description: desc } : {}),
+        ...(agent ? { agent } : {}),
+        ...(model ? { model } : {}),
+        ...(variant === 'low' || variant === 'medium' || variant === 'high' ? { variant } : {}),
+        ...(field('subtask') === 'true' ? { subtask: true } : {}),
+        template: normalized.slice(m[0].length).trim(),
+    };
 }
 /** Every custom command, keyed by name; project commands replace personal ones. */
 export async function loadCustomCommands(cwd, home) {
@@ -96,4 +107,3 @@ export function formatCustomCommands(commands) {
         .map((c) => `/${c.name}${c.description ? ` — ${c.description}` : ''}${c.source === 'project' ? ' (project)' : ''}`)
         .join('\n');
 }
-//# sourceMappingURL=custom-commands.js.map

package/dist/config-file.d.ts

@@ -1,4 +1,7 @@
 import type { ModelAliases } from './model-alias.js';
+import { type CustomProviderConfig } from './custom-providers.js';
+import type { ModelOverride } from './model-overrides.js';
+import type { PermissionConfig } from './tools/permission-rules.js';
 import type { ProviderName } from './types.js';
 /**
  * Shape of `~/.forge/config.json`: cross-surface provider/model/display
@@ -20,12 +23,48 @@ export interface ForgeConfigFile {
         command: string;
         fingerprint?: string;
     }>>;
+    /**
+     * Ordered permission rules (`read`, `edit`, `bash`, `webfetch`, `websearch`, `task`, `external_directory`): each maps
+     * to an action or to a pattern → action map; the last matching rule wins. See tools/permission-rules.ts.
+     */
+    permission?: PermissionConfig;
+    /**
+     * Providers beyond the built-in eleven, by id: `groq` and other presets need only a key, anything else needs a
+     * `baseUrl`. A model on one is written `id:model` (e.g. `acme:fast`). See custom-providers.ts.
+     */
+    customProviders?: Record<string, CustomProviderConfig>;
+    /** Context and output limits and prices per model, keyed `provider:model`, `id:model` or a bare model id. */
+    modelOverrides?: Record<string, ModelOverride>;
+    /** Per provider, which model ids the pickers list: `whitelist` (only these) then `blacklist` (not these). */
+    modelFilters?: Record<string, {
+        whitelist?: string[];
+        blacklist?: string[];
+    }>;
+    /** The model sub-agents use when the model does not name one; blank means the parent's model. */
+    subagentModel?: string;
+    /** Extra instruction sources added to the system prompt: files, globs (workspace-relative) and http(s) URLs. User config only. */
+    instructions?: string[];
+    /** Extra places to read skills from: folders (absolute, `~/...`, or relative to the workspace) or http(s) URLs of a skill file or a skill index. User config only. */
+    skillPaths?: string[];
+    /** PEM files of extra certificate authorities to trust (absolute or `~/...`), for company networks that re-sign TLS. User config only. */
+    caCertificates?: string[];
     /** Short names for models: `"fast": "anthropic:claude-haiku-4-5"`. See model-alias.ts. */
     aliases?: ModelAliases;
+    /** Model for a chat mode that has none of its own: mode id → `provider:model`, bare model id or alias. */
+    modeModels?: Record<string, string>;
+    /** Delete saved sessions not updated for this many days, when the VS Code extension starts. Unset keeps everything. */
+    sessionRetentionDays?: number;
     display?: {
         blockDefault?: 'collapsed' | 'expanded';
         detail?: 'compact' | 'full';
         showReasoning?: boolean;
+        /** Per kind of block; overrides the two settings above for that kind. */
+        blocks?: {
+            reasoning?: 'hidden' | 'collapsed' | 'expanded';
+            terminal?: 'collapsed' | 'expanded';
+            edit?: 'collapsed' | 'expanded';
+            mcp?: 'collapsed' | 'expanded';
+        };
     };
 }
 export interface LoadForgeConfigFileResult {
@@ -41,4 +80,11 @@ export declare function loadForgeConfigFile(configPath?: string): Promise<LoadFo
  * Fields not present in `partial` are left untouched.
  */
 export declare function saveForgeConfigFile(partial: ForgeConfigFile, configPath?: string): Promise<void>;
-//# sourceMappingURL=config-file.d.ts.map
+/**
+ * Read-modify-write of a JSON settings file, safely:
+ * - merged over the file as written, not the cleaned config, so keys this version drops or does not know survive;
+ * - a file that exists but is not valid JSON is never overwritten (that would replace every setting with one);
+ * - writes to one path from this process run one after another, so two saves at once both land;
+ * - written to a temporary file and renamed, so a crash cannot leave half a file.
+ */
+export declare function updateJsonFile(filePath: string, update: (existing: Record<string, unknown>) => Record<string, unknown>): Promise<void>;

package/dist/config-file.js

@@ -1,7 +1,178 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { customProviderProblems } from './custom-providers.js';
+const PERMISSION_ACTIONS = new Set(['allow', 'ask', 'deny']);
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const positiveNumber = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0;
+const nonNegativeNumber = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+const stringList = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined);
+const BLOCK_KINDS = {
+    reasoning: ['hidden', 'collapsed', 'expanded'],
+    terminal: ['collapsed', 'expanded'],
+    edit: ['collapsed', 'expanded'],
+    mcp: ['collapsed', 'expanded'],
+};
+/** `display.blocks`: keep the kinds and values the chat understands, warn once about each thing it would silently ignore. */
+function cleanDisplayBlocks(config, filePath, warnings) {
+    const blocks = config.display?.blocks;
+    if (blocks === undefined)
+        return;
+    const display = config.display;
+    if (!isObject(blocks)) {
+        warnings.push(`${filePath}: display.blocks must be an object (reasoning, terminal, edit, mcp); ignored`);
+        delete display.blocks;
+        return;
+    }
+    const kept = {};
+    for (const [kind, value] of Object.entries(blocks)) {
+        const allowed = BLOCK_KINDS[kind];
+        if (!allowed)
+            warnings.push(`${filePath}: display.blocks.${kind} is not a block kind (${Object.keys(BLOCK_KINDS).join(', ')}); ignored`);
+        else if (typeof value !== 'string' || !allowed.includes(value))
+            warnings.push(`${filePath}: display.blocks.${kind} must be ${allowed.join(', ')}; ignored`);
+        else
+            kept[kind] = value;
+    }
+    if (Object.keys(kept).length)
+        display.blocks = kept;
+    else
+        delete display.blocks;
+}
+/** Validate `customProviders`, `modelOverrides`, `modelFilters` and `subagentModel`, dropping what cannot be used with one warning each. */
+function cleanProviderKeys(config, filePath, warnings) {
+    if (config.customProviders !== undefined) {
+        const raw = config.customProviders;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "customProviders" must be an object of provider id → settings; ignored`);
+            delete config.customProviders;
+        }
+        else {
+            const kept = {};
+            const bad = new Set(customProviderProblems(raw).map((p) => p.id));
+            for (const p of customProviderProblems(raw))
+                warnings.push(`${filePath}: ${p.message} Ignored.`);
+            for (const [id, value] of Object.entries(raw)) {
+                if (bad.has(id) || !isObject(value))
+                    continue;
+                const entry = { ...value };
+                if (entry.headers !== undefined && !(isObject(entry.headers) && Object.values(entry.headers).every((h) => typeof h === 'string'))) {
+                    warnings.push(`${filePath}: customProviders.${id}.headers must be text values; headers ignored`);
+                    delete entry.headers;
+                }
+                kept[id] = entry;
+            }
+            if (Object.keys(kept).length)
+                config.customProviders = kept;
+            else
+                delete config.customProviders;
+        }
+    }
+    if (config.modelOverrides !== undefined) {
+        const raw = config.modelOverrides;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "modelOverrides" must be an object of model → numbers; ignored`);
+            delete config.modelOverrides;
+        }
+        else {
+            const kept = {};
+            for (const [model, value] of Object.entries(raw)) {
+                if (!isObject(value)) {
+                    warnings.push(`${filePath}: modelOverrides.${model} must be an object; ignored`);
+                    continue;
+                }
+                const out = {};
+                const limit = isObject(value.limit) ? value.limit : undefined;
+                if (limit) {
+                    const l = {};
+                    for (const k of ['context', 'output']) {
+                        if (limit[k] === undefined)
+                            continue;
+                        if (positiveNumber(limit[k]))
+                            l[k] = limit[k];
+                        else
+                            warnings.push(`${filePath}: modelOverrides.${model}.limit.${k} must be a positive number; ignored`);
+                    }
+                    if (Object.keys(l).length)
+                        out.limit = l;
+                }
+                const cost = isObject(value.cost) ? value.cost : undefined;
+                if (cost) {
+                    const c = {};
+                    for (const k of ['input', 'output']) {
+                        if (cost[k] === undefined)
+                            continue;
+                        if (nonNegativeNumber(cost[k]))
+                            c[k] = cost[k];
+                        else
+                            warnings.push(`${filePath}: modelOverrides.${model}.cost.${k} must be a number of 0 or more; ignored`);
+                    }
+                    if (Object.keys(c).length)
+                        out.cost = c;
+                }
+                if (value.limit !== undefined && !limit)
+                    warnings.push(`${filePath}: modelOverrides.${model}.limit must be an object; ignored`);
+                if (Object.keys(out).length)
+                    kept[model] = out;
+            }
+            if (Object.keys(kept).length)
+                config.modelOverrides = kept;
+            else
+                delete config.modelOverrides;
+        }
+    }
+    if (config.modelFilters !== undefined) {
+        const raw = config.modelFilters;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "modelFilters" must be an object of provider → lists; ignored`);
+            delete config.modelFilters;
+        }
+        else {
+            const kept = {};
+            for (const [provider, value] of Object.entries(raw)) {
+                if (!isObject(value))
+                    continue;
+                const whitelist = stringList(value.whitelist);
+                const blacklist = stringList(value.blacklist);
+                if (whitelist?.length || blacklist?.length)
+                    kept[provider] = { ...(whitelist?.length ? { whitelist } : {}), ...(blacklist?.length ? { blacklist } : {}) };
+            }
+            if (Object.keys(kept).length)
+                config.modelFilters = kept;
+            else
+                delete config.modelFilters;
+        }
+    }
+    if (config.instructions !== undefined) {
+        const list = stringList(config.instructions)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.instructions = list;
+        else
+            delete config.instructions;
+    }
+    if (config.skillPaths !== undefined) {
+        const list = stringList(config.skillPaths)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.skillPaths = list;
+        else
+            delete config.skillPaths;
+    }
+    if (config.caCertificates !== undefined) {
+        const list = stringList(config.caCertificates)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.caCertificates = list;
+        else
+            delete config.caCertificates;
+    }
+    if (config.subagentModel !== undefined) {
+        const v = typeof config.subagentModel === 'string' ? config.subagentModel.trim() : '';
+        if (v)
+            config.subagentModel = v;
+        else
+            delete config.subagentModel;
+    }
+}
 /** Returns `~/.forge/config.json` for the current user. */
 export function defaultForgeConfigPath() {
     return path.join(homedir(), '.forge', 'config.json');
@@ -40,6 +211,41 @@ export async function loadForgeConfigFile(configPath) {
                 }
             }
         }
+        if (config.permission !== undefined) {
+            const raw = config.permission;
+            if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+                warnings.push(`${filePath}: "permission" must be an object of permission → action or pattern map; ignored`);
+                delete config.permission;
+            }
+            else {
+                const kept = {};
+                for (const [perm, value] of Object.entries(raw)) {
+                    if (typeof value === 'string') {
+                        if (PERMISSION_ACTIONS.has(value))
+                            kept[perm] = value;
+                        else
+                            warnings.push(`${filePath}: permission.${perm} is "${value}", not allow, ask or deny; ignored`);
+                    }
+                    else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                        const patterns = {};
+                        for (const [pattern, action] of Object.entries(value)) {
+                            if (typeof action === 'string' && PERMISSION_ACTIONS.has(action))
+                                patterns[pattern] = action;
+                            else
+                                warnings.push(`${filePath}: permission.${perm}["${pattern}"] is "${String(action)}", not allow, ask or deny; ignored`);
+                        }
+                        if (Object.keys(patterns).length)
+                            kept[perm] = patterns;
+                    }
+                    else {
+                        warnings.push(`${filePath}: permission.${perm} must be allow, ask, deny or a pattern map; ignored`);
+                    }
+                }
+                config.permission = kept;
+            }
+        }
+        cleanProviderKeys(config, filePath, warnings);
+        cleanDisplayBlocks(config, filePath, warnings);
         return { config, warnings };
     }
     catch (err) {
@@ -52,9 +258,46 @@ export async function loadForgeConfigFile(configPath) {
  */
 export async function saveForgeConfigFile(partial, configPath) {
     const filePath = configPath ?? defaultForgeConfigPath();
-    const { config: existing } = await loadForgeConfigFile(filePath);
-    const merged = { ...existing, ...partial };
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+    await updateJsonFile(filePath, (existing) => ({ ...existing, ...partial }));
+}
+const fileQueues = new Map();
+/**
+ * Read-modify-write of a JSON settings file, safely:
+ * - merged over the file as written, not the cleaned config, so keys this version drops or does not know survive;
+ * - a file that exists but is not valid JSON is never overwritten (that would replace every setting with one);
+ * - writes to one path from this process run one after another, so two saves at once both land;
+ * - written to a temporary file and renamed, so a crash cannot leave half a file.
+ */
+export function updateJsonFile(filePath, update) {
+    const key = path.resolve(filePath);
+    const run = async () => {
+        let existing = {};
+        let text;
+        try {
+            text = await readFile(filePath, 'utf8');
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        if (text !== undefined && text.trim()) {
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (err) {
+                throw new Error(`${filePath} is not valid JSON (${err.message}); fix it before saving, so your other settings are not lost`);
+            }
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error(`${filePath} must hold a JSON object; not saving over it`);
+            existing = parsed;
+        }
+        await mkdir(path.dirname(filePath), { recursive: true });
+        const tmp = `${filePath}.${process.pid}.tmp`;
+        await writeFile(tmp, JSON.stringify(update(existing), null, 2) + '\n', 'utf8');
+        await rename(tmp, filePath);
+    };
+    const next = (fileQueues.get(key) ?? Promise.resolve()).then(run, run);
+    fileQueues.set(key, next.catch(() => undefined));
+    return next;
 }
-//# sourceMappingURL=config-file.js.map

package/dist/config-merge.d.ts

@@ -0,0 +1,13 @@
+import { type ForgeConfigFile, type LoadForgeConfigFileResult } from './config-file.js';
+/**
+ * The shared config as one object: `~/.forge/config.json`, then the workspace's `.forge/config.json` on top.
+ * A project file can pick the model and add stricter rules, but it can never loosen what the user decided:
+ * its `allow` permission rules are dropped, and the keys that hold approvals or delete data are only read
+ * from the user file. An untrusted workspace contributes nothing.
+ */
+export declare function projectConfigPath(cwd: string): string;
+export declare const USER_ONLY_CONFIG_KEYS: ReadonlyArray<keyof ForgeConfigFile>;
+export declare function loadMergedForgeConfig(cwd: string, opts: {
+    trusted: boolean;
+    userPath?: string;
+}): Promise<LoadForgeConfigFileResult>;

package/dist/config-merge.js

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { loadForgeConfigFile } from './config-file.js';
+/**
+ * The shared config as one object: `~/.forge/config.json`, then the workspace's `.forge/config.json` on top.
+ * A project file can pick the model and add stricter rules, but it can never loosen what the user decided:
+ * its `allow` permission rules are dropped, and the keys that hold approvals or delete data are only read
+ * from the user file. An untrusted workspace contributes nothing.
+ */
+export function projectConfigPath(cwd) {
+    return path.join(cwd, '.forge', 'config.json');
+}
+// customProviders is user-only because an entry names a URL and the environment variable whose value is sent there:
+// a repository must not be able to point a key at a host of its choosing.
+export const USER_ONLY_CONFIG_KEYS = ['autoApproveTools', 'autoApproveCommands', 'sessionRetentionDays', 'customProviders', 'instructions', 'skillPaths', 'caCertificates'];
+export async function loadMergedForgeConfig(cwd, opts) {
+    const user = await loadForgeConfigFile(opts.userPath);
+    const file = projectConfigPath(cwd);
+    if (!opts.trusted || !existsSync(file))
+        return user;
+    const project = await loadForgeConfigFile(file);
+    const warnings = [...user.warnings, ...project.warnings];
+    const p = project.config;
+    const merged = { ...user.config };
+    for (const key of USER_ONLY_CONFIG_KEYS) {
+        if (p[key] !== undefined)
+            warnings.push(`${file}: "${key}" is only read from the user config (~/.forge/config.json); ignored`);
+    }
+    for (const key of ['provider', 'model', 'completionModel', 'compactionModel', 'reasoningEffort', 'subagentModel']) {
+        if (p[key] !== undefined)
+            merged[key] = p[key];
+    }
+    if (p.modelOverrides)
+        merged.modelOverrides = { ...user.config.modelOverrides, ...p.modelOverrides };
+    if (p.aliases)
+        merged.aliases = { ...user.config.aliases, ...p.aliases };
+    if (p.modeModels)
+        merged.modeModels = { ...user.config.modeModels, ...p.modeModels };
+    if (p.display)
+        merged.display = { ...user.config.display, ...p.display };
+    if (p.disabledProviders)
+        merged.disabledProviders = [...new Set([...(user.config.disabledProviders ?? []), ...p.disabledProviders])];
+    if (p.permission) {
+        const permission = tighten(user.config.permission, p.permission);
+        if (permission)
+            merged.permission = permission;
+    }
+    return { config: merged, warnings };
+}
+/** User rules first, then the project's `ask` and `deny` rules (an `allow` is dropped), each after everything of the user's. */
+function tighten(user, project) {
+    const out = { ...(user ?? {}) };
+    for (const [permission, value] of Object.entries(project)) {
+        const rules = typeof value === 'string' ? [['*', value]] : Object.entries(value);
+        const kept = rules.filter(([, action]) => action !== 'allow');
+        if (kept.length === 0)
+            continue;
+        const existing = out[permission];
+        const target = typeof existing === 'string' ? { '*': existing } : { ...(existing ?? {}) };
+        for (const [pattern, action] of kept) {
+            delete target[pattern];
+            target[pattern] = action;
+        }
+        out[permission] = target;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}