@jawcode-dev/coding-agent 1.1.0

package/dist/types/modes/utils/help-markdown.d.ts

@@ -0,0 +1,17 @@
+import type { KeybindingsManager } from "../../config/keybindings";
+/** Minimal command shape — the autocomplete list and the builtin defs both satisfy it. */
+export interface HelpCommandEntry {
+    name: string;
+    description?: string;
+}
+export interface HelpMarkdownInputs {
+    commands: ReadonlyArray<HelpCommandEntry>;
+    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+}
+/**
+ * /help panel body (devlog 99.20.08): a short "getting around" primer plus the
+ * full command catalog — the same combined list the autocomplete advertises
+ * (builtin + hooks + custom + skills + file commands), so the two surfaces can
+ * never drift apart.
+ */
+export declare function buildHelpMarkdown(inputs: HelpMarkdownInputs): string;

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { KeybindingsManager } from "../../config/keybindings";
+export interface HotkeysMarkdownBindings {
+    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+}
+export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Match the coding-agent interrupt key.
+ *
+ * Interactive mode installs a keybinding manager that exposes `app.interrupt`
+ * globally, but some isolated component tests still run with only TUI
+ * keybindings registered. In that case, fall back to raw Escape matching.
+ */
+export declare function matchesAppInterrupt(data: string): boolean;
+export declare function matchesSelectCancel(data: string): boolean;
+export declare function matchesAppExternalEditor(data: string): boolean;

package/dist/types/modes/utils/session-transcript-replay.d.ts

@@ -0,0 +1,24 @@
+import type { AgentMessage, AgentTool } from "@jawcode-dev/agent-core";
+import { type Component, type TUI } from "@jawcode-dev/tui";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import type { SessionContext } from "../../session/session-manager";
+export type SessionTranscriptReplayDeps = {
+    ui: TUI;
+    cwd: string;
+    hideThinkingBlock: boolean;
+    toolOutputExpanded: boolean;
+    retryAttempt: number;
+    getToolByName(name: string): AgentTool | undefined;
+    getUserMessageText?(message: AgentMessage): string;
+    getMessageRenderer?(customType: string): MessageRenderer | undefined;
+    requestRender(): void;
+    showImages: boolean;
+    readToolResultPreview: boolean;
+    editFuzzyThreshold: number;
+    editAllowFuzzy: boolean;
+    hashlineAutoDropPureInsertDuplicates: boolean;
+};
+export type SessionTranscriptReplayOptions = {
+    mode: "transcript" | "chat";
+};
+export declare function buildSessionTranscriptComponents(sessionContext: SessionContext, deps: SessionTranscriptReplayDeps, options: SessionTranscriptReplayOptions): Component[];

