@borgee/agents-host 0.2.84 → 0.2.94

package/dist/vendor/claude-agent-acp/dist/elicitation.js

@@ -0,0 +1,304 @@
+import { randomUUID } from "node:crypto";
+import { CreateElicitationResponse } from "@agentclientprotocol/sdk";
+/**
+ * Convert an MCP elicitation request (from the SDK's `onElicitation` callback)
+ * into an ACP `CreateElicitationRequest`. Returns `null` when the request can't
+ * be represented (e.g. a url-mode request with no url).
+ */
+export function mcpElicitationToCreateRequest(request, sessionId) {
+    if (request.mode === "url") {
+        if (!request.url) {
+            return null;
+        }
+        return {
+            mode: "url",
+            sessionId,
+            message: request.message,
+            url: request.url,
+            // URL elicitations need a stable id so the client can correlate the
+            // later `session/complete_elicitation` notification. MCP servers usually
+            // provide one; fall back to a generated id if not.
+            elicitationId: request.elicitationId ?? randomUUID(),
+        };
+    }
+    // Form mode (the default). The MCP `requestedSchema` is already a JSON Schema
+    // with primitive-typed properties, which is structurally what ACP expects.
+    return {
+        mode: "form",
+        sessionId,
+        message: request.message,
+        requestedSchema: normalizeElicitationSchema(request.requestedSchema),
+    };
+}
+/**
+ * Content of an accepted elicitation response.
+ *
+ * Uses the SDK's validating guard rather than an `action === "accept"` check:
+ * the guard both narrows past the union's custom/future variant and validates
+ * the payload, so a malformed accept (right tag, ill-typed content) yields
+ * empty content — the same classification the SDK's wire validators apply.
+ */
+function acceptedElicitationContent(response) {
+    return CreateElicitationResponse.isAccept(response) ? (response.content ?? {}) : {};
+}
+/**
+ * Map an ACP elicitation response back to the MCP `ElicitResult` the SDK expects
+ * to hand back to the requesting server.
+ */
+export function createElicitationResponseToElicitResult(response) {
+    switch (response.action) {
+        case "accept":
+            return { action: "accept", content: acceptedElicitationContent(response) };
+        case "decline":
+            return { action: "decline" };
+        case "cancel":
+        default:
+            return { action: "cancel" };
+    }
+}
+/**
+ * Pull the well-formed questions out of an AskUserQuestion tool input. Returns
+ * `null` when there are no usable questions — including the case where every
+ * entry is malformed and filtering leaves an empty list — so callers can treat
+ * "nothing to ask" uniformly.
+ */
+export function extractAskUserQuestions(input) {
+    const questions = input.questions;
+    if (!Array.isArray(questions)) {
+        return null;
+    }
+    const valid = questions.filter((q) => !!q && typeof q.question === "string" && Array.isArray(q.options) && q.options.length > 0);
+    return valid.length > 0 ? valid : null;
+}
+/** Stable form-field key for the question at the given index. */
+function questionFieldKey(index) {
+    return `question_${index}`;
+}
+/**
+ * Form-field key for the per-question free-text "custom answer" field that sits
+ * alongside `question_<n>`. Mirrors the first-party clients, where every
+ * question carries its own "Other" box rather than one form-level field.
+ */
+function questionCustomFieldKey(index) {
+    return `question_${index}_custom`;
+}
+/**
+ * `_meta` key under which a bridged enum option carries its `preview`, the one
+ * option field ACP's `EnumOption` still has no slot for (descriptions are
+ * first-class as of schema 1.19). Namespaced like the agent's other `_meta`
+ * extensions (`_claude/...`).
+ */
+const OPTION_META_KEY = "_claude/askUserQuestionOption";
+/**
+ * Shared `_meta` key for marking a per-question free-text field as the custom
+ * answer companion for a select question. This intentionally has no
+ * agent-specific namespace so ACP clients can recognize the same marker across
+ * Codex, Claude, and other AskUserQuestion bridges.
+ */
+const CUSTOM_ANSWER_META_KEY = "_askUserQuestionCustomAnswer";
+/**
+ * Render the AskUserQuestion tool's questions as an ACP form elicitation.
+ *
+ * Fields are keyed by a short stable id (`question_<n>`) rather than the full
+ * question text, so the question text appears in exactly one place per field.
+ * Single-select questions use a titled `oneOf` enum; multi-select questions use
+ * an array with a titled `anyOf` item enum. The enum `const` is always the
+ * option label, since that is what the tool records as the answer; an option's
+ * secondary text travels in the enum option's own `description` field.
+ *
+ * Each question is followed by its own optional free-text "custom answer" field
+ * (`question_<n>_custom`), mirroring the CLI's per-question "Other" box: the
+ * user can type their own answer instead of picking an option, scoped to that
+ * specific question. Nothing is marked required, so the user can also just skip
+ * — matching the built-in tool, which always offers Skip + a free-text box.
+ */
+export function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId) {
+    const single = questions.length === 1;
+    const properties = {};
+    questions.forEach((question, index) => {
+        const options = question.options.map((option) => {
+            const enumOption = {
+                const: option.label,
+                title: option.label,
+            };
+            if (option.description) {
+                enumOption.description = option.description;
+            }
+            // The SDK option's `preview` (mockups, code snippets, comparisons shown
+            // on focus) still has no structural slot in `EnumOption`, so forward it
+            // under ACP's reserved `_meta` extension point for clients that render it.
+            if (option.preview) {
+                enumOption._meta = { [OPTION_META_KEY]: { preview: option.preview } };
+            }
+            return enumOption;
+        });
+        // For a single question the prompt is carried by `message`, so we don't
+        // repeat it in the field description. With multiple questions each field
+        // needs its own question text.
+        const description = single ? undefined : question.question;
+        const title = question.header || undefined;
+        properties[questionFieldKey(index)] = question.multiSelect
+            ? { type: "array", title, description, items: { anyOf: options } }
+            : { type: "string", title, description, oneOf: options };
+        properties[questionCustomFieldKey(index)] = {
+            type: "string",
+            title: "Other",
+            description: "Type your own answer instead of choosing an option above (optional).",
+            _meta: {
+                [CUSTOM_ANSWER_META_KEY]: {
+                    questionId: questionFieldKey(index),
+                    isCustomAnswer: true,
+                },
+            },
+        };
+    });
+    const requestedSchema = {
+        type: "object",
+        properties,
+    };
+    const message = single ? questions[0].question : "Please answer the following questions.";
+    return {
+        mode: "form",
+        sessionId,
+        ...(toolCallId ? { toolCallId } : {}),
+        message,
+        requestedSchema,
+    };
+}
+/**
+ * Fold an ACP elicitation response into the AskUserQuestion tool's input.
+ *
+ * Selected labels are read back from the indexed form fields and written into
+ * `answers` as a `{ [questionText]: label }` map (comma-joining multi-selects)
+ * — the key shape the tool's own `call()` reads. A non-empty per-question
+ * custom-answer field (`question_<n>_custom`) takes precedence over that
+ * question's selection, since the user typed their own answer instead of
+ * picking one. Decline yields empty answers (the model is told the user skipped
+ * rather than the turn aborting); cancel — and any custom/future action we
+ * don't understand — aborts the tool call.
+ */
+export function applyAskElicitationResponse(response, toolInput, questions) {
+    if (response.action === "decline") {
+        return { action: "answered", updatedInput: { ...toolInput, answers: {} } };
+    }
+    if (response.action !== "accept") {
+        return { action: "cancel" };
+    }
+    const content = acceptedElicitationContent(response);
+    // Typed against the tool's own output schema so the answer/response shapes
+    // stay in sync with what the built-in tool's call() expects to read back.
+    const answers = {};
+    questions.forEach((question, index) => {
+        // A typed custom answer wins over the selection: the user chose to write
+        // their own answer for this question instead of picking an option.
+        const custom = content[questionCustomFieldKey(index)];
+        if (typeof custom === "string" && custom.trim() !== "") {
+            answers[question.question] = custom.trim();
+            return;
+        }
+        const value = content[questionFieldKey(index)];
+        if (value === undefined || value === null) {
+            return;
+        }
+        const text = Array.isArray(value) ? value.join(", ") : String(value);
+        if (text === "") {
+            return;
+        }
+        answers[question.question] = text;
+    });
+    return { action: "answered", updatedInput: { ...toolInput, answers } };
+}
+/**
+ * Coerce an arbitrary MCP `requestedSchema` into an ACP `ElicitationSchema`.
+ * The two are structurally compatible JSON Schemas; we just guarantee the
+ * `type: "object"` discriminator is present.
+ */
+function normalizeElicitationSchema(schema) {
+    if (!schema || typeof schema !== "object") {
+        return { type: "object", properties: {} };
+    }
+    return { ...schema, type: "object" };
+}
+/**
+ * The `request_user_dialog` kind the CLI emits when a model refusal has a
+ * fallback available but needs user consent before retrying (e.g. Claude Fable
+ * declining a request with Opus available as the fallback). Declaring this
+ * kind in `supportedDialogKinds` is the opt-in: the CLI fails closed and never
+ * emits an undeclared kind — the flow degrades to the classic refusal error
+ * ending the turn.
+ */
+export const REFUSAL_FALLBACK_DIALOG_KIND = "refusal_fallback_prompt";
+/**
+ * Validate the opaque dialog payload into a {@link RefusalFallbackPrompt}.
+ * Returns `null` when the required fields are missing or mistyped (a newer CLI
+ * may reshape the payload), so the caller can cancel the dialog and let the
+ * CLI apply its default behavior instead of rendering something misleading.
+ */
+export function extractRefusalFallbackPrompt(payload) {
+    const { originalModel, fallbackModel, apiRefusalCategory, guidanceText } = payload;
+    if (typeof originalModel !== "string" || typeof fallbackModel !== "string") {
+        return null;
+    }
+    return {
+        originalModel,
+        fallbackModel,
+        apiRefusalCategory: typeof apiRefusalCategory === "string" ? apiRefusalCategory : null,
+        ...(typeof guidanceText === "string" && guidanceText ? { guidanceText } : {}),
+    };
+}
+/** Form-field key carrying the user's choice in the refusal-fallback form. */
+const REFUSAL_FALLBACK_CHOICE_KEY = "choice";
+/** Wire values of the dialog's result enum (CLI schema). `edit_prompt` is
+ *  deliberately not offered: in the CLI it prefills the composer with the
+ *  refused prompt for edit-and-retry, and ACP has no composer-prefill surface
+ *  — the user can simply edit and resend on their own. */
+const RETRY_FALLBACK_RESULT = "retry_fallback";
+const KEEP_REFUSAL_RESULT = "cancelled";
+/**
+ * Render the refusal-fallback consent prompt as an ACP form elicitation: a
+ * single-select between retrying on the fallback model and keeping the
+ * refusal. The enum `const`s are the dialog's wire result values, so the
+ * response maps back without a translation table.
+ */
+export function refusalFallbackToCreateRequest(prompt, sessionId) {
+    const category = prompt.apiRefusalCategory ? ` (${prompt.apiRefusalCategory})` : "";
+    const guidance = prompt.guidanceText ? `\n\n${prompt.guidanceText}` : "";
+    return {
+        mode: "form",
+        sessionId,
+        message: `${prompt.originalModel} declined this request${category}. ` +
+            `Retry with ${prompt.fallbackModel}?` +
+            guidance,
+        requestedSchema: {
+            type: "object",
+            properties: {
+                [REFUSAL_FALLBACK_CHOICE_KEY]: {
+                    type: "string",
+                    oneOf: [
+                        {
+                            const: RETRY_FALLBACK_RESULT,
+                            title: `Retry with ${prompt.fallbackModel}`,
+                            description: `The session continues on ${prompt.fallbackModel}.`,
+                        },
+                        {
+                            const: KEEP_REFUSAL_RESULT,
+                            title: "Keep the refusal",
+                            description: "You can send a new message.",
+                        },
+                    ],
+                },
+            },
+        },
+    };
+}
+/**
+ * Map the elicitation response back to the dialog's result enum. Only an
+ * explicit accept-with-retry resolves to `retry_fallback`; decline, cancel, a
+ * skipped field, or an unrecognized value all keep the refusal — the dialog's
+ * own default — so a dismissed or half-filled form can never trigger a model
+ * switch the user didn't ask for.
+ */
+export function refusalFallbackResultFromResponse(response) {
+    const choice = acceptedElicitationContent(response)[REFUSAL_FALLBACK_CHOICE_KEY];
+    return choice === RETRY_FALLBACK_RESULT ? RETRY_FALLBACK_RESULT : KEEP_REFUSAL_RESULT;
+}

