@gajae-code/coding-agent 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## [Unreleased]
 
+## [0.7.3] - 2026-06-25
+
+### Added
+
+- Added the `gruvbox-dark` built-in theme: the canonical Gruvbox dark palette mapped across every GJC theme token, selectable via `/theme`.
+- Added a standalone MCP registration command: `gjc mcp add|list|remove` writes explicit user-provided MCP server definitions (stdio/http/sse) into GJC config without importing or inheriting other tools' live MCP configs, with env/header/auth values redacted in output (#1095).
+
+### Changed
+
+- Refined the interactive composer chrome so the input box, status rail, and welcome banner share one visual language: the composer now uses a rounded border (matching the rounded welcome banner) instead of a sharp rectangle, and the status rail uses the subtle elevated `userMessageBg` surface tone instead of the heavy `statusLineBg` block, so it reads as a quiet layered zone rather than a solid bar. Both resolve through existing semantic theme slots, so every bundled theme tracks automatically.
+- When a Composer harness model is active, the `bash` tool now hard-blocks repository file I/O — pipes, process/heredoc/command substitution, redirection, `tee`, file read/discovery (`cat`/`head`/`tail`/`grep`/`find`/`ls`), file mutation (`cp`/`mv`/`rm`/`touch`/`mkdir`/`chmod`/`ln`), `sed`/`awk`, git file-read subcommands, and script file I/O — unless the command is on a strict allowlist (`bun test`/`run check|test|build`, `cargo test|check|build`, `git status`/`rev-parse`, package version queries), forcing Composer models to use the dedicated find/search/read/edit tools for file discovery and mutation (#1027).
+### Documentation
+
+- Documented the docs-only Aside evaluation boundary as an opt-in search/context retrieval sidecar using explicit user-provided MCP configuration, with browser actions, login flows, payments, internal tools, secrets, and raw browser/session payload logging out of scope by default (#1097).
+- Added a UI design and visual QA contract governing future TUI/dashboard/terminal visual work (#1101).
+- Added a CodeGraph custom-tool integration guide (#1073).
+- Documented the Windows psmux namespace boundary for `gjc --tmux`, `gjc session`, and `gjc team`: cwd/`-c` is now called out as a start directory rather than server isolation, `-L <namespace>` is identified as the psmux namespace primitive, and tmux command overrides are documented as executable names rather than shell command lines (#1118).
+- Clarified the Telegram Threaded Mode fallback documentation (#1122).
+
+### Fixed
+
+- Expanded the initial GJC forge welcome box to the live terminal viewport width and pinned the status/composer area to the bottom when the startup layout is shorter than the screen (#1120).
+
+- Deep Interview Restate/option gates now recover through the ask selector path instead of waiting on plaintext `Options:` output.
+- Widened the forge splash on wide terminals so it no longer clips (#1110).
+- Parse quoted SSH remote host names in the slash-command host parser (#1104).
+- Tolerate an unreadable git HEAD in the status chrome instead of throwing (#1072).
+- Registered the `plugin` command in the CLI command registry so `gjc plugin …` (install/uninstall/list/marketplace/enable/disable/doctor) resolves instead of silently falling through to the default launch/chat command — the command was implemented and tested but was never registered (#1071).
+- Keybinding/Ctrl+Enter newline-handling sweep across the editor and input controller (#1111).
+- Fixed model-profile default badge precedence in the `/model` selector so the correct default-profile badge wins (#1117).
+- Prevented duplicate Telegram topics being created for transient sessions (#1125).
+
+### Security
+
+- User-supplied URL reads now share the public HTTP(S) network guard that was previously insane-fallback-only: the initial target, the redirect chain, and binary-conversion redirects are all revalidated against private-network blocking before any request is opened or followed, closing an SSRF path through the normal read-tool fetch pipeline (#1114).
+- Bridge workflow-gate responses now require the claimed controller token before the unattended control plane may resolve a gate, and the `workflow_gate_response` RPC command was raised from prompt scope to control scope, so prompt-only clients can no longer answer lifecycle workflow gates (#1116).
+
+## [0.7.2] - 2026-06-24
+### Added
+
+- Added a keyless `insane` web search provider that safely ports upstream insane-search public-route fallbacks without TLS impersonation, browser/cookie bypasses, credential storage, or auto-installed dependencies (#1011).
+- `web_search` `auto` mode now drives native provider search over proxies/custom endpoints by reusing the active model's own credential + baseUrl when canonical native creds are absent: `activeContextNativeId()` matches the model's wire api (+ model-id family) to `anthropic` (anthropic-messages), `openai-compatible` (openai-responses/completions), or `gemini` (google-generative-ai Generative Language), each falling back to DuckDuckGo if the endpoint does not support web search.
+- Added built-in C# LSP detection for `csharp-ls`, with `omnisharp` preserved as a fallback when `csharp-ls` is unavailable (#1054).
+- Added Discord and Slack notification adapters alongside the existing Telegram surface, so action-needed signals and replies can be routed to those clients (#1043).
+- Telegram daemon now supports inbound and outbound photo/file attachments, forwarding agent images and accepting user-sent media (#1053).
+- `gjc` verifies Telegram Threaded Mode during notification setup and falls back to a flat private chat when topics are unavailable (#1029).
+
+### Fixed
+
+- Hardened context-overflow recovery so automatic maintenance clears the TUI loader, surfaces overflow completion/skip status, retries resumable tails safely, and falls back to the synthetic auto-continue prompt for non-resumable tails when enabled.
+- `web_search` native providers no longer discard genuinely grounded answers that omit structured `url_citation` annotations: when a search demonstrably ran — Responses `web_search_call` / `tool_usage.web_search`, a Chat Completions search request, or Anthropic `web_search_tool_result` / `server_tool_use` / `server_tool_use.web_search_requests` — sources are recovered from inline markdown links and bare URLs. Inline recovery is gated on that real-search signal so a stray prose URL in a non-search answer is never promoted to a citation, and Anthropic now fails closed to DuckDuckGo when Claude answers from stable knowledge without searching. Inline-citation helpers are shared via `providers/text-citations.ts`.
+- Preserve GJC-managed tmux sessions on attach/disconnect instead of tearing them down, and stop implicitly attaching on launch (#1063).
+- Corrected the auto-compaction output reserve so post-compaction responses keep adequate headroom (#1021).
+- Improved active-input shortcut hints and the busy-input queueing hint for clearer in-session guidance (#1022, #1024).
+- Fixed the Ultragoal ask guard blocking the `ask` tool when no GJC session can be resolved. `ultragoalReadPaths` falls back to the legacy/global `.gjc/ultragoal` directory when neither `GJC_SESSION_ID` nor an auto-detectable active session is present, but the follow-up `readUltragoalPlan`/`readUltragoalLedger` reads ignored that resolution and re-ran session detection, throwing `no active GJC session found` and surfacing `durable_state_unreadable` — which blocked `ask` for every agent even with no active Ultragoal run. `ultragoalReadPaths` now returns the resolved session id (or `null`); the ask guard treats a null session as inactive and falls open, and threads the resolved id into the plan/ledger reads so they no longer re-resolve. An inconsistent state (state dir present but `goals.json` missing/empty) still fails closed so the pause guard keeps blocking give-ups.
+
 ## [0.7.1] - 2026-06-23
 ### Fixed
 
@@ -136,6 +192,7 @@
 - Added an opt-in `gjc rlm` research mode (v1, interactive): a Jupyter-notebook-style research session over the existing agent loop, backed by the shared persistent Python kernel. It loads a distinct research system prompt, restricts the toolset to a hard-gated allowlist (`python` + `read` + `web_search`, asserted after tool-registry assembly — no `bash`/edit/arbitrary mutation), optionally loads a project-root `DATA.md` (overridable via `--data <path>`), aggregates every executed cell live into `.gjc/rlm/<session>/notebook.ipynb` (single-queue atomic temp-rename writes with post-write validation), and synthesizes `.gjc/rlm/<session>/report.md` on session exit. Autonomous goal-arg runs, `--resume`, managed per-workspace venv provisioning, and the optional `>=N` completion gate are deferred follow-ups.
 - Added an experimental opt-in `computer` desktop-control tool surface for local macOS screenshot/input coordination, backed by native `ComputerController`/`computerScreenshot` bindings and gated through settings/tool registration so it can continue stabilizing on `dev` outside the 0.5.4 patch release.
 - Dropped deprecated GitHub Actions Intel macOS (`macos-13` / `darwin-x64`) release-binary coverage after the runner pool repeatedly blocked v0.6.0 publish; Intel macOS users should install through npm/Bun or build from source.
+- Re-enabled GitHub Actions Intel macOS (`darwin-x64`) release-binary coverage using the `macos-15-intel` runner, so standalone `gjc-darwin-x64` binaries ship again alongside Apple Silicon.
 
 ## [0.5.4] - 2026-06-17
 

package/dist/types/cli/mcp-cli.d.ts

@@ -0,0 +1,25 @@
+import type { MCPServerConfig } from "../runtime-mcp/types";
+export type MCPAction = "add" | "list" | "remove";
+export interface MCPCommandArgs {
+    action: MCPAction;
+    name?: string;
+    commandArgs?: string[];
+    flags: {
+        project?: boolean;
+        force?: boolean;
+        json?: boolean;
+        type?: "stdio" | "http" | "sse";
+        command?: string;
+        url?: string;
+        arg?: string[];
+        env?: string[];
+        header?: string[];
+        cwd?: string;
+        timeout?: number;
+    };
+    cwd?: string;
+}
+export declare class MCPArgsError extends Error {
+}
+export declare function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig;
+export declare function runMCPCommand(args: MCPCommandArgs): Promise<void>;

package/dist/types/cli/notify-cli.d.ts

@@ -17,6 +17,8 @@ export interface NotifyCommandDeps {
     pollIntervalMs?: number;
     setupChatId?: string;
     setupRedact?: boolean;
+    setupInteractive?: boolean;
+    threadedModePrompt?: (message: string) => Promise<string>;
 }
 export declare function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined;
 export declare function runNotifyCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;

package/dist/types/cli.d.ts

@@ -1,3 +1,9 @@
 #!/usr/bin/env bun
+/**
+ * CLI entry point — registers all commands explicitly and delegates to the
+ * lightweight CLI runner from pi-utils.
+ */
+import { type CommandEntry } from "@gajae-code/utils/cli";
+export declare const commands: CommandEntry[];
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export declare function runCli(argv: string[]): Promise<void>;

package/dist/types/commands/mcp.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Direct MCP server registration for standalone GJC.
+ */
+import { Command } from "@gajae-code/utils/cli";
+import { type MCPAction } from "../cli/mcp-cli";
+export default class MCP extends Command {
+    static description: string;
+    static delegateHelp: boolean;
+    static examples: string[];
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: MCPAction[];
+        };
+        name: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+        commandArgs: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            multiple: true;
+        };
+    };
+    static flags: {
+        project: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        force: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+        type: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
+        command: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        url: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        arg: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        env: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        header: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        cwd: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        timeout: import("@gajae-code/utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+        };
+    };
+    run(): Promise<void>;
+    private printHelp;
+}

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

@@ -230,8 +230,8 @@ export declare const KEYBINDINGS: {
         readonly description: "Open external editor";
     };
     readonly "app.message.followUp": {
-        readonly defaultKeys: "ctrl+enter";
-        readonly description: "Send follow-up message";
+        readonly defaultKeys: [];
+        readonly description: "Send follow-up message (no default; Ctrl+Enter inserts a newline)";
     };
     readonly "app.message.queue": {
         readonly defaultKeys: "alt+enter";

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

@@ -130,6 +130,22 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "notifications.discord.botToken": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "notifications.discord.channelId": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "notifications.slack.botToken": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "notifications.slack.channelId": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
     readonly "notifications.redact": {
         readonly type: "boolean";
         readonly default: false;
@@ -2469,6 +2485,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Allow the read tool to fetch and process URLs";
         };
     };
+    readonly "web.insaneFallback": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Insane Search Fallback";
+            readonly description: "Opt in to the vendored insane-search escalation for blocked public URL reads (403/WAF/JS-gated). Off by default. Requires preinstalled python3 + curl_cffi (and node + playwright/stealth for the browser phase); changes network posture by enabling TLS/browser impersonation for public pages.";
+        };
+    };
     readonly "github.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -2518,7 +2543,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "array";
         readonly default: string[];
         readonly items: {
-            readonly enum: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
+            readonly enum: readonly ["duckduckgo", "insane", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
         };
         readonly ui: {
             readonly tab: "tools";
@@ -3121,7 +3146,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "providers.webSearch": {
         readonly type: "enum";
-        readonly values: readonly ["auto", "duckduckgo", "exa", "brave", "jina", "kimi", "zai", "perplexity", "anthropic", "gemini", "codex", "xai", "tavily", "kagi", "synthetic", "parallel", "searxng"];
+        readonly values: readonly ["auto", "duckduckgo", "insane", "exa", "brave", "jina", "kimi", "zai", "perplexity", "anthropic", "gemini", "codex", "xai", "tavily", "kagi", "synthetic", "parallel", "searxng"];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "providers";
@@ -3135,6 +3160,10 @@ export declare const SETTINGS_SCHEMA: {
                 readonly value: "duckduckgo";
                 readonly label: "DuckDuckGo";
                 readonly description: "Keyless default \u2014 no API key or OAuth required";
+            }, {
+                readonly value: "insane";
+                readonly label: "Insane";
+                readonly description: "Keyless safe public-route fallback inspired by upstream insane-search";
             }, {
                 readonly value: "exa";
                 readonly label: "Exa";
@@ -3574,6 +3603,14 @@ export interface NotificationsSettings {
         botToken: string | undefined;
         chatId: string | undefined;
     };
+    discord: {
+        botToken: string | undefined;
+        channelId: string | undefined;
+    };
+    slack: {
+        botToken: string | undefined;
+        channelId: string | undefined;
+    };
     redact: boolean;
     daemon: {
         idleTimeoutMs: number;

package/dist/types/deep-interview/plaintext-gate-guard.d.ts

@@ -0,0 +1,11 @@
+export type DeepInterviewPlaintextAskLeakOption = "Yes, crystallize" | "Adjust wording" | "Missing scope";
+export type DeepInterviewPlaintextAskLeakResult = {
+    kind: "deep_interview_plaintext_ask_leak";
+    matchedOptions: DeepInterviewPlaintextAskLeakOption[];
+    signals: {
+        optionsHeading: true;
+        restateIntent: true;
+        deepInterviewContext: boolean;
+    };
+};
+export declare function detectDeepInterviewPlaintextAskLeak(text: string): DeepInterviewPlaintextAskLeakResult | null;

package/dist/types/extensibility/shared-events.d.ts

@@ -172,6 +172,7 @@ export interface AutoCompactionEndEvent {
     errorMessage?: string;
     /** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
     skipped?: boolean;
+    continuationSkipReason?: "auto_continue_disabled_non_resumable_tail";
 }
 /** Fired when auto-retry starts */
 export interface AutoRetryStartEvent {

package/dist/types/gjc-runtime/ralplan-runtime.d.ts

@@ -12,7 +12,7 @@
  *
  * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N> --artifact
  *    <path-or-string> [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
- *    / Critic / revision / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
+ *    / Critic / revision / post-interview / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
  *    an `index.jsonl` audit log, copies `final` stages to `pending-approval.md`, and advances
  *    the HUD chip to reflect the latest persisted stage.
  */

package/dist/types/lsp/types.d.ts

@@ -224,6 +224,8 @@ export interface ServerConfig {
     /** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
     warmupTimeoutMs?: number;
     capabilities?: ServerCapabilities;
+    /** Names of lower-precedence servers to drop when this server is available. */
+    supersedes?: string[];
     /** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
     isLinter?: boolean;
     /** Resolved absolute path to the command binary (set during config loading) */

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@gajae-code/tui";
 import { type AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.followUp" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 type PastePendingClearReason = "timeout" | "queue-limit";
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.

package/dist/types/modes/components/model-selector.d.ts

@@ -35,6 +35,8 @@ export declare class ModelSelectorComponent extends Container {
         sessionId?: string;
         isFastForProvider?: (provider?: string) => boolean;
         isFastForSubagentProvider?: (provider?: string) => boolean;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
     });
     handleInput(keyData: string): void;
     getSearchInput(): Input;

package/dist/types/modes/components/status-line/git-utils.d.ts

@@ -1,3 +1,4 @@
+import type { GitHeadState } from "../../../utils/git";
 /**
  * Extract "owner/repo" from a GitHub remote URL.
  * Handles HTTPS, SSH (scp-style), and git:// protocols.
@@ -20,3 +21,8 @@ export declare function canReuseCachedPr(cachedPr: {
     number: number;
     url: string;
 } | null | undefined, cachedContext: PrCacheContext | undefined, currentContext: PrCacheContext | null): boolean;
+export interface CurrentBranchState {
+    readonly branch: string | null;
+    readonly repoId: string | null;
+}
+export declare function resolveCurrentBranch(cwd: string, resolveHead?: (cwd: string) => GitHeadState | null): CurrentBranchState;

package/dist/types/modes/theme/defaults/index.d.ts

@@ -325,6 +325,105 @@ export declare const defaultThemes: {
             "preset": string;
         };
     };
+    "gruvbox-dark": {
+        $schema: string;
+        name: string;
+        vars: {
+            "bgHard": string;
+            "surface": string;
+            "surfaceBright": string;
+            "borderNeutral": string;
+            "borderSubtle": string;
+            "fg": string;
+            "muted": string;
+            "dim": string;
+            "gray": string;
+            "red": string;
+            "green": string;
+            "yellow": string;
+            "blue": string;
+            "purple": string;
+            "aqua": string;
+            "orange": string;
+            "diffRemovalRed": string;
+        };
+        colors: {
+            "accent": string;
+            "border": string;
+            "borderAccent": string;
+            "borderMuted": string;
+            "success": string;
+            "error": string;
+            "warning": string;
+            "muted": string;
+            "dim": string;
+            "text": string;
+            "thinkingText": string;
+            "selectedBg": string;
+            "userMessageBg": string;
+            "userMessageText": string;
+            "customMessageBg": string;
+            "customMessageText": string;
+            "customMessageLabel": string;
+            "toolPendingBg": string;
+            "toolSuccessBg": string;
+            "toolErrorBg": string;
+            "toolTitle": string;
+            "toolOutput": string;
+            "mdHeading": string;
+            "mdLink": string;
+            "mdLinkUrl": string;
+            "mdCode": string;
+            "mdCodeBlock": string;
+            "mdCodeBlockBorder": string;
+            "mdQuote": string;
+            "mdQuoteBorder": string;
+            "mdHr": string;
+            "mdListBullet": string;
+            "toolDiffAdded": string;
+            "toolDiffRemoved": string;
+            "toolDiffContext": string;
+            "syntaxComment": string;
+            "syntaxKeyword": string;
+            "syntaxFunction": string;
+            "syntaxVariable": string;
+            "syntaxString": string;
+            "syntaxNumber": string;
+            "syntaxType": string;
+            "syntaxOperator": string;
+            "syntaxPunctuation": string;
+            "thinkingOff": string;
+            "thinkingMinimal": string;
+            "thinkingLow": string;
+            "thinkingMedium": string;
+            "thinkingHigh": string;
+            "thinkingXhigh": string;
+            "bashMode": string;
+            "pythonMode": string;
+            "statusLineBg": string;
+            "statusLineSep": string;
+            "statusLineModel": string;
+            "statusLinePath": string;
+            "statusLineGitClean": string;
+            "statusLineGitDirty": string;
+            "statusLineContext": string;
+            "statusLineSpend": string;
+            "statusLineStaged": string;
+            "statusLineDirty": string;
+            "statusLineUntracked": string;
+            "statusLineOutput": string;
+            "statusLineCost": string;
+            "statusLineSubagents": string;
+        };
+        export: {
+            "pageBg": string;
+            "cardBg": string;
+            "infoBg": string;
+        };
+        symbols: {
+            "preset": string;
+        };
+    };
     opencode: {
         $schema: string;
         name: string;

package/dist/types/notifications/attachment-registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Process-wide registry mapping a session id to a sink that delivers a local
+ * file to the session's connected Telegram chat as a document. Registered by
+ * the notifications extension; consumed by the telegram_send tool.
+ */
+/** Delivers a local file to the session's Telegram chat. */
+export type TelegramFileSink = (file: {
+    path: string;
+    caption?: string;
+}) => Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Register `sink` for `sessionId`. Returns a disposer that clears it. */
+export declare function registerTelegramFileSink(sessionId: string, sink: TelegramFileSink): () => void;
+/** The Telegram file sink for `sessionId`, if one is registered. */
+export declare function getTelegramFileSink(sessionId: string): TelegramFileSink | undefined;

package/dist/types/notifications/chat-adapters.d.ts

@@ -0,0 +1,9 @@
+import type { NotificationPresentationAdapter } from "./engine";
+type AdapterKind = "discord" | "slack";
+interface ChatAdapterOptions {
+    kind: AdapterKind;
+    channelId?: string;
+}
+export declare function createDiscordAdapter(opts?: Omit<ChatAdapterOptions, "kind">): NotificationPresentationAdapter;
+export declare function createSlackAdapter(opts?: Omit<ChatAdapterOptions, "kind">): NotificationPresentationAdapter;
+export {};

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

@@ -3,13 +3,21 @@ export interface NotificationConfig {
     enabled: boolean;
     botToken?: string;
     chatId?: string;
+    discord: {
+        botToken?: string;
+        channelId?: string;
+    };
+    slack: {
+        botToken?: string;
+        channelId?: string;
+    };
     redact: boolean;
     verbosity: "lean" | "verbose";
     idleTimeoutMs: number;
 }
 /** Read typed config from Settings. */
 export declare function getNotificationConfig(settings: Settings): NotificationConfig;
-/** Is global config sufficient for auto-on (enabled + botToken + chatId all present)? */
+/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
 /** Resolve whether the notifications extension should be registered at SDK startup. */
 export declare function shouldRegisterNotificationsExtension(input: {

package/dist/types/notifications/engine.d.ts

@@ -0,0 +1,59 @@
+import { type RedactableAction } from "./config";
+export type NotificationEvent = ({
+    type: "action_needed";
+} & RedactableAction) | {
+    type: "action_resolved";
+    id: string;
+    sessionId: string;
+    resolvedBy?: string;
+} | {
+    type: "frame";
+    sessionId: string;
+    frame: Record<string, unknown>;
+};
+export interface NotificationReplyRoute {
+    sessionId: string;
+    actionId: string;
+    answer: number | string | {
+        selected?: Array<number | string>;
+        custom?: string;
+    };
+}
+export interface NotificationAdapterPayload {
+    adapter: string;
+    channelKey?: string;
+    body: unknown;
+    route?: Omit<NotificationReplyRoute, "answer">;
+}
+export interface NotificationPresentationAdapter {
+    readonly kind: "telegram" | "discord" | "slack";
+    render(event: NotificationEvent): NotificationAdapterPayload[];
+    mapInbound(input: unknown): NotificationReplyRoute | undefined;
+}
+export interface EngineSessionSink {
+    sendReply(route: NotificationReplyRoute): void;
+}
+export interface NotificationEngineOptions {
+    redact: boolean;
+    sessionTag: (sessionId: string) => string;
+}
+/**
+ * Shared presentation engine for managed notification clients.
+ *
+ * It owns fanout, redaction boundaries, pending-action routing, and reply
+ * delivery into session sinks. Transport adapters stay pure: render an internal
+ * event into a public-safe payload and map an inbound transport interaction
+ * back into a session/action answer.
+ */
+export declare class NotificationPresentationEngine {
+    private readonly opts;
+    readonly adapters: readonly NotificationPresentationAdapter[];
+    private readonly sessions;
+    private readonly pending;
+    constructor(adapters: readonly NotificationPresentationAdapter[], opts: NotificationEngineOptions);
+    connectSession(sessionId: string, sink: EngineSessionSink): void;
+    dropSession(sessionId: string): void;
+    fanout(event: NotificationEvent): NotificationAdapterPayload[];
+    routeInbound(adapterKind: NotificationPresentationAdapter["kind"], input: unknown): boolean;
+    private redactEvent;
+}

package/dist/types/notifications/managed-daemon.d.ts

@@ -0,0 +1,48 @@
+import type { Settings } from "../config/settings";
+import { RateLimitPool } from "./rate-limit-pool";
+import { type ThreadedSend } from "./threaded-render";
+export interface ManagedNotificationDaemonFs {
+    readdir(path: string): Promise<string[]>;
+}
+export interface ManagedSessionSocket {
+    sessionId: string;
+    token: string;
+    ws: WebSocket;
+    pending: Map<string, {
+        sessionId: string;
+        actionId: string;
+    }>;
+    capable: boolean;
+    lastPongAt: number;
+    awaitingNonce: string | undefined;
+    pingTimer: ReturnType<typeof setInterval> | undefined;
+}
+export interface ManagedNotificationDaemonOptions {
+    settings: Settings;
+    fs: ManagedNotificationDaemonFs;
+    WebSocketImpl?: typeof WebSocket;
+    now?: () => number;
+    setIntervalImpl?: typeof setInterval;
+    clearIntervalImpl?: typeof clearInterval;
+    rateLimitPool?: RateLimitPool<{
+        send: ThreadedSend;
+        topicId?: string;
+    }>;
+}
+export declare abstract class ManagedNotificationDaemon {
+    protected readonly opts: ManagedNotificationDaemonOptions;
+    readonly sessions: Map<string, ManagedSessionSocket>;
+    readonly pool: RateLimitPool<{
+        send: ThreadedSend;
+        topicId?: string;
+    }>;
+    protected constructor(opts: ManagedNotificationDaemonOptions);
+    scanRoots(): Promise<void>;
+    connectSession(sessionId: string, url: string, token: string): ManagedSessionSocket;
+    protected handleSessionMessage(session: ManagedSessionSocket, msg: Record<string, unknown>): Promise<boolean>;
+    protected renderFrame(frame: Record<string, unknown>): ThreadedSend | undefined;
+    protected dropSession(session: ManagedSessionSocket): void;
+    protected abstract readRoots(): Promise<string[]>;
+    private sendHello;
+    private startLiveness;
+}