package/dist/types/modes/utils/tools-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "../../tools";
+export interface ToolsMarkdownBindings {
+    tools: ReadonlyArray<Pick<Tool, "description" | "name">>;
+}
+export declare function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -0,0 +1,77 @@
+import type { AgentMessage } from "@jawcode-dev/agent-core";
+import type { AssistantMessage, Message } from "@jawcode-dev/ai";
+import { type Component } from "@jawcode-dev/tui";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { SessionContext } from "../../session/session-manager";
+interface RenderInitialMessagesOptions {
+    preserveExistingChat?: boolean;
+}
+/**
+ * 083.9 P2-b → 083.10 §1: commit render lane gate. DEFAULT ON — finalized
+ * cells are written once into the real terminal scrollback instead of living
+ * in the diff-rendered frame. JWC_COMMIT_LANE=0 opts out (virtual lane only);
+ * unsupported terminals/zellij/overlays fall back per-call inside
+ * TUI.commitLines regardless of this gate.
+ */
+export declare function commitLaneEnabled(): boolean;
+export declare function markLiveToggleEligible(component: unknown, eligible: boolean): void;
+export declare function isLiveToggleEligible(component: unknown): boolean;
+/**
+ * 083.9 P4 — turn-boundary commit sweep. Called right before the next prompt
+ * submit: every finalized chat component commits its pixels into the
+ * scrollback and is flagged `committed` (frame assembly skips it; the object
+ * stays in chatContainer for alt+t transcript and sweeps). The just-finished
+ * turn therefore stays FULLY interactive (ctrl+o/t, focus mode, Enter
+ * expand) until the user moves on — pixels freeze only at the turn boundary.
+ *
+ * Commits must form a contiguous prefix of the frame, so the walk stops at
+ * the first non-committable child (streaming component, pending tool awaiting
+ * a result, or a commitLines fallback).
+ */
+export declare function commitFinalizedBacklog(ctx: InteractiveModeContext): void;
+export declare class UiHelpers {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /** Extract text content from a user message */
+    getUserMessageText(message: Message): string;
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    addMessageToChat(message: AgentMessage, options?: {
+        populateHistory?: boolean;
+        live?: boolean;
+    }): Component[];
+    /**
+     * Render session context to chat. Used for initial load and rebuild after compaction.
+     * @param sessionContext Session context to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionContext(sessionContext: SessionContext, options?: {
+        updateFooter?: boolean;
+        populateHistory?: boolean;
+    }): void;
+    renderInitialMessages(prebuiltContext?: SessionContext, options?: RenderInitialMessagesOptions): void;
+    clearEditor(): void;
+    showError(errorMessage: string): void;
+    showWarning(warningMessage: string): void;
+    showNewVersionNotification(newVersion: string): void;
+    updatePendingMessagesDisplay(): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+    isKnownSlashCommand(text: string): boolean;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    /** Move pending bash components from pending area to chat */
+    flushPendingBashComponents(): void;
+    findLastAssistantMessage(): AssistantMessage | undefined;
+    extractAssistantText(message: AssistantMessage): string;
+}
+export {};

package/dist/types/notifications/ask-bridge.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Bridges a live local answer source against a remote notification answer for a single ask.
+ *
+ * Transport-agnostic and TUI-free so it can be unit-tested in isolation: the caller supplies the
+ * local answer promise (already wired to whatever UI it uses) and a mapper from a remote string to
+ * the caller's own answer shape. The local side is cancelled via `dismiss` when the remote wins.
+ */
+export interface AskBridgeServer {
+    enqueueAction(draft: {
+        actionId: string;
+        prompt: string;
+        options?: readonly string[];
+        allowFreeText?: boolean;
+    }): unknown;
+    resolveLocal(actionId: string): unknown;
+    setOnRemoteResolved(callback: (actionId: string, value: string) => void): void;
+}
+export interface BridgeAskOptions<T> {
+    actionId: string;
+    prompt: string;
+    options?: readonly string[];
+    allowFreeText?: boolean;
+    /** The local answer promise (e.g. the TUI select), wired to abort on `dismiss`. */
+    local: Promise<T>;
+    /** Aborted when the remote side wins, to cancel/dismiss the local prompt. */
+    dismiss: AbortController;
+    /** Map a remote answer string into the caller's local answer shape. */
+    onRemote: (value: string) => T;
+}
+/**
+ * Enqueue an ask on the server, then race the local answer against a remote reply for `actionId`.
+ * Local win → `resolveLocal` (so a late remote reply is rejected) and returns the local result.
+ * Remote win → aborts `dismiss` (cancelling the local prompt) and returns `onRemote(value)`.
+ * The remote subscription is always cleared before returning.
+ */
+export declare function bridgeAsk<T>(server: AskBridgeServer, options: BridgeAskOptions<T>): Promise<T>;

package/dist/types/notifications/config-command-parser.d.ts

