@gajae-code/coding-agent 0.10.2 → 0.11.1

package/dist/types/config/settings.d.ts

@@ -1,19 +1,10 @@
-/**
- * Settings singleton with sync get/set and background persistence.
- *
- * Usage:
- *   import { settings } from "./settings";
- *
- *   const enabled = settings.get("compaction.enabled");  // sync read
- *   settings.set("theme.dark", "red-claw");              // sync write, saves in background
- *
- * For tests:
- *   const isolated = Settings.isolated({ "compaction.enabled": false });
- */
 import { procmgr } from "@gajae-code/utils";
 import type { ModelRole } from "../config/model-registry";
+import type { NotificationSettingsReader, NotificationSettingsSnapshot } from "../sdk/bus/config";
 import { AgentStorage } from "../session/agent-storage";
 import { type EditMode } from "../utils/edit-mode";
+import { type CasReceipt } from "./atomic-yaml-patch";
+import { type ModelSelectorValue } from "./model-selector-value";
 import { type BashInterceptorRule, type GroupPrefix, type GroupTypeMap, type SettingPath, type SettingValue } from "./settings-schema";
 export type * from "./settings-schema";
 export * from "./settings-schema";
@@ -21,6 +12,22 @@ export * from "./settings-schema";
 export interface RawSettings {
     [key: string]: unknown;
 }
