@gajae-code/coding-agent 0.6.5 → 0.7.1

package/dist/types/gjc-runtime/ultragoal-guard.d.ts

@@ -27,10 +27,25 @@ export declare function validateCompletionReceipt(input: {
 export declare function readUltragoalVerificationState(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
 }): Promise<UltragoalGuardDiagnostic>;
 export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
 }): Promise<void>;
 export declare function isUltragoalBypassPrompt(prompt: string): boolean;
+export interface UltragoalPauseBlockDiagnostic {
+    blocked: boolean;
+    reason: string;
+}
+/**
+ * While an Ultragoal run is active, `goal({"op":"pause"})` is only allowed when the
+ * current durable Ultragoal state is readable and the latest durable ledger event
+ * classifies the current blocker as `human_blocked`. Resolvable blockers must be
+ * worked, not parked. Reads fail closed so unreadable durable state or ledger data
+ * blocks pause rather than silently allowing a give-up.
+ */
+export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
+export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;

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

@@ -193,6 +193,19 @@ export declare function recordUltragoalReviewBlockers(input: {
     evidence: string;
     gjcGoalJson?: string;
 }): Promise<UltragoalPlan>;
+export type UltragoalBlockerClassification = "human_blocked" | "resolvable";
+/**
+ * Record an audited blocker triage classification in the durable ledger. A
+ * `human_blocked` classification is the only thing that authorizes
+ * `goal({"op":"pause"})` while an Ultragoal run is active; `resolvable` is an
+ * audit note and never unblocks pause.
+ */
+export declare function recordUltragoalBlockerClassification(input: {
+    cwd: string;
+    classification: UltragoalBlockerClassification;
+    evidence: string;
+    goalId?: string;
+}): Promise<UltragoalLedgerEvent>;
 type UltragoalReviewContractStrength = "strong" | "thin-derived";
 interface UltragoalReviewFinding extends JsonObject {
     severity: "blocker";
@@ -208,6 +221,7 @@ interface UltragoalReviewResult extends JsonObject {
     weakContractCapApplied: boolean;
     blockerGoalIds?: string[];
 }
+export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
 export {};

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

@@ -1,5 +1,6 @@
 import { Container } from "@gajae-code/tui";
 import type { AuthStorage } from "../../session/auth-storage";
+import type { ImportableCredential } from "../../setup/credential-import";
 /**
  * Component that renders an OAuth provider selector.
  */
@@ -8,6 +9,7 @@ export declare class OAuthSelectorComponent extends Container {
     constructor(mode: "login" | "logout", authStorage: AuthStorage, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
         validateAuth?: (providerId: string) => Promise<boolean>;
         requestRender?: () => void;
+        externalCredentialCandidates?: ImportableCredential[];
     });
     stopValidation(): void;
     dispose(): void;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -1,5 +1,5 @@
 import type { Component } from "@gajae-code/tui";
-import type { InteractiveModeContext } from "../../modes/types";
+import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
 import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 export declare class SelectorController {
@@ -44,7 +44,7 @@ export declare class SelectorController {
     showSessionSelector(): Promise<void>;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
-    showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
     showDebugSelector(): void;
     showSessionObserver(registry: SessionObserverRegistry): void;
     /**

package/dist/types/modes/interactive-mode.d.ts

@@ -221,7 +221,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showSessionSelector(): void;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
-    showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: import("./types").OAuthSelectorOptions): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     handleCtrlC(): void;
     handleCtrlD(): void;

package/dist/types/modes/shared/agent-wire/unattended-session.d.ts

@@ -34,6 +34,14 @@ export interface WorkflowGateEmitter {
     isUnattended(): boolean;
     /** Open + emit a gate; resolves with the agent's answer (from workflow_gate_response). */
     emitGate(input: OpenGateInput): Promise<unknown>;
+    /**
+     * Optional bridge surface (present on {@link UnattendedSessionControlPlane}) that
+     * lets an in-process extension observe emitted gates and answer them — used by
+     * the notifications SDK to resolve a real ask gate from a remote reply.
+     */
+    onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
+    resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    listPendingGates?(): RpcWorkflowGate[];
 }
 export interface UnattendedSessionOptions {
     runId: string;
@@ -61,6 +69,8 @@ export declare class UnattendedSessionControlPlane implements RpcUnattendedContr
     private readonly opts;
     constructor(opts: UnattendedSessionOptions);
     isUnattended(): boolean;
+    /** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
+    onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void;
     get controller(): UnattendedRunController | undefined;
     negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
     preflightCommand(command: RpcCommand): void;

package/dist/types/modes/types.d.ts

@@ -12,6 +12,7 @@ import type { MCPManager } from "../runtime-mcp";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { CredentialAutoImportOptions } from "../setup/credential-auto-import";
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -226,7 +227,7 @@ export interface InteractiveModeContext {
     showSessionSelector(): void;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
-    showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): void;
     showSessionObserver(): void;
@@ -276,3 +277,8 @@ export interface InteractiveModeContext {
     showExtensionError(extensionPath: string, error: string): void;
     showToolError(toolName: string, error: string): void;
 }
+export interface OAuthSelectorOptions {
+    allowExternalCredentialDiscovery?: boolean;
+    trigger?: "bare-login";
+    externalCredentialDiscover?: CredentialAutoImportOptions["discover"];
+}

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

@@ -0,0 +1,26 @@
+/**
+ * In-thread configuration slash commands for the threaded session surface.
+ *
+ * Replies are thread-native now (the old `/answer <sessionId> …` command is
+ * removed), but the user can still adjust per-surface behaviour from inside a
+ * session thread with small slash commands:
+ *
+ * - `/verbose`            switch the mirror to verbose (full tool output + reasoning)
+ * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbosity lean|verbose`
+ * - `/redact on|off`      toggle redaction of streamed content
+ *
+ * This parser is pure so the command grammar is unit-testable; the daemon maps
+ * the returned change onto a `config_command` frame / settings update.
+ */
+/** A parsed in-thread configuration change. */
+export interface ConfigCommandChange {
+    verbosity?: "lean" | "verbose";
+    redact?: boolean;
+}
+/**
+ * Parse an in-thread config command. Returns the requested change, or
+ * `undefined` when the text is not a recognised config command (so the daemon
+ * can fall through to treating it as a free-text injection).
+ */
+export declare function parseInThreadConfigCommand(text: string): ConfigCommandChange | undefined;

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

@@ -0,0 +1,61 @@
+import type { Settings } from "../config/settings";
+export interface NotificationConfig {
+    enabled: boolean;
+    botToken?: string;
+    chatId?: 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)? */
+export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
+/** Resolve whether the notifications extension should be registered at SDK startup. */
+export declare function shouldRegisterNotificationsExtension(input: {
+    env: NodeJS.ProcessEnv;
+    cfg?: NotificationConfig;
+}): boolean;
+/**
+ * Resolve whether THIS session should run notifications.
+ * Precedence (highest first):
+ *  1) env.GJC_NOTIFICATIONS === "0"  -> false (hard opt-out)
+ *  2) sessionDisabled === true       -> false (local /notify off)
+ *  3) env.GJC_NOTIFICATIONS === "1" || env.GJC_NOTIFICATIONS_TOKEN present -> true (legacy explicit)
+ *  4) isGloballyConfigured(cfg)      -> true (global auto-on)
+ *  5) otherwise false
+ */
+export declare function isSessionNotificationsEnabled(input: {
+    cfg: NotificationConfig;
+    env: NodeJS.ProcessEnv;
+    sessionDisabled: boolean;
+}): boolean;
+/** Mask a bot token for display: first 4 chars + "…" + "(len N)"; "(unset)" when undefined/empty. Never reveal full token. */
+export declare function maskToken(token: string | undefined): string;
+/** Stable non-reversible fingerprint of a token: sha256 hex, first 12 chars. */
+export declare function tokenFingerprint(token: string): string;
+/** Short session tag for display, e.g. last 6 chars of sessionId. */
+export declare function sessionTag(sessionId: string): string;
+export interface RedactableAction {
+    id: string;
+    kind: string;
+    sessionId: string;
+    question?: string;
+    options?: string[];
+    summary?: string;
+}
+/**
+ * When redact is true, strip sensitive content for remote delivery:
+ *  - ask: NOT redacted. An ask is an interactive prompt the human must read and
+ *    answer on the remote surface; redacting its question/options would make it
+ *    unanswerable, defeating remote answering. Asks are returned unchanged.
+ *  - idle: summary removed, (no question/options).
+ * When redact is false, return the action unchanged.
+ *
+ * Redaction still applies to streamed content frames (turn_stream, context_update,
+ * image_attachment) which are suppressed at their emit sites, not here.
+ */
+export declare function buildRedactedAction(action: RedactableAction, opts: {
+    redact: boolean;
+    sessionTag: string;
+}): RedactableAction;

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

@@ -0,0 +1,55 @@
+/**
+ * Pure helpers for the notifications extension.
+ *
+ * Kept side-effect-free so the mapping logic (ask extraction, idle summary,
+ * dedupe keys) is unit-testable without a live session or the native server.
+ */
+import { type RedactableAction } from "./config";
+/** A pending ask derived from an `ask` tool call. */
+export interface PendingAsk {
+    /** Action id: `${toolCallId}:${questionId}`. */
+    id: string;
+    /** Question text. */
+    question: string;
+    /** Option labels (may be empty for free-text questions). */
+    options: string[];
+}
+/** Truncate text to `max` chars, appending an ellipsis when cut. */
+export declare function truncate(text: string, max?: number): string;
+/** Stable per-turn idle dedupe key so exactly one idle action fires per turn. */
+export declare function idleDedupeKey(sessionId: string, turnIndex: number): string;
+/**
+ * Extract pending asks from an `ask` tool call input.
+ *
+ * Defensive: tolerates partial/unknown shapes and always returns an array.
+ */
+export declare function asksFromAskInput(toolCallId: string, input: unknown): PendingAsk[];
+/** Prepare an action JSON payload for remote notification delivery. */
+export declare function notificationActionPayload<T extends RedactableAction>(action: T, opts: {
+    redact: boolean;
+    sessionTag: string;
+}): RedactableAction;
+/** Extract a plain-text summary from an agent message's content, if any. */
+export declare function summaryFromMessage(message: unknown, max?: number): string | undefined;
+/**
+ * Extract an idle summary from an `agent_end` event's settled message list: the
+ * last message that yields text (i.e. the final assistant message; tool-result
+ * messages have no text and are skipped).
+ *
+ * `agent_end` fires exactly once when the agent loop settles to await the user,
+ * so emitting idle from this — instead of per-`turn_end` — produces exactly one
+ * idle notification per genuine idle, eliminating the multi-turn flood.
+ */
+export declare function summaryFromMessages(messages: unknown, max?: number): string | undefined;
+/** An agent-produced image extracted from a message's content. */
+export interface ExtractedImage {
+    source: string;
+    mime: string;
+    data: string;
+}
+/**
+ * Extract agent-produced images (`{ type: "image", data, mimeType }` blocks)
+ * from a message's content — e.g. computer-use/browser screenshots or tool
+ * image outputs — for `image_attachment` delivery.
+ */
+export declare function imageAttachmentsFromMessage(message: unknown, source?: string): ExtractedImage[];

package/dist/types/notifications/html-format.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Telegram HTML formatting helpers for the notifications SDK.
+ *
+ * All notifications-SDK Telegram output is sent with `parse_mode: "HTML"`. This
+ * module is the single source of truth for: escaping dynamic text, converting a
+ * bounded markdown subset into Telegram HTML, safely truncating a finished
+ * message to Telegram's 4096-char limit without breaking tags/entities, and
+ * laying out inline-keyboard buttons as a numbered grid.
+ *
+ * Discipline: escape first, tag second. Telegram only parses a small tag set
+ * (b, i, u, s, code, pre, a, blockquote, tg-spoiler); a stray `<` or unbalanced
+ * tag can make Telegram reject the whole message, so dynamic text is always
+ * escaped before any tag is emitted.
+ */
+export declare const TELEGRAM_PARSE_MODE: "HTML";
+export declare const TELEGRAM_MESSAGE_LIMIT = 4096;
+/** Escape text for Telegram HTML body content (`& < >`). */
+export declare function escapeHtml(value: string): string;
+/** Bold the given raw text (escaped internally). */
+export declare function bold(raw: string): string;
+/** Italicize the given raw text (escaped internally). */
+export declare function italic(raw: string): string;
+/** Render the given raw text as inline code (escaped internally). */
+export declare function code(raw: string): string;
+/** Render the given raw text as a preformatted block (escaped internally). */
+export declare function pre(raw: string): string;
+/**
+ * Convert a bounded markdown subset into Telegram HTML. Supported: fenced code,
+ * inline code, `**bold**`, `*italic*`, `[text](url)` (safe schemes only),
+ * `#` headers, `>` blockquotes, and GFM tables (rendered as a monospace block).
+ * Unsupported or malformed markdown is left as escaped literal text — never
+ * emitted as unbalanced tags.
+ */
+export declare function markdownToTelegramHtml(markdown: string): string;
+/**
+ * Truncate a finished Telegram HTML message to at most `max` chars without
+ * splitting a tag or entity, closing any still-open allowed tags and appending
+ * `marker`. The final string is guaranteed to be <= `max`.
+ */
+export declare function truncateTelegramHtml(message: string, max?: number, marker?: string): string;
+/** Finalize an optional message: undefined passthrough, else safe-truncate. */
+export declare function finalizeTelegramHtml(message?: string): string | undefined;
+/**
+ * One-based, plain-text button label (Telegram does not parse HTML in labels).
+ *
+ * Strips any leading `N.`/`N)` index already embedded in the label (e.g.
+ * deep-interview options pre-numbered by the ask tool) and applies the canonical
+ * one-based button index instead. This avoids duplicated numbering like
+ * `1. 1. …` and keeps the displayed number aligned with the button's real index.
+ */
+export declare function buttonLabel(label: string, index: number): string;
+export interface InlineButton {
+    text: string;
+    callback_data: string;
+}
+/**
+ * Lay out option labels as a numbered button grid. Long buttons take a
+ * full-width row; runs of short buttons are packed into rows of up to 3. The
+ * callback value comes from `callbackForIndex(i)` using the original zero-based
+ * option index — layout never changes callback semantics.
+ */
+export declare function buildButtonGrid(labels: string[], callbackForIndex: (index: number) => string): InlineButton[][];

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

@@ -0,0 +1,28 @@
+/**
+ * Notifications extension.
+ *
+ * Hosts a per-session loopback WebSocket notification server (the Rust core via
+ * N-API) and bridges GJC session events + the `ask` tool to it so a remote client
+ * (e.g. a Telegram bot) can both see action-needed signals and ANSWER them —
+ * without requiring RPC/unattended mode:
+ *
+ * - `ask` (interactive): registers an {@link AskAnswerSource}; the ask tool races
+ *   the local UI against a remote reply. First valid answer wins; a local answer
+ *   aborts the remote wait (and broadcasts `action_resolved` resolvedBy=local).
+ * - `ask` (unattended/RPC): observes emitted workflow gates and resolves the real
+ *   gate on a remote reply via `ctx.workflowGate`.
+ * - `turn_end` -> `action_needed` (kind `idle`, deduped per turn).
+ * - `session_shutdown` -> stop the server + deregister the answer source.
+ *
+ * Enable with Settings notifications config, `GJC_NOTIFICATIONS=1` (a token is
+ * generated), or `GJC_NOTIFICATIONS_TOKEN`.
+ */
+import type { ExtensionFactory } from "../extensibility/extensions";
+/**
+ * Best-effort real repository name (no git spawn): resolves the main worktree
+ * root directory so linked worktrees report the repo (e.g. `gajae-code`)
+ * instead of the worktree directory (e.g. `feat-foo-01047f11`).
+ */
+export declare function readGitRepoName(cwd: string): string | undefined;
+export declare function notificationsEnabled(): boolean;
+export declare const createNotificationsExtension: ExtensionFactory;

package/dist/types/notifications/rate-limit-pool.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Host-wide shared Telegram rate-limit pool for the threaded session surface.
+ *
+ * Multiple GJC sessions on one host share a single bot token and paired chat.
+ * Telegram enforces per-bot/per-chat limits (~1 message/sec, bursts up to ~20),
+ * so the singleton notifications daemon owns ONE pool that all per-session
+ * threads draw from. The pool provides:
+ *
+ * - a token bucket (burst capacity + steady refill) modelling the chat limit;
+ * - priority lanes (`ask` > `finalized` > `live` > `idle`) so urgent frames
+ *   win scarce tokens;
+ * - per-session round-robin fairness within a lane so one session's live-edit
+ *   stream cannot starve other sessions;
+ * - coalescing of live edits that share a `coalesceKey` (the latest rendered
+ *   text replaces the queued one) so throttled edit storms collapse.
+ *
+ * The core is a pull-based scheduler with an injectable clock so fairness,
+ * starvation, and burst behaviour are deterministically unit-testable without
+ * real time or a live Bot API.
+ */
+/** Delivery lanes in descending priority. */
+export type RateLimitLane = "ask" | "finalized" | "live" | "idle";
+/** Lanes ordered from highest to lowest priority. */
+export declare const LANE_PRIORITY: readonly RateLimitLane[];
+/** A unit of work competing for a send slot. */
+export interface RateLimitItem<T = unknown> {
+    /** Owning session id (used for per-session fairness). */
+    sessionId: string;
+    /** Priority lane. */
+    lane: RateLimitLane;
+    /**
+     * Optional coalesce key. Submitting another item with the same
+     * `(sessionId, lane, coalesceKey)` replaces the queued payload with the
+     * newer one instead of enqueuing a duplicate (used for live edits).
+     */
+    coalesceKey?: string;
+    /** Opaque payload the caller maps to an actual Telegram send. */
+    payload: T;
+}
+/** Options for {@link RateLimitPool}. */
+export interface RateLimitPoolOptions {
+    /** Burst capacity (max tokens). Default 20 (Telegram per-chat burst). */
+    capacity?: number;
+    /** Steady refill rate in tokens per second. Default 1 (~1 msg/sec/chat). */
+    refillPerSec?: number;
+    /** Injectable clock in ms. Default `Date.now`. */
+    now?: () => number;
+}
+/**
+ * A deterministic, pull-based shared rate-limit scheduler.
+ *
+ * Callers {@link submit} work and periodically {@link drain} (e.g. on a timer
+ * or after each submit); `drain` returns the items granted a send slot, in the
+ * order they should be sent.
+ */
+export declare class RateLimitPool<T = unknown> {
+    private readonly capacity;
+    private readonly refillPerSec;
+    private readonly now;
+    /** Per-lane FIFO queues; each lane holds items across sessions. */
+    private readonly lanes;
+    /** Rotating session cursor per lane for round-robin fairness. */
+    private readonly laneCursor;
+    private tokens;
+    private lastRefill;
+    private seqCounter;
+    constructor(options?: RateLimitPoolOptions);
+    /** Number of items currently queued across all lanes. */
+    get pending(): number;
+    /** Current available token count (after refill at `now`). */
+    availableTokens(nowMs?: number): number;
+    /**
+     * Submit an item. If it carries a `coalesceKey` matching a queued item in
+     * the same `(sessionId, lane)`, the queued payload is replaced (latest
+     * wins) and FIFO position is preserved; otherwise it is appended.
+     */
+    submit(item: RateLimitItem<T>): void;
+    /**
+     * Grant as many queued items as tokens allow at `nowMs`. Items are selected
+     * by lane priority, then round-robin across sessions within a lane (so no
+     * single session monopolises a lane), consuming one token each.
+     */
+    drain(nowMs?: number): RateLimitItem<T>[];
+    private refill;
+    /** Pop the next item by lane priority + per-session round-robin fairness. */
+    private takeNext;
+    /**
+     * Choose the index to serve from a lane queue using round-robin over the
+     * distinct session ids present, starting just after the last-served
+     * session. Falls back to FIFO (index 0) when only one session is queued.
+     */
+    private pickFairIndex;
+}

package/dist/types/notifications/telegram-cli.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+/**
+ * Reference CLI for the notifications SDK Telegram client.
+ *
+ * Bridges a running GJC session's notification endpoint to a Telegram bot so you
+ * can answer asks / see idle pings from your phone — no RPC mode required. This
+ * is an EXAMPLE/template (the SDK contract is in `docs/notifications-sdk.md`);
+ * Discord/Slack clients are written the same way.
+ *
+ * Usage:
+ *   bun run packages/coding-agent/src/notifications/telegram-cli.ts \
+ *     --bot-token <token> [--chat-id <id>] [--endpoint-file <path> | --session-id <id>] [--repo <dir>]
+ *
+ * Env fallbacks: GJC_TG_BOT_TOKEN, GJC_TG_CHAT_ID.
+ * If --chat-id is omitted it is auto-resolved from getUpdates (message the bot once).
+ * If neither --endpoint-file nor --session-id is given, the newest endpoint file
+ * under <repo>/.gjc/state/notifications/ is used.
+ */
+export {};

package/dist/types/notifications/telegram-daemon-cli.d.ts

@@ -0,0 +1,11 @@
+import { Settings } from "../config/settings";
+import { TelegramNotificationDaemon } from "./telegram-daemon";
+export interface RunDaemonInternalDeps {
+    SettingsImpl?: Pick<typeof Settings, "init">;
+    DaemonImpl?: typeof TelegramNotificationDaemon;
+    processPid?: number;
+}
+export declare function runDaemonSmoke(opts?: {
+    agentDir?: string;
+}): Promise<void>;
+export declare function runDaemonInternal(argv: string[], deps?: RunDaemonInternalDeps): Promise<void>;

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

@@ -0,0 +1,56 @@
+/**
+ * Telegram daemon controller + owner-scoped control-request helpers.
+ *
+ * Reload is a hybrid: an owner-scoped control-request file records auditable
+ * intent, SIGTERM is the wakeup that aborts the in-flight long poll, and a
+ * fresh daemon is spawned only after the old pid is dead / has exited. This
+ * keeps the single-poller invariant (no Telegram getUpdates 409 overlap) and
+ * never steals a still-live owner.
+ */
+import type { Settings } from "../config/settings";
+import type { BuiltInDaemonController, DaemonOperationOptions, DaemonOperationResult, DaemonStatus } from "../daemon/control-types";
+import { type TelegramDaemonDeps, type TelegramDaemonFs } from "./telegram-daemon";
+export interface TelegramDaemonControlRequest {
+    version: 1;
+    requestId: string;
+    action: "reload" | "stop";
+    ownerId: string;
+    pid: number;
+    createdAt: number;
+}
+export declare function telegramControlRequestPath(agentDir: string): string;
+export declare function readTelegramControlRequest(settings: Settings, fsImpl?: TelegramDaemonFs): Promise<TelegramDaemonControlRequest | undefined>;
+export declare function writeTelegramControlRequest(settings: Settings, request: TelegramDaemonControlRequest, fsImpl?: TelegramDaemonFs): Promise<void>;
+export declare function clearTelegramControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;
+export interface TelegramDaemonControlDeps {
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    pidAlive?: (pid: number) => boolean;
+    sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
+    spawn?: TelegramDaemonDeps["spawn"];
+    execPath?: string;
+    randomId?: () => string;
+    sleep?: (ms: number) => Promise<void>;
+    waitStepMs?: number;
+}
+export declare class TelegramDaemonController implements BuiltInDaemonController {
+    private readonly settings;
+    private readonly deps;
+    readonly kind: "telegram";
+    private readonly fsImpl;
+    private readonly now;
+    private readonly pidAlive;
+    private readonly sendSignal;
+    private readonly waitStepMs;
+    constructor(settings: Settings, deps?: TelegramDaemonControlDeps);
+    private runtimeInfo;
+    status(): Promise<DaemonStatus>;
+    private spawnDeps;
+    private sleep;
+    private waitForPidDeath;
+    private result;
+    reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+    stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+    private stopOrReload;
+    private clearOwnRequest;
+}