@@ -0,0 +1,27 @@
+import type { NotificationVerbosity } from "./config";
+/**
+ * In-thread notification config command parser (chase 10.032): `/verbose`,
+ * `/lean`, `/verbosity [lean|verbose]`, `/redact [on|off|...]`. Mirrors the
+ * lifecycle-command-parser pattern. Pure / side-effect-free and intent-only —
+ * applying an intent to Settings is the caller's responsibility.
+ */
+export type NotificationConfigCommandIntent = {
+    kind: "set_verbosity";
+    verbosity: NotificationVerbosity;
+} | {
+    kind: "show_verbosity";
+} | {
+    kind: "set_redact";
+    redact: boolean;
+} | {
+    kind: "show_redact";
+};
+export type NotificationConfigCommandRejectionReason = "empty_command" | "unknown_command" | "unexpected_arguments" | "invalid_verbosity" | "invalid_redact_value";
+export type ParseNotificationConfigCommandResult = {
+    ok: true;
+    intent: NotificationConfigCommandIntent;
+} | {
+    ok: false;
+    reason: NotificationConfigCommandRejectionReason;
+};
+export declare function parseNotificationConfigCommand(input: string): ParseNotificationConfigCommandResult;

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

@@ -0,0 +1,37 @@
+import type { Settings } from "../config/settings";
+export type NotificationVerbosity = "lean" | "verbose";
+export interface NotificationSettingsSnapshot {
+    enabled: boolean;
+    botToken: string | undefined;
+    chatId: string | undefined;
+    redact: boolean;
+    verbosity: NotificationVerbosity;
+    idleTimeoutMs: number;
+}
+export interface ResolvedNotificationConfig extends NotificationSettingsSnapshot {
+    configured: boolean;
+    envRequested: boolean;
+    hardDisabled: boolean;
+}
+export interface NotificationEnvSnapshot {
+    notifications: string | undefined;
+    token: string | undefined;
+    chatId: string | undefined;
+}
+export declare function maskToken(token: string | undefined): string | null;
+export declare function maskChatId(chatId: string | undefined): string | null;
+export declare function resolveNotificationEnv(): NotificationEnvSnapshot;
+export declare function isNotificationConfigured(config: Pick<ResolvedNotificationConfig, "botToken" | "chatId">): boolean;
+export declare function isNotificationEnabled(config: Pick<ResolvedNotificationConfig, "enabled" | "configured">): boolean;
+export declare function isNotificationConnectTokenAccepted(expectedToken: string, presentedToken: string | undefined): boolean;
+export declare function getNotificationConfig(settings: Settings): ResolvedNotificationConfig;
+export interface NotificationStatusJson {
+    enabled: boolean;
+    configured: boolean;
+    botTokenMasked: string | null;
+    chatIdMasked: string | null;
+    redact: boolean;
+    verbosity: NotificationVerbosity;
+    idleTimeoutMs: number;
+}
+export declare function toNotificationStatusJson(config: ResolvedNotificationConfig): NotificationStatusJson;

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

@@ -0,0 +1,29 @@
+import { type TransportOwnerState } from "./transport-state";
+export type DaemonControlKind = "stop" | "reload";
+export interface DaemonControlRequest {
+    version: 1;
+    kind: DaemonControlKind;
+    /** The owner this control request targets; honored only when it matches the current owner. */
+    targetOwnerId: string;
+    requestedAt: number;
+}
+export type DaemonControlDecision = {
+    action: "honor-stop" | "honor-reload";
+    reason: "owner-match";
+} | {
+    action: "ignore";
+    reason: "no-request" | "owner-mismatch" | "stale-request";
+};
+export declare function daemonControlPath(agentDir: string): string;
+export declare function writeDaemonControl(agentDir: string, request: DaemonControlRequest): Promise<void>;
+export declare function readDaemonControl(agentDir: string): Promise<DaemonControlRequest | null>;
+export declare function clearDaemonControl(agentDir: string): Promise<void>;
+/**
+ * Decide whether a daemon should honor a stop/reload control request. Owner-scoped: a request is
+ * honored only when it targets the current owner and is not older than the owner's start — so a stale
+ * or mismatched request can never clear a newer owner.
+ */
+export declare function decideDaemonControl(input: {
+    current: TransportOwnerState | null;
+    request: DaemonControlRequest | null;
+}): DaemonControlDecision;

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