package/dist/vendor/claude-agent-acp/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/claude-agent-acp/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/vendor/claude-agent-acp/dist/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { resolveSettings } from "@anthropic-ai/claude-agent-sdk";
+import { claudeCliPath, runAcp } from "./acp-agent.js";
+import packageJson from "../package.json" with { type: "json" };
+// `--cli` is checked first so that `--version`/`-v` (and any other flags) are
+// forwarded to the wrapped native CLI rather than swallowed by our own version
+// handler below. Our version flag only applies when not delegating.
+if (process.argv.includes("--cli")) {
+    const { spawn } = await import("node:child_process");
+    const args = process.argv.slice(2).filter((arg) => arg !== "--cli");
+    const child = spawn(await claudeCliPath(), args, { stdio: "inherit" });
+    const signals = process.platform === "win32"
+        ? ["SIGINT", "SIGTERM"]
+        : ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const sig of signals) {
+        process.on(sig, () => {
+            if (!child.killed)
+                child.kill(sig);
+        });
+    }
+    child.on("exit", (code, signal) => {
+        if (signal && process.platform !== "win32") {
+            // Remove our listener so re-raising actually terminates instead of
+            // re-entering the no-op handler, which would let us exit with code 0
+            // instead of the signal's conventional 128+N.
+            process.removeAllListeners(signal);
+            process.kill(process.pid, signal);
+        }
+        else {
+            process.exit(code ?? 1);
+        }
+    });
+    child.on("error", (err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+else if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    console.log(packageJson.version);
+    process.exit(0);
+}
+else {
+    // Apply env vars from the managed-policy tier before any SDK call so the
+    // SDK subprocess inherits them. Going through resolveSettings (vs. a raw
+    // read of managed-settings.json) also picks up MDM sources on macOS and
+    // HKLM/HKCU on Windows.
+    const policy = await resolveSettings({ settingSources: [] });
+    for (const [key, value] of Object.entries(policy.effective.env ?? {})) {
+        process.env[key] = value;
+    }
+    // stdout is used to send messages to the client
+    // we redirect everything else to stderr to make sure it doesn't interfere with ACP
+    console.log = console.error;
+    console.info = console.error;
+    console.warn = console.error;
+    console.debug = console.error;
+    process.on("unhandledRejection", (reason, promise) => {
+        console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    const { connection, agent } = runAcp();
+    async function shutdown() {
+        await agent.dispose().catch((err) => {
+            console.error("Error during cleanup:", err);
+        });
+        process.exit(0);
+    }
+    // Exit cleanly when the ACP connection closes (e.g. stdin EOF, transport
+    // error). Without this, `process.stdin.resume()` keeps the event loop
+    // alive indefinitely, causing orphan process accumulation in oneshot mode.
+    connection.closed.then(shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    // Keep process alive while connection is open
+    process.stdin.resume();
+}

package/dist/vendor/claude-agent-acp/dist/lib.d.ts

@@ -0,0 +1,6 @@
+export { ClaudeAcpAgent, isLocalCommandMetadata, stripLocalCommandMetadata, runAcp, toAcpNotifications, streamEventToAcpNotifications, type ToolUpdateMeta, type NewSessionMeta, type SDKMessageFilter, } from "./acp-agent.js";
+export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
+export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
+export { SettingsManager, type SettingsManagerOptions } from "./settings.js";
+export type { ClaudePlanEntry } from "./tools.js";
+//# sourceMappingURL=lib.d.ts.map

package/dist/vendor/claude-agent-acp/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,yBAAyB,EACzB,MAAM,EACN,kBAAkB,EAClB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG7E,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/vendor/claude-agent-acp/dist/lib.js

@@ -0,0 +1,5 @@
+// Export the main agent class and utilities for library usage
+export { ClaudeAcpAgent, isLocalCommandMetadata, stripLocalCommandMetadata, runAcp, toAcpNotifications, streamEventToAcpNotifications, } from "./acp-agent.js";
+export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
+export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
+export { SettingsManager } from "./settings.js";

package/dist/vendor/claude-agent-acp/dist/settings.d.ts

@@ -0,0 +1,68 @@
+import { type Settings } from "@anthropic-ai/claude-agent-sdk";
+export interface SettingsManagerOptions {
+    onChange?: () => void;
+    logger?: {
+        log: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+}
+/**
+ * Manages Claude Code settings using the SDK's `resolveSettings` merge engine
+ * so the values we see match what `query()` would observe.
+ *
+ * Watches the user/project/local/managed settings files for changes and
+ * re-resolves through the SDK on update. Escalating `permissions.defaultMode`
+ * values from repo-committed sources are filtered out via
+ * `filterEscalatingDefaultMode`, matching the CLI's trust policy.
+ */
+export declare class SettingsManager {
+    private cwd;
+    private effective;
+    private watchers;
+    private onChange?;
+    private logger;
+    private initialized;
+    private disposed;
+    private debounceTimer;
+    private initPromise;
+    constructor(cwd: string, options?: SettingsManagerOptions);
+    /**
+     * Initialize the settings manager by loading all settings and setting up file watchers
+     */
+    initialize(): Promise<void>;
+    /**
+     * Paths the SDK reads when resolving settings for this cwd. Watching the
+     * containing directories means we pick up file creation as well as edits.
+     */
+    private getWatchedPaths;
+    /**
+     * Resolves the effective settings via the SDK and applies the CLI's trust
+     * filter for escalating `permissions.defaultMode` values.
+     */
+    private loadAllSettings;
+    /**
+     * Sets up file watchers for all settings files
+     */
+    private setupWatchers;
+    /**
+     * Handles settings file changes with debouncing to avoid rapid reloads
+     */
+    private handleSettingsChange;
+    /**
+     * Returns the current merged settings
+     */
+    getSettings(): Settings;
+    /**
+     * Returns the current working directory
+     */
+    getCwd(): string;
+    /**
+     * Updates the working directory and reloads project-specific settings
+     */
+    setCwd(cwd: string): Promise<void>;
+    /**
+     * Disposes of file watchers and cleans up resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=settings.d.ts.map

package/dist/vendor/claude-agent-acp/dist/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,gCAAgC,CAAC;AA0BxC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAqE;IACnF,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,WAAW,CAA8B;gBAErC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAMzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBjC;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;YACW,eAAe;IAU7B;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB"}

package/dist/vendor/claude-agent-acp/dist/settings.js

@@ -0,0 +1,185 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+// resolveSettings and filterEscalatingDefaultMode are marked @alpha in the
+// SDK; API may shift in a future release.
+import { filterEscalatingDefaultMode, resolveSettings, } from "@anthropic-ai/claude-agent-sdk";
+import { CLAUDE_CONFIG_DIR } from "./acp-agent.js";
+/**
+ * Permission rule format examples:
+ * - "Read" - matches all Read tool calls
+ * - "Read(./.env)" - matches specific path
+ * - "Read(./.env.*)" - glob pattern
+ * - "Read(./secrets/**)" - recursive glob
+ * - "Bash(npm run lint)" - exact command prefix
+ * - "Bash(npm run:*)" - command prefix with wildcard
+ *
+ * Docs: https://code.claude.com/docs/en/iam#tool-specific-permission-rules
+ */
+function getManagedSettingsPath() {
+    switch (process.platform) {
+        case "darwin":
+            return "/Library/Application Support/ClaudeCode/managed-settings.json";
+        case "win32":
+            return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
+        default:
+            return "/etc/claude-code/managed-settings.json";
+    }
+}
+/**
+ * Manages Claude Code settings using the SDK's `resolveSettings` merge engine
+ * so the values we see match what `query()` would observe.
+ *
+ * Watches the user/project/local/managed settings files for changes and
+ * re-resolves through the SDK on update. Escalating `permissions.defaultMode`
+ * values from repo-committed sources are filtered out via
+ * `filterEscalatingDefaultMode`, matching the CLI's trust policy.
+ */
+export class SettingsManager {
+    cwd;
+    effective = {};
+    watchers = [];
+    onChange;
+    logger;
+    initialized = false;
+    disposed = false;
+    debounceTimer = null;
+    initPromise = null;
+    constructor(cwd, options) {
+        this.cwd = cwd;
+        this.onChange = options?.onChange;
+        this.logger = options?.logger ?? console;
+    }
+    /**
+     * Initialize the settings manager by loading all settings and setting up file watchers
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.disposed = false;
+        this.initPromise = this.loadAllSettings().then(() => {
+            if (!this.disposed) {
+                this.setupWatchers();
+                this.initialized = true;
+            }
+            this.initPromise = null;
+        });
+        return this.initPromise;
+    }
+    /**
+     * Paths the SDK reads when resolving settings for this cwd. Watching the
+     * containing directories means we pick up file creation as well as edits.
+     */
+    getWatchedPaths() {
+        return [
+            path.join(CLAUDE_CONFIG_DIR, "settings.json"),
+            path.join(this.cwd, ".claude", "settings.json"),
+            path.join(this.cwd, ".claude", "settings.local.json"),
+            getManagedSettingsPath(),
+        ];
+    }
+    /**
+     * Resolves the effective settings via the SDK and applies the CLI's trust
+     * filter for escalating `permissions.defaultMode` values.
+     */
+    async loadAllSettings() {
+        try {
+            const resolved = await resolveSettings({ cwd: this.cwd });
+            this.effective = filterEscalatingDefaultMode(resolved);
+        }
+        catch (error) {
+            this.logger.error("Failed to resolve settings:", error);
+            this.effective = {};
+        }
+    }
+    /**
+     * Sets up file watchers for all settings files
+     */
+    setupWatchers() {
+        for (const filePath of this.getWatchedPaths()) {
+            try {
+                const dir = path.dirname(filePath);
+                const filename = path.basename(filePath);
+                if (fs.existsSync(dir)) {
+                    const watcher = fs.watch(dir, (eventType, changedFilename) => {
+                        if (changedFilename === filename) {
+                            this.handleSettingsChange();
+                        }
+                    });
+                    watcher.on("error", (error) => {
+                        this.logger.error(`Settings watcher error for ${filePath}:`, error);
+                    });
+                    this.watchers.push(watcher);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to set up watcher for ${filePath}:`, error);
+            }
+        }
+    }
+    /**
+     * Handles settings file changes with debouncing to avoid rapid reloads
+     */
+    handleSettingsChange() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(async () => {
+            this.debounceTimer = null;
+            if (this.disposed) {
+                return;
+            }
+            try {
+                await this.loadAllSettings();
+                if (!this.disposed) {
+                    this.onChange?.();
+                }
+            }
+            catch (error) {
+                this.logger.error("Failed to reload settings:", error);
+            }
+        }, 100);
+    }
+    /**
+     * Returns the current merged settings
+     */
+    getSettings() {
+        return this.effective;
+    }
+    /**
+     * Returns the current working directory
+     */
+    getCwd() {
+        return this.cwd;
+    }
+    /**
+     * Updates the working directory and reloads project-specific settings
+     */
+    async setCwd(cwd) {
+        if (this.cwd === cwd) {
+            return;
+        }
+        this.dispose();
+        this.cwd = cwd;
+        await this.initialize();
+    }
+    /**
+     * Disposes of file watchers and cleans up resources
+     */
+    dispose() {
+        this.disposed = true;
+        this.initialized = false;
+        this.initPromise = null;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.watchers = [];
+    }
+}