+export type SettingsAtomicPatch = {
+    path: SettingPath;
+    op: "set";
+    value: unknown;
+} | {
+    path: SettingPath;
+    op: "unset";
+};
+export type SettingsAtomicReceipt = CasReceipt;
+export interface GlobalDefaultModelRoleCommit {
+    readonly previousDefault: ModelSelectorValue | undefined;
+    readonly previousModelRolesExisted: boolean;
+    readonly committedDefault: ModelSelectorValue | undefined;
+    readonly committedConfigVersion?: string;
+    readonly defaultRevision: number;
+}
 export interface SettingsOptions {
     /** Current working directory for project settings discovery */
     cwd?: string;
@@ -31,7 +38,17 @@ export interface SettingsOptions {
     /** Initial overrides */
     overrides?: Partial<Record<SettingPath, unknown>>;
 }
-export declare class Settings {
+/** Additional layer setup for {@link Settings.isolated}. */
+export interface IsolatedSettingsOptions {
+    /** Initial runtime overrides. Notification paths are rejected. */
+    overrides?: Partial<Record<SettingPath, unknown>>;
+}
+/** Raised when an ephemeral override attempts to change global-only notification settings. */
+export declare class NotificationSettingsOverrideError extends Error {
+    readonly path: SettingPath;
+    constructor(path: SettingPath);
+}
+export declare class Settings implements NotificationSettingsReader {
     #private;
     private constructor();
     /**
@@ -40,10 +57,10 @@ export declare class Settings {
      */
     static init(options?: SettingsOptions): Promise<Settings>;
     /**
-     * Create an isolated instance for testing.
+     * Create an isolated instance for testing with explicit user/global settings.
      * Does not affect the global singleton.
      */
-    static isolated(overrides?: Partial<Record<SettingPath, unknown>>): Settings;
+    static isolated(globalSettings?: Partial<Record<SettingPath, unknown>>, options?: IsolatedSettingsOptions): Settings;
     /**
      * Get the global singleton.
      * Throws if not initialized.
@@ -61,14 +78,32 @@ export declare class Settings {
      * activated by project-scoped config files.
      */
     getGlobal<P extends SettingPath>(path: P): SettingValue<P> | undefined;
+    /**
+     * Read the remote-notification settings from the user/global layer only.
+     * Schema defaults are applied per path; project settings and runtime overrides
+     * are deliberately excluded from this trust boundary.
+     */
+    getNotificationSettingsSnapshot(): NotificationSettingsSnapshot;
     /** Check whether a setting is present in loaded settings/overrides rather than coming from schema defaults. */
     has(path: SettingPath): boolean;
     /**
      * Set a setting value (sync).
-     * Updates global settings and queues a background save.
-     * Triggers hooks for settings that have side effects.
+     * Updates global settings and reserves its background persistence slot before
+     * returning, so later durable batches cannot overtake this mutation.
      */
-    set<P extends SettingPath>(path: P, value: SettingValue<P>): void;
+    set<P extends SettingPath>(path: P, value: SettingValue<P> | undefined): void;
+    /**
+     * Delete a global setting (sync), rather than serializing an ambiguous YAML
+     * `undefined` value. Defaults/project settings become visible immediately.
+     */
+    unset<P extends SettingPath>(path: P): void;
+    /**
+     * Persist a tagged batch as one atomic YAML replacement. Unlike ordinary
+     * {@link set}, canonical state and hooks change only after the rename succeeds.
+     */
+    commitAtomicBatch(patches: readonly SettingsAtomicPatch[]): Promise<CasReceipt>;
+    /** Build a durable batch from the current on-disk YAML under the shared queue and file lock. */
+    commitAtomicBatchWithCurrent(buildPatches: (current: Readonly<RawSettings>) => Promise<readonly SettingsAtomicPatch[]> | readonly SettingsAtomicPatch[]): Promise<CasReceipt>;
     /**
      * Apply runtime overrides (not persisted).
      */
@@ -77,17 +112,9 @@ export declare class Settings {
      * Clear a runtime override.
      */
     clearOverride(path: SettingPath): void;
-    /**
-     * Flush any pending saves to disk.
-     * Call before exit to ensure all changes are persisted.
-     */
+    /** Flush a reserved debounced save without allowing it to be overtaken. */
     flush(): Promise<void>;
-    /**
-     * Like {@link flush}, but rejects if the durable save fails instead of
-     * swallowing the error. Use where the caller must confirm persistence before
-     * reporting success (e.g. the Telegram `/rich` toggle). In-memory instances
-     * ({@link isolated}) short-circuit in {@link #saveNow} and never throw.
-     */
+    /** Like {@link flush}, but reports a durable save failure to the caller. */
     flushOrThrow(): Promise<void>;
     cloneForCwd(cwd: string): Promise<Settings>;
     getStorage(): AgentStorage | null;
@@ -114,9 +141,10 @@ export declare class Settings {
     /**
      * Set a model role (helper for modelRoles record).
      */
-    setModelRole(role: ModelRole | string, modelId: string): void;
-    setGlobalModelRole(role: ModelRole | string, modelId: string | undefined): void;
-    setGlobalModelRoleAndFlush(role: ModelRole | string, modelId: string | undefined): Promise<void>;
+    setModelRole(role: ModelRole | string, modelId: ModelSelectorValue): void;
+    setGlobalModelRole(role: ModelRole | string, modelId: ModelSelectorValue | undefined): void;
+    setGlobalModelRoleAndFlush(role: ModelRole | string, modelId: ModelSelectorValue | undefined): Promise<GlobalDefaultModelRoleCommit>;
+    restoreGlobalDefaultModelRoleIfCurrent(commit: GlobalDefaultModelRoleCommit): Promise<boolean>;
     /**
      * Set an agent model override while keeping any live runtime override aligned.
      *
@@ -124,16 +152,16 @@ export declare class Settings {
      * session. A user-selected role assignment must win immediately in that same
      * session, but only the explicit agent change should be persisted.
      */
-    setAgentModelOverride(agentName: string, modelId: string): void;
+    setAgentModelOverride(agentName: string, modelId: ModelSelectorValue): void;
     /**
      * Get a model role (helper for modelRoles record).
      */
-    getModelRole(role: ModelRole | string): string | undefined;
+    getModelRole(role: ModelRole | string): ModelSelectorValue | undefined;
     /**
      * Get all model roles (helper for modelRoles record).
      */
-    getModelRoles(): ReadOnlyDict<string>;
-    overrideModelRoles(roles: ReadOnlyDict<string>): void;
+    getModelRoles(): Readonly<Record<string, ModelSelectorValue>>;
+    overrideModelRoles(roles: Readonly<Record<string, ModelSelectorValue>>): void;
     /**
      * Set disabled providers (for compatibility with discovery system).
      */

package/dist/types/coordinator-mcp/model-preset.d.ts

@@ -1,11 +1,12 @@
-import { type ModelProfileDefinition } from "../config/model-profiles";
+export interface CoordinatorModelProfile {
+    name: string;
+}
 /**
- * Loads the merged built-in + custom model-profile registry the way the `gjc`
- * CLI resolves `--mpreset`, so coordinator MCP launches select the same
- * authoritative profile the spawned child will activate. Custom profiles live
- * in the shared models config, which the child inherits, so both sides agree.
+ * Loads the merged built-in + custom model-profile names from `models.yml`
+ * without loading the session-host model registry. The child still owns
+ * profile activation; this validates the selection before session creation.
  */
-export type CoordinatorModelProfileLoader = () => Map<string, ModelProfileDefinition> | Promise<Map<string, ModelProfileDefinition>>;
+export type CoordinatorModelProfileLoader = () => Map<string, CoordinatorModelProfile> | Promise<Map<string, CoordinatorModelProfile>>;
 /**
  * Thrown by the default loader when `models.yml` exists but is invalid or
  * unreadable. This lets the resolver fail closed with a distinct, stable reason

package/dist/types/coordinator-mcp/server.d.ts

@@ -1,5 +1,5 @@
 import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
-import { type OwnerIsolationProbe } from "../gjc-runtime/tmux-owner-isolation";
+import { SdkClient } from "../sdk/client/client";
 import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
 import { type SessionReaper } from "./session-reaper";
@@ -22,71 +22,28 @@ interface JsonRpcResponse {
         data?: unknown;
     };
 }
-interface SessionStartInput {
-    cwd: string;
-    prompt?: string;
-    mpreset?: string | null;
-    namespace: {
-        profile: string | null;
-        repo: string | null;
-    };
-    worktree: true;
-    sessionId: string;
-    launchId: string;
-    /** Canonical, coordinator-owned immutable readiness marker path. */
-    readinessMarkerFile: string;
-    /** @deprecated Compatibility alias for injected launch providers. */
-    readinessFile: string;
-}
-interface CommandResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}
-type CommandRunner = (command: string[], stdinLine?: string) => Promise<CommandResult>;
 interface CoordinatorServices {
-    listSessions?: () => unknown[] | Promise<unknown[]>;
-    startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
-    commandRunner?: CommandRunner;
-    forceCloseSession?: (sessionName: string, env: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string) => Promise<unknown>;
-    ownerIsolationProbe?: OwnerIsolationProbe;
+    connectSdk?: (url: string, token: string) => Promise<SdkClient>;
+    getAgentDir?: () => string;
     resolveModelProfiles?: CoordinatorModelProfileLoader;
+    canonicalizePath?: (value: string) => Promise<string>;
 }
 interface CoordinatorMcpServerOptions {
     env?: NodeJS.ProcessEnv;
     services?: CoordinatorServices;
+    platform?: NodeJS.Platform;
 }
 interface LegacyHandlerOptions {
     env?: NodeJS.ProcessEnv;
-    createSession?: (input: SessionStartInput) => unknown;
 }
-/**
- * Append an authoritative `--mpreset <profile>` to the coordinator child launch
- * command so the spawned GJC session activates the selected profile from its
- * first turn. The profile name is validated against the merged registry before
- * reaching here; it is still shell-quoted as defense in depth.
- *
- * Precedence note: this matches `gjc --mpreset <profile>` semantics exactly, so
- * an explicit model-affecting flag already present in the operator-configured
- * `sessionCommand` (e.g. a `--model`/`--thinking` baked into the launch command)
- * follows the same CLI precedence as a direct `gjc --mpreset ... --model ...`
- * invocation. The effective profile recorded on the session is the
- * coordinator-resolved request, not a child-attested activation receipt; a
- * cross-process activation receipt is a possible future enhancement and is out
- * of scope for the per-session selection contract here.
- */
-export declare function buildCoordinatorSessionCommand(sessionCommand: string, mpreset: string | null | undefined): string;
 export declare const COORDINATOR_AWAIT_TURN_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_RUNTIME_PROMPT_ACK_TIMEOUT_MAX_MS: number;
-export declare const COORDINATOR_RUNTIME_READINESS_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30000;
 export declare const COORDINATOR_POLL_INTERVAL_MAX_MS = 10000;
 export declare function boundedAwaitTurnTimeoutMs(value: unknown): number;
 export declare function boundedRuntimePromptAckTimeoutMs(value: unknown): number;
-export declare function boundedRuntimeReadinessTimeoutMs(value: unknown): number;
 export declare function boundedEventWatchTimeoutMs(value: unknown): number;
 export declare function boundedPollIntervalMs(value: unknown): number;
-export declare function coordinatorOwnerIsolationProbe(runner: CommandRunner): Promise<OwnerIsolationProbe>;
 export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
     path: unknown;
 }): Promise<Record<string, unknown>>;
@@ -101,7 +58,7 @@ export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServe
     }) => Promise<{
         ok: boolean;
         reason?: string;
-        killed: boolean;
+        closed: boolean;
         active_turn_id?: string;
         detail?: string;
     }>;