@@ -0,0 +1,64 @@
+import { type InboundDispatchEffects, type ProcessInboundUpdatesResult } from "./daemon-inbound";
+import { type OwnerClaimDecision } from "./daemon-owner";
+import { type NotificationEndpointRecord } from "./discovery";
+import { getTelegramUpdates } from "./telegram-api";
+import type { ThreadTopicRegistry } from "./threaded-surface";
+import { type ScanTransportSessionsResult } from "./transport-shell";
+import { type TransportOwnerState } from "./transport-state";
+export interface DaemonPollState {
+    offset?: number;
+    attempt: number;
+}
+export interface DaemonPollOutcome {
+    ok: boolean;
+    updateCount: number;
+    nextOffset?: number;
+    retryable?: boolean;
+    backoffMs?: number;
+    status?: number;
+    reason?: string;
+}
+export interface DaemonTickResult {
+    decision: OwnerClaimDecision;
+    owned: boolean;
+    scannedSessions: number;
+    poll?: DaemonPollOutcome;
+    nextPollState: DaemonPollState;
+    inbound?: ProcessInboundUpdatesResult;
+}
+/** Inbound (button/free-text remote answer) routing+execution config. When absent, polling is offset-only. */
+export interface DaemonInboundConfig {
+    registry: ThreadTopicRegistry;
+    effects: InboundDispatchEffects;
+    isDuplicateUpdate: (updateId: number) => boolean;
+    recordUpdateId?: (updateId: number) => void;
+    /** Defaults to reading the per-session discovery record under `agentDir`. */
+    loadRecord?: (sessionId: string) => Promise<NotificationEndpointRecord | null>;
+}
+export interface RunDaemonTickOptions {
+    agentDir: string;
+    token: string;
+    chatId: string;
+    ownerId: string;
+    pid: number;
+    now: () => number;
+    pollState?: DaemonPollState;
+    pollTimeoutSec?: number;
+    heartbeatTtlMs?: number;
+    pidAlive?: (pid: number) => boolean;
+    readOwner?: (agentDir: string) => Promise<TransportOwnerState | null>;
+    writeOwner?: (agentDir: string, owner: TransportOwnerState) => Promise<void>;
+    scan?: (options: {
+        agentDir: string;
+    }) => Promise<ScanTransportSessionsResult>;
+    getUpdates?: typeof getTelegramUpdates;
+    fetchImpl?: typeof fetch;
+    inbound?: DaemonInboundConfig;
+}
+/**
+ * Run one deterministic iteration of the managed Telegram daemon: claim/keep/defer the single owner
+ * slot, refresh the heartbeat, scan discovered sessions, and poll Telegram once (advancing the offset
+ * or backing off on a transient error). No OS process spawn and no real timers — the long-lived loop
+ * and reload/stop control are a later slice. All I/O is injectable for tests.
+ */
+export declare function runDaemonTick(options: RunDaemonTickOptions): Promise<DaemonTickResult>;

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