package/dist/types/daemon/builtin.d.ts

@@ -1,16 +1,17 @@
 /**
  * Static built-in daemon controller map.
  *
- * Intentionally a static map keyed by daemon kind rather than a mutable plugin
- * registry: there is exactly one kind today (`telegram`). Promote to a richer
- * registry only when a second daemon kind exists.
+ * Controllers are deliberately static rather than a mutable plugin registry.
  */
 import type { Settings } from "../config/settings";
-import { type TelegramDaemonControlDeps } from "../notifications/telegram-daemon-control";
+import { type ChatDaemonControlDeps } from "../sdk/bus/chat-daemon-control";
+import { type TelegramDaemonControlDeps } from "../sdk/bus/telegram-daemon-control";
 import type { BuiltInDaemonController, DaemonKind } from "./control-types";
-export declare const BUILT_IN_DAEMON_KINDS: readonly ["telegram"];
+export declare const BUILT_IN_DAEMON_KINDS: readonly ["telegram", "discord", "slack"];
 export interface BuiltInDaemonControllerDeps {
     telegram?: TelegramDaemonControlDeps;
+    discord?: ChatDaemonControlDeps;
+    slack?: ChatDaemonControlDeps;
 }
 export declare function createBuiltInDaemonControllers(settings: Settings, deps?: BuiltInDaemonControllerDeps): Record<DaemonKind, BuiltInDaemonController>;
 /**

package/dist/types/daemon/control-types.d.ts

@@ -5,7 +5,7 @@
  * controller contract. There is exactly one daemon kind today (`telegram`);
  * a richer registry is intentionally deferred until a second kind exists.
  */