@@ -0,0 +1,93 @@
+import type { NotificationEndpointRecord } from "./discovery";
+import type { RemoteActionContext } from "./remote-answer";
+import type { TelegramUpdate } from "./telegram-api";
+import { type InboundDispatchAction, type InboundDispatchPlan } from "./telegram-inbound-router";
+import type { ThreadTopicRegistry } from "./threaded-surface";
+/**
+ * Daemon-side inbound bridge + executor (chase 10.032 live path).
+ *
+ * The managed Telegram daemon runs out-of-process from the agent sessions, so it cannot read a session's
+ * in-memory pending ask. The session publishes a {@link NotificationEndpointRecord.pendingAction} snapshot
+ * into its discovery record; `buildRemoteActionContextFromRecord` turns that into the synchronous
+ * `RemoteActionContext` the phase-49 router needs (to decode compact button callbacks against the ask
+ * `options`). This context is PRELIMINARY — the session re-validates every forwarded answer via
+ * `decideRemoteAnswer` and is the final authority on the local/remote race and idempotency.
+ *
+ * `executeInboundDispatchPlan` runs a router `InboundDispatchPlan` against injected real effects
+ * (`answerTelegramCallbackQuery` to clear the user's spinner; `forwardTelegramReplyToSession` to deliver an
+ * answer/reply to exactly one mapped session). Every action is isolated: a single failing effect is
+ * swallowed and tallied, never aborting the rest of the plan. No token, chat id, or session secret is ever
+ * logged or embedded in the result.
+ */
+/**
+ * Build a preliminary `RemoteActionContext` from a session's discovery record. Returns `undefined` when the
+ * record is stale or advertises no active ask — the daemon then has no daemon-side context and the router
+ * falls back to forwarding (text) or rejecting the callback spinner (button), all fail-closed.
+ */
+export declare function buildRemoteActionContextFromRecord(record: NotificationEndpointRecord): RemoteActionContext | undefined;
+export interface InboundDispatchEffects {
+    /** Clear a callback's loading spinner (`ok` = answer accepted). `text` is an optional short notice. */
+    answerCallback: (input: {
+        callbackQueryId: string;
+        ok: boolean;
+        text?: string;
+    }) => Promise<void>;
+    /** Forward an answer/reply value to exactly one mapped session; the session resolves authoritatively. */
+    forwardToSession: (input: {
+        sessionId: string;
+        value: string;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+}
+export interface ExecutedInboundAction {
+    kind: InboundDispatchAction["kind"];
+    ok: boolean;
+    detail?: string;
+}
+export interface ExecuteInboundResult {
+    executed: ExecutedInboundAction[];
+    /** callbacks acknowledged (spinner cleared) without throwing. */
+    acked: number;
+    /** answers/replies the mapped session accepted (forward returned ok). */
+    forwarded: number;
+    /** explicit router drops (no effect performed). */
+    dropped: number;
+    /** actions that threw OR forwards the session did not accept. */
+    failed: number;
+}
+/**
+ * Execute a router dispatch plan against real effects. Pure orchestration: never throws, isolates each
+ * action, and returns an accurate tally plus a per-action record.
+ */
+export declare function executeInboundDispatchPlan(plan: InboundDispatchPlan, effects: InboundDispatchEffects): Promise<ExecuteInboundResult>;
+/**
+ * Read-only resolution of which mapped session an inbound update targets, mirroring the router's
+ * chat/topic resolution WITHOUT any dedupe side effect. Returns `undefined` for a foreign/missing chat,
+ * a missing topic, or an unmapped thread. Used only to pick the session whose connect token + context the
+ * daemon should present to the router for that update.
+ */
+export declare function resolveTargetSession(update: TelegramUpdate, registry: ThreadTopicRegistry, expectedChatIdFingerprint: string): string | undefined;
+export interface ProcessInboundUpdatesOptions {
+    updates: readonly TelegramUpdate[];
+    registry: ThreadTopicRegistry;
+    expectedChatIdFingerprint: string;
+    /** Load a session's discovery record (its token + published pending-action snapshot). */
+    loadRecord: (sessionId: string) => Promise<NotificationEndpointRecord | null>;
+    isDuplicateUpdate: (updateId: number) => boolean;
+    recordUpdateId?: (updateId: number) => void;
+    effects: InboundDispatchEffects;
+}
+export interface ProcessInboundUpdatesResult {
+    processed: number;
+    results: ExecuteInboundResult[];
+}
+/**
+ * Route and execute a batch of polled Telegram updates. Pre-loads each mapped session's discovery record
+ * once per call (resolving the router's synchronous `resolveActionContext` seam), then routes every update
+ * with a per-update `presentedToken` set to its target session's connect token. The daemon is pre-authorized
+ * (it read that token from the local discovery file and matched the chat); the session re-validates every
+ * forwarded answer as the final authority. Never throws.
+ */
+export declare function processInboundUpdates(opts: ProcessInboundUpdatesOptions): Promise<ProcessInboundUpdatesResult>;

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

@@ -0,0 +1,28 @@
+import { type DaemonControlRequest } from "./daemon-control";
+import type { DaemonTickResult } from "./daemon-engine";
+import type { TransportOwnerState } from "./transport-state";
+export type DaemonLoopOutcome = "stopped" | "reloaded" | "max-ticks";
+export interface DaemonLoopResult {
+    ticks: number;
+    reloads: number;
+    outcome: DaemonLoopOutcome;
+}
+export interface RunDaemonLoopOptions {
+    tick: () => Promise<DaemonTickResult>;
+    sleep: (ms: number) => Promise<void>;
+    readControl: () => Promise<DaemonControlRequest | null>;
+    readOwner: () => Promise<TransportOwnerState | null>;
+    clearControl: () => Promise<void>;
+    /** Invoked when a stop is honored (e.g. mark the owner record stopped). */
+    onStop?: () => Promise<void> | void;
+    baseIntervalMs?: number;
+    /** Bound the run (tests / finite runs); omit for an unbounded daemon. */
+    maxTicks?: number;
+}
+/**
+ * Run the daemon loop: before each tick, check the owner-scoped control request. Honor a stop
+ * (run `onStop`, return `stopped`) or a reload (return `reloaded` so a supervisor relaunches; the
+ * fresh owner defers via `decideOwnerClaim` until the old pid dies). Otherwise run one tick and sleep
+ * for the poll's backoff (or the base interval). Injectable tick/sleep/I/O — no real timers.
+ */
+export declare function runDaemonLoop(options: RunDaemonLoopOptions): Promise<DaemonLoopResult>;

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

@@ -0,0 +1,25 @@
+import { type TransportIdentity, type TransportOwnerState } from "./transport-state";
+export type OwnerClaimReason = "no-owner" | "stale-owner" | "live-owner" | "self-owner";
+export interface OwnerClaimDecision {
+    action: "claim" | "defer" | "keep";
+    reason: OwnerClaimReason;
+}
+export interface DecideOwnerClaimInput {
+    /** The current owner record on disk, if any. */
+    current: TransportOwnerState | null | undefined;
+    /** The identity + pid of the daemon that wants to own the poll. */
+    candidate: TransportIdentity & {
+        pid: number;
+    };
+    now: number;
+    heartbeatTtlMs?: number;
+    pidAlive?: (pid: number) => boolean;
+}
+/**
+ * Decide whether a candidate daemon may claim the single Telegram poll owner slot.
+ *
+ * Exactly one owner is allowed (Telegram permits one active `getUpdates`). A fresh, live owner is
+ * never displaced; a stopped/stale/dead owner is replaceable; the candidate keeps ownership when it
+ * is already the live owner.
+ */
+export declare function decideOwnerClaim(input: DecideOwnerClaimInput): OwnerClaimDecision;

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

@@ -0,0 +1,32 @@
+import { type DaemonInboundConfig } from "./daemon-engine";
+import { type DaemonLoopResult } from "./daemon-loop";
+import type { deleteForumTopic } from "./telegram-api";
+export interface RunManagedDaemonOptions {
+    agentDir: string;
+    token: string;
+    chatId: string;
+    ownerId: string;
+    pid?: number;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    baseIntervalMs?: number;
+    pollTimeoutSec?: number;
+    maxTicks?: number;
+    fetchImpl?: typeof fetch;
+    heartbeatTtlMs?: number;
+    pidAlive?: (pid: number) => boolean;
+    /** Active per-session topics to best-effort delete on shutdown (e.g. ThreadTopicRegistry.list()). */
+    listActiveTopics?: () => ReadonlyArray<{
+        messageThreadId: number;
+    }>;
+    deleteTopicImpl?: typeof deleteForumTopic;
+    /** Optional inbound (remote answer) routing+execution config, threaded into every tick. */
+    inbound?: DaemonInboundConfig;
+}
+/**
+ * Run a managed Telegram daemon: wires the tested loop/tick/control/owner pieces to real transport
+ * and control I/O, carrying poll state across ticks and marking the owner stopped on a stop control.
+ * `sleep`/`fetchImpl`/`now`/`maxTicks` are injectable so the full stack runs end-to-end in tests with
+ * a mocked Telegram and no detached OS process.
+ */
+export declare function runManagedDaemon(options: RunManagedDaemonOptions): Promise<DaemonLoopResult>;

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

@@ -0,0 +1,45 @@
+/**
+ * Operational snapshot of the session's currently-active ask, published into the discovery record so the
+ * out-of-process managed daemon can decode compact button callbacks (which require the ask `options`) and
+ * build a preliminary `RemoteActionContext`. Carries NO token, prompt body, or other secret — only the
+ * routing-relevant action id and answer constraints. The session remains the final authority for
+ * resolution; this is a best-effort hint for the daemon.
+ */
+export interface NotificationPendingActionSnapshot {
+    actionId: string;
+    options?: string[];
+    allowFreeText?: boolean;
+}
+export interface NotificationEndpointRecord {
+    version: number;
+    sessionId: string;
+    url: string;
+    host: string;
+    port: number;
+    token: string;
+    startedAt: number;
+    updatedAt: number;
+    pid: number;
+    stale?: boolean;
+    stoppedAt?: number;
+    pendingAction?: NotificationPendingActionSnapshot;
+}
+export interface NotificationEndpointDisplay {
+    version: number;
+    sessionId: string;
+    url: string;
+    host: string;
+    port: number;
+    tokenMasked: string | null;
+    startedAt: number;
+    updatedAt: number;
+    pid: number;
+    stale: boolean;
+    stoppedAt?: number;
+}
+export declare function notificationDiscoveryDir(stateRoot: string): string;
+export declare function notificationDiscoveryPath(stateRoot: string, sessionId: string): string;
+export declare function writeNotificationDiscoveryRecord(stateRoot: string, record: NotificationEndpointRecord): Promise<string>;
+export declare function removeNotificationDiscoveryRecord(stateRoot: string, sessionId: string): Promise<void>;
+export declare function readNotificationDiscoveryRecord(stateRoot: string, sessionId: string): Promise<NotificationEndpointRecord | null>;
+export declare function toNotificationEndpointDisplay(record: NotificationEndpointRecord): NotificationEndpointDisplay;

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

@@ -0,0 +1,34 @@
+export * from "./ask-bridge";
+export * from "./config";
+export * from "./config-command-parser";
+export * from "./daemon-control";
+export * from "./daemon-engine";
+export * from "./daemon-inbound";
+export * from "./daemon-loop";
+export * from "./daemon-owner";
+export * from "./daemon-runtime";
+export * from "./discovery";
+export * from "./lifecycle-audit";
+export * from "./lifecycle-command-parser";
+export * from "./lifecycle-control-runtime";
+export * from "./notification-redaction";
+export * from "./protocol";
+export * from "./remote-answer";
+export * from "./reply-bridge";
+export * from "./server";
+export * from "./session-lifecycle";
+export * from "./session-registry";
+export * from "./telegram-api";
+export * from "./telegram-ask-keyboard";
+export * from "./telegram-callback-ingest";
+export * from "./telegram-inbound-router";
+export * from "./telegram-media-policy";
+export * from "./telegram-media-render";
+export * from "./telegram-message-ingest";
+export * from "./telegram-pairing";
+export * from "./threaded-lifecycle";
+export * from "./threaded-shutdown";
+export * from "./threaded-surface";
+export * from "./transport-shell";
+export * from "./transport-state";
+export * from "./workspace-path-confinement";