-export type DaemonKind = "telegram";
+export type DaemonKind = "telegram" | "discord" | "slack";
 export type DaemonAction = "list" | "status" | "stop" | "reload";
 export type DaemonHealth = "not_configured" | "stopped" | "running" | "stale" | "stopping" | "error";
 export interface DaemonRuntimeInfo {

package/dist/types/discovery/mcp-json.d.ts

@@ -1 +1,12 @@
-export {};
+import { type MCPServer } from "../capability/mcp";
+import type { LoadResult } from "../capability/types";
+export interface MCPJsonLoadResult extends LoadResult<MCPServer> {
+    disabledServers: string[];
+}
+/**
+ * Load MCP servers from a JSON file.
+ */
+export declare function loadMCPJsonFile(filePath: string, level: "user" | "project", options?: {
+    quiet?: boolean;
+    useCache?: boolean;
+}): Promise<MCPJsonLoadResult>;

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -42,7 +42,7 @@ export interface CustomToolAPI {
     exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
     /** UI methods for user interaction (select, confirm, input, notify, custom) */
     ui: CustomToolUIContext;
-    /** Whether UI is available (false in print/RPC mode) */
+    /** Whether an interactive UI is available */
     hasUI: boolean;
     /** File logger for error/warning/debug messages */
     logger: typeof import("@gajae-code/utils").logger;

package/dist/types/extensibility/extensions/compact-handler.d.ts

@@ -3,7 +3,7 @@
  *
  * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
  * takes two positional arguments `(instructions, options)`. This helper splits the
- * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
+ * union so the same adapter can be reused by print, SDK, ACP, and executor callers.
  */
 import type { Model } from "@gajae-code/ai";
 import type { CompactOptions } from "./types";
@@ -15,7 +15,9 @@ interface SetModelCapableSession {
     modelRegistry: {
         getApiKey(model: Model): Promise<string | undefined>;
     };
-    setModel(model: Model): Promise<unknown>;
+    setModel(model: Model, role?: string, options?: {
+        cause?: string;
+    }): Promise<unknown>;
 }
 /**
  * Helper for wiring the `setModel` action of an {@link ExtensionContext}.

package/dist/types/extensibility/extensions/get-commands-handler.d.ts

@@ -2,8 +2,8 @@
  * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
  *
  * Centralizes the union over the three slash-command sources the runtime
- * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
- * task executor) cannot drift:
+ * exposes so the interactive UI, ACP, SDK, print, and child task executor wiring
+ * sites cannot drift:
  *   - extension-registered hook commands (`source: "extension"`)
  *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
  *     custom commands and MCP prompts (`source: "prompt"`)

package/dist/types/extensibility/extensions/loader.d.ts

@@ -1,4 +1,5 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
+import type { UsageReport } from "@gajae-code/ai";
 import { EventBus } from "../../utils/event-bus";
 import type { Extension, ExtensionFactory, ExtensionRuntime as IExtensionRuntime, LoadExtensionsResult } from "./types";
 export declare class ExtensionRuntimeNotInitializedError extends Error {
@@ -16,7 +17,7 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
         sourceId: string;
     }>;
     sendMessage(): void;
-    sendUserMessage(): void;
+    sendUserMessage(): Promise<void>;
     appendEntry(): void;
     setLabel(): void;
     getActiveTools(): string[];
@@ -26,6 +27,14 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
     setModel(): Promise<boolean>;
     getThinkingLevel(): ThinkingLevel;
     setThinkingLevel(): void;
+    getThinkingVisibility(): "visible" | "hidden";
+    setThinkingVisibility(): void;
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    setThinkingLevelForControl(): Promise<void>;
+    setThinkingVisibilityForControl(): Promise<void>;
+    setModelTemporaryForControl(): Promise<boolean>;
+    fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
+    getThinkingScopeForControl(): "session" | "global config";
     getSessionName(): string | undefined;
     setSessionName(): Promise<void>;
 }

package/dist/types/extensibility/extensions/runner.d.ts

@@ -68,8 +68,8 @@ export declare class ExtensionRunner {
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
      *
      * If {@link initialize} has not yet run, the event is buffered and replayed once
-     * initialize wires the runtime/UI context. This matters because mode controllers
-     * (interactive, RPC, ACP, print, subagent) call `initialize()` AFTER `createAgentSession`
+     * initialize wires the runtime/UI context. This matters because session frontends
+     * (interactive, ACP, print, and subagent) call `initialize()` AFTER `createAgentSession`
      * returns, but `AuthStorage` can fire `credential_disabled` during startup model probes
      * inside `createAgentSession()`. Without deferral, extension handlers would observe
      * `hasUI=false`, an unset model, and no-op runtime actions on exactly the headline
@@ -126,7 +126,7 @@ export declare class ExtensionRunner {
         }>;
     }>;
     /** Emit input event. Transforms chain, "handled" short-circuits. */
-    emitInput(text: string, images: ImageContent[] | undefined, source: "interactive" | "rpc" | "extension"): Promise<InputEventResult>;
+    emitInput(text: string, images: ImageContent[] | undefined, source: "interactive" | "sdk" | "extension"): Promise<InputEventResult>;
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
     emitBeforeProviderRequest(payload: unknown): Promise<BeforeProviderRequestEventResult>;
     emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void>;