@gajae-code/coding-agent 0.11.9 → 0.11.11

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

@@ -5,7 +5,7 @@ import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/t
 import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
 import { proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
 import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
-import { ensureTelegramDaemonRunningDetailed, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { ensureTelegramDaemonRunningDetailed, readNotificationRootRegistration, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
 import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
 import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
 import { type CommandPaletteAction } from "../components/command-palette";
@@ -28,6 +28,13 @@ export interface NotificationsEditorAdapterContext {
     sessionManager: Pick<InteractiveModeContext["sessionManager"], "getCwd" | "getSessionId">;
     notifyConfigChanged?: () => Promise<void> | void;
 }
+type TelegramDaemonStopResult = {
+    ok: boolean;
+    message: string;
+    before?: {
+        health?: string;
+    };
+};
 export interface NotificationsEditorOperationDependencies {
     getNotificationConfig: typeof getNotificationConfig;
     maskToken: typeof maskToken;
@@ -43,7 +50,13 @@ export interface NotificationsEditorOperationDependencies {
     reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
     saveTelegramInactive: typeof saveTelegramInactive;
     removeTelegramConfiguration: typeof removeTelegramConfiguration;
+    readNotificationRootRegistration: typeof readNotificationRootRegistration;
     unregisterNotificationRoot: typeof unregisterNotificationRoot;
+    stopTelegramDaemonIfRootRegistryFenceMatches(input: {
+        settings: Settings;
+        registryFingerprint: string;
+        stop: () => Promise<TelegramDaemonStopResult>;
+    }): Promise<boolean>;
     reloadTelegramDaemon(settings: Settings): Promise<{
         ok: boolean;
         message: string;
@@ -52,13 +65,7 @@ export interface NotificationsEditorOperationDependencies {
         ok: boolean;
         message: string;
     }>;
-    stopTelegramDaemon(settings: Settings): Promise<{
-        ok: boolean;
-        message: string;
-        before?: {
-            health?: string;
-        };
-    }>;
+    stopTelegramDaemon(settings: Settings): Promise<TelegramDaemonStopResult>;
 }
 /**
  * Concrete service adapter for the direct Notifications settings tab. Secrets remain in this closure's
@@ -128,3 +135,4 @@ export declare class SelectorController {
     showJobsOverlay(observer: JobsObserver): void;
     showTasksPane(aggregator: TasksAggregator): void;
 }
+export {};

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

@@ -34,8 +34,12 @@ import { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import { type CompactionQueuedMessage, type ComposerSubmissionOptions, type InteractiveModeContext, type IrcArrivalSnapshot, type SubmittedUserInput, type TodoItem, type TodoPhase, type TranscriptRebuildPolicy } from "./types";
 import type { ParsedIrcMessage } from "./utils/irc-message";
-export declare function getDefaultComposerPlaceholder(context?: KeyDisplayContext): string;
+export declare function getDefaultComposerPlaceholder(context?: KeyDisplayContext, keybindings?: Pick<KeybindingsManager, "getDisplayString">): string;
 export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
+export declare function getComposerPlaceholder(keybindings: Pick<KeybindingsManager, "getDisplayString">, context: KeyDisplayContext, options: {
+    readonly busy: boolean;
+    readonly busyPromptMode: "steer" | "queue";
+}): string;
 export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;

package/dist/types/runtime/memory-domain.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryGuardDomainSnapshot, MemoryGuardWorkerSample } from "./memory-guard-contract";
+export interface MemoryGuardDomainInput {
+    effectiveLimitBytes: number;
+    totalUsageBytes: number;
+    parentBytes: number;
+    parentReserveBytes: number;
+    workers: readonly MemoryGuardWorkerSample[];
+}
+export declare function computeMemoryGuardDomain(input: MemoryGuardDomainInput): MemoryGuardDomainSnapshot;

package/dist/types/runtime/memory-guard-contract.d.ts

@@ -0,0 +1,71 @@
+export interface MemoryGuardPolicy {
+    enabled: boolean;
+    checkIntervalMs: number;
+    gcThresholdRatio: number;
+    restartThresholdRatio: number;
+    restartThresholdWindowMs: number;
+    cooldownMs: number;
+    parentReserveBytes: number;
+    policyLimitBytes: number | null;
+}
+export interface MemoryGuardWorkerSample {
+    workerId: string;
+    bytes: number;
+    accepted?: boolean;
+}
+export interface MemoryGuardWorkerAccounting {
+    workerId: string;
+    bytes: number;
+    accepted: boolean;
+    allowanceBytes: number;
+    excessBytes: number;
+}
+export interface MemoryGuardDomainSnapshot {
+    effectiveLimitBytes: number;
+    totalUsageBytes: number;
+    parentBytes: number;
+    parentReserveBytes: number;
+    totalWorkerBytes: number;
+    acceptedWorkerCount: number;
+    unmanagedBytes: number;
+    headroomBytes: number;
+    workerBudgetBytes: number;
+    perWorkerAllowanceBytes: number;
+    hostExcessBytes: number;
+    workers: MemoryGuardWorkerAccounting[];
+}
+export interface MemoryGuardHostTarget {
+    kind: "host";
+    excessBytes: number;
+}
+export interface MemoryGuardWorkerTarget {
+    kind: "worker";
+    workerId: string;
+    excessBytes: number;
+}
+export type MemoryGuardActionTarget = MemoryGuardHostTarget | MemoryGuardWorkerTarget;
+export type MemoryGuardNoopReason = "memory_guard_action_noop_unmanaged_or_within_allowance" | "memory_guard_action_noop_unsupported";
+export type MemoryGuardDecision = {
+    kind: "execute";
+    target: MemoryGuardActionTarget;
+} | {
+    kind: "noop";
+    reason: MemoryGuardNoopReason;
+} | {
+    kind: "revalidated_out";
+    reason: "memory_guard_action_revalidated_out";
+};
+export interface MemoryGuardSchedulerState {
+    timerActive: boolean;
+    registrationCount: number;
+    inProgress: boolean;
+    generation: number;
+    pendingDeadline: number | null;
+    pendingOwner: {
+        generation: number;
+        token: number;
+    } | null;
+    deferredDeadline: number | null;
+    deferredGeneration: number | null;
+    activeGeneration: number | null;
+}

package/dist/types/runtime/memory-guard.d.ts

@@ -0,0 +1,39 @@
+import type { Settings } from "../config/settings";
+import type { MemoryGuardDecision, MemoryGuardDomainSnapshot, MemoryGuardPolicy, MemoryGuardSchedulerState } from "./memory-guard-contract";
+type WorkOwner = {
+    generation: number;
+    source: "timer" | "external";
+};
+export interface MemoryGuardHostRegistration {
+    ownerId: string;
+    intervalMs: number;
+}
+export interface MemoryGuardHostOptions {
+    run: () => Promise<void>;
+    logDebug?: (message: string, meta?: Record<string, unknown>) => void;
+    schedulerNow?: () => number;
+}
+export declare function resolveMemoryGuardPolicy(settings: Settings): MemoryGuardPolicy;
+export declare function chooseMemoryGuardAction(input: {
+    domain: MemoryGuardDomainSnapshot;
+    hostSupported: boolean;
+    workerSupported: (workerId: string) => boolean;
+}): MemoryGuardDecision;
+export declare function revalidateMemoryGuardAction(previous: Extract<MemoryGuardDecision, {
+    kind: "execute";
+}>, revalidated: MemoryGuardDecision): MemoryGuardDecision;
+export declare class MemoryGuardHost {
+    #private;
+    constructor(options: MemoryGuardHostOptions);
+    register(registration: MemoryGuardHostRegistration): () => void;
+    updateInterval(ownerId: string, intervalMs: number): void;
+    runTick(generation?: number, source?: WorkOwner["source"]): Promise<void>;
+    runTimerCallbackForTest(owner: {
+        generation: number;
+        token: number;
+    }, deadline: number): Promise<void>;
+    setSchedulerNowForTest(now: () => number): void;
+    getStateForTest(): MemoryGuardSchedulerState;
+    resetForTest(): void;
+}
+export {};

package/dist/types/runtime/memory-limit.d.ts

@@ -0,0 +1,11 @@
+export interface EffectiveMemoryLimitInput {
+    hardCapBytes?: number | null;
+    policyLimitBytes?: number | null;
+}
+export interface EffectiveMemoryLimit {
+    hardCapBytes: number | null;
+    policyLimitBytes: number | null;
+    effectiveBytes: number | null;
+    source: "none" | "hard_cap" | "policy_limit" | "hard_cap_and_policy_limit";
+}
+export declare function resolveEffectiveMemoryLimit(input: EffectiveMemoryLimitInput): EffectiveMemoryLimit;

package/dist/types/runtime-mcp/manager.d.ts

@@ -5,6 +5,7 @@ import type { AuthStorage } from "../session/auth-storage";
 import type { MCPToolDetails } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
+export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
 /**
  * Stable, total ordering on MCP tools by name.
  *
@@ -48,6 +49,13 @@ export interface MCPDiscoverOptions {
 export interface MCPManagerOptions {
     /** Restrict this instance to tools from an explicit MCP config. */
     toolsOnly?: boolean;
+    /**
+     * Ceiling for the startup wait, in milliseconds. Only ACP lifecycle launches
+     * set this, so a slow ACP MCP handshake gets the readiness budget while every
+     * other consumer keeps the short default. Non-positive or non-finite values
+     * are ignored and the default applies.
+     */
+    maxStartupTimeoutMs?: number;
 }
 /**
  * MCP Server Manager.

package/dist/types/sdk/acp/final-text.d.ts

@@ -0,0 +1,19 @@
+export declare const ACP_FINAL_TEXT_LIMIT = 100000;
+export interface BoundedAcpFinalText {
+    text: string;
+    truncated: boolean;
+}
+export type AcpFinalTextResolution = {
+    kind: "none";
+    final: BoundedAcpFinalText;
+} | {
+    kind: "emit";
+    final: BoundedAcpFinalText;
+    text: string;
+} | {
+    kind: "divergent";
+    final: BoundedAcpFinalText;
+};
+export declare function boundAcpFinalText(value: string): BoundedAcpFinalText;
+export declare function acpFinalTextFromMessage(message: unknown): BoundedAcpFinalText;
+export declare function resolveAcpFinalText(streamed: string, finalText: string): AcpFinalTextResolution;

package/dist/types/sdk/acp/mcp.d.ts

@@ -0,0 +1,23 @@
+export declare const ACP_MCP_REQUEST_TIMEOUT_MS = 30000;
+export declare const ACP_MCP_LIFECYCLE_TIMEOUT_MS: number;
+/**
+ * Slice of the readiness budget reserved for the work that follows MCP startup
+ * (session wiring, marker publication). The ACP MCP startup ceiling is the
+ * remaining time to `semanticReadyDeadlineAt` minus this headroom, so a slow
+ * MCP handshake cannot consume the whole readiness window.
+ */
+export declare const ACP_MCP_STARTUP_HEADROOM_MS = 250;
+export interface SessionLifecycleMcpStdioServer {
+    type?: "stdio";
+    name: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface SessionLifecycleMcpRemoteServer {
+    type: "http" | "sse";
+    name: string;
+    url: string;
+    headers?: Record<string, string>;
+}
+export type SessionLifecycleMcpServer = SessionLifecycleMcpStdioServer | SessionLifecycleMcpRemoteServer;

package/dist/types/sdk/broker/lifecycle.d.ts

@@ -1,3 +1,4 @@
+import type { SessionLifecycleMcpServer } from "../acp/mcp";
 import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
 import type { Broker, BrokerCleanupEvidence, BrokerResponse } from "./broker";
 import type { LifecycleDurableEffectsReceipt, LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -61,6 +62,7 @@ export interface SessionLifecycleLaunchRequest {
     /** Broker-issued effect marker which the child echoes only after host readiness. */
     effectMarker?: string;
     modelPreset?: string;
+    mcpServers?: SessionLifecycleMcpServer[];
     worktree?: SessionLifecycleWorktreeTarget;
     receivedAt: number;
     requestedReadinessTimeoutMs: number;

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -15,7 +15,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * concrete detached quarantine plus a proven-absent canonical lock pathname —
  * when deleting an observed owner-lock lease. Generation 12 refreshes retained
  * native path and process authority semantics. Generation 13 rejects special
- * files before retained native authority opens.
+ * files before retained native authority opens. Generation 14 reloads shared
+ * chat daemons after notification configuration parsing changes.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/daemon-paths.d.ts

@@ -9,6 +9,7 @@ export interface DaemonPaths {
     dir: string;
     lock: string;
     state: string;
+    heartbeat: string;
     ownership: string;
     roots: string;
     steal: string;

package/dist/types/sdk/bus/index.d.ts

@@ -29,7 +29,7 @@ import { CursorRegistry, RevisionStore } from "../host/query";
 import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
-import { type EnsureDaemonResult } from "./telegram-daemon";
+import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -324,6 +324,12 @@ interface SessionRuntime {
     hostStopped: boolean;
     serverStopped: boolean;
     brokerRegistrationReleased: boolean;
+    /** Managed Telegram root registration released during terminal teardown. */
+    notificationRootRegistration?: {
+        settings: Settings;
+        cwd: string;
+        registrationToken?: string;
+    };
     verbosity: "lean" | "verbose";
     sessionTag: string;
     /** Whether the agent loop is currently running (drives the typing indicator). */
@@ -368,6 +374,7 @@ interface SessionRuntime {
         sessionId: string;
         commandId?: string;
         turnId?: string;
+        finalText?: string;
     } | {
         type: "agent_failed";
         sessionId: string;
@@ -417,7 +424,8 @@ interface SessionRuntime {
     /** Started tool calls awaiting a terminal activity frame, keyed by tool call id. */
     inFlightTools: Map<string, {
         toolName: string;
-        args: unknown;
+        args?: unknown;
+        pendingPhase?: "completed" | "failed" | "cancelled";
     }>;
     /** Cancels the postmortem cleanup that emits `session_closed` on process teardown. */
     cancelPostmortemCleanup: () => void;
@@ -511,6 +519,7 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
         settings: Settings;
         cwd: string;
         sessionId: string;
+        onRegistered?: (registration: RegisterNotificationRootResult) => void;
     }) => Promise<EnsureDaemonResult>;
     ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>;
     /** Suppress auto-delivery for a GJC-spawned child under `sessionScope=primary`. */

package/dist/types/sdk/bus/operator-runtime.d.ts

@@ -47,6 +47,7 @@ export declare class NotificationOperatorRuntime {
     stopInterval(name: string): void;
     stopAllIntervals(): void;
     runExclusive(name: string, fn: () => Promise<void>): Promise<void>;
+    joinExclusive(name: string, timeoutMs: number): Promise<boolean>;
     sleep(ms: number, signal?: AbortSignal): Promise<void>;
     now(): number;
 }

package/dist/types/sdk/bus/rate-limit-pool.d.ts

@@ -84,6 +84,8 @@ export declare class RateLimitPool<T = unknown> {
     constructor(options?: RateLimitPoolOptions);
     /** Number of items currently queued across all lanes. */
     get pending(): number;
+    /** Whether any queued item currently matches the predicate. */
+    someQueued(predicate: (item: RateLimitItem<T>) => boolean): boolean;
     /** Current available token count (after refill at `now`). */
     availableTokens(nowMs?: number): number;
     /**

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -5,12 +5,9 @@
 /** Protocol version the daemon advertises in its ClientHello. */
 export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
 /**
- * Operational generation the current daemon build speaks. Decoupled from
- * {@link NOTIFICATION_PROTOCOL_VERSION} (#2304): additive `tool_activity` /
- * `reasoning_summary` frames do not bump the wire protocol version, but a
- * freshly-upgraded host must still recognize an older, still-live daemon that
- * predates capability-gated frame enforcement and trigger a reload. Bump this
- * on every daemon-behavior change independent of the wire version.
+ * Guarded behavior-inventory version for the current daemon build. Bump this
+ * on every guarded daemon-behavior change independent of the wire version; it
+ * does not force a live daemon reload by itself.
  * The current development baseline already includes #2299's generation 4,
  * incarnation fencing in generation 5, owner-lock authority in generation 6,
  * identity-atomic transition markers in generation 7, stable signaling plus
@@ -38,5 +35,15 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * cooldown and lazy Telegram topic lifecycle safeguards (#2956, #2960, #2984).
  * Generation 27 refreshes retained native path and process authority semantics.
  * Generation 28 rejects special files before retained native authority opens.
+ * Generation 29 adds serving-epoch compatibility, sidecar heartbeat, root GC,
+ * and Bot API cooldown structural fixes (#2956, #2960, #3048).
+ * Generation 30 adds opt-in tool activity delivery, closed lifecycle phases,
+ * and capability-versioned mixed-host compatibility.
  */
-export declare const DAEMON_GENERATION = 28;
+export declare const DAEMON_GENERATION = 30;
+/**
+ * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers
+ * all builds published before this field existed; epoch 2 covered generation 29;
+ * bump this to force serving convergence and reload of compatible live predecessors.
+ */
+export declare const SERVING_EPOCH = 3;

package/dist/types/sdk/bus/telegram-daemon.d.ts

@@ -5,10 +5,10 @@ import { HEARTBEAT_TTL_MS } from "./daemon-paths";
 import { type DaemonTransitionLock, type NotificationEndpointFile, type NotificationEndpointFileIdentity, type NotificationExactUnlinkResult } from "./notification-service";
 import { type DaemonProcessReference } from "./telegram-daemon-control";
 import { type TelegramSetupPreflight } from "./telegram-setup";
-export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION } from "./telegram-daemon-contract";
+export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION, SERVING_EPOCH } from "./telegram-daemon-contract";
 import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
 import type { OrchestratorDeps } from "./lifecycle-orchestrator";
-import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
+import { NotificationOperatorRuntime } from "./operator-runtime";
 import { type AliasTable, type CallbackRoute } from "./telegram-reference";
 import { type TopicEndpointBinding } from "./topic-registry";
 export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
@@ -41,6 +41,8 @@ export interface DaemonState {
      * notification wire protocol version. Absent on pre-generation state.
      */
     generation?: number;
+    /** Lifecycle-serving compatibility epoch; absent pre-epoch records are epoch 1. */
+    servingEpoch?: number;
     stoppedAt?: number;
 }
 export interface TelegramDaemonFs {
@@ -105,8 +107,10 @@ export declare const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 /** Capability required for typed controls and semantic Selected acknowledgement frames. */
 export declare const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
 export declare const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
-/** Capability required for tool lifecycle and reasoning-summary frames. */
-export declare const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
+/** Capability for the closed tool phase set: started, completed, failed, and cancelled. */
+export declare const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
+/** Receive-only compatibility capability for pre-v2 hosts. */
+export declare const LEGACY_TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
 /**
  * File-lock options whose acquisition budget covers the full reload-reservation
  * critical section: the in-lock freshness poll plus the controller's
@@ -201,15 +205,59 @@ export declare function liveOwnershipLockDecision(input: {
     attached: false;
     provisional: true;
 } | undefined;
+type OwnerHeartbeatSidecar = {
+    pid: number;
+    incarnation: string;
+    ownerId: string;
+    acquisitionId: string;
+    heartbeatAt: number;
+};
+export interface OwnerFreshnessSnapshot {
+    ownerTag: Pick<OwnerHeartbeatSidecar, "pid" | "incarnation" | "ownerId" | "acquisitionId"> | null;
+    effectiveHeartbeatAt: number | undefined;
+    legacyEmbedded: boolean;
+    state: DaemonState | undefined;
+}
+export declare function readOwnerFreshnessSnapshot(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+}): Promise<OwnerFreshnessSnapshot>;
+/** Marker-free steady heartbeat renewal. The final lock reread fences a stale writer. */
+export declare function renewOwnerHeartbeatSidecar(input: {
+    settings: Settings;
+    ownerId: string;
+    acquisitionId?: string;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    pid?: number;
+    pidIncarnation?: (pid: number) => string | undefined;
+}): Promise<boolean>;
+export interface NotificationRootRegistration {
+    root?: string;
+    managed?: boolean;
+    token?: string;
+}
+export declare function readNotificationRootRegistration(input: {
+    settings: Settings;
+    sessionId: string;
+    fs?: TelegramDaemonFs;
+}): Promise<NotificationRootRegistration>;
+export interface RegisterNotificationRootResult {
+    root: string;
+    /** Per-registration ownership token fencing a stale same-session cleanup from deleting a live replacement registration. */
+    token: string;
+}
 export declare function registerNotificationRoot(input: {
     settings: Settings;
     cwd: string;
     sessionId: string;
     fs?: TelegramDaemonFs;
-}): Promise<string>;
+}): Promise<RegisterNotificationRootResult>;
 export interface UnregisterNotificationRootResult {
     root: string;
     remainingRoots: number;
+    /** Opaque fingerprint of the exact registry written by this successful unregister. */
+    registryFingerprint?: string;
 }
 /** Remove one session's Telegram scan root without disturbing other live session roots. */
 export declare function unregisterNotificationRoot(input: {
@@ -217,7 +265,16 @@ export declare function unregisterNotificationRoot(input: {
     cwd: string;
     sessionId: string;
     fs?: TelegramDaemonFs;
+    /** Ownership token minted by this runtime's own registration; a stale cleanup presenting an older token never deletes a replacement registration. */
+    registrationToken?: string;
 }): Promise<UnregisterNotificationRootResult>;
+/** Run an action while the roots registry lock excludes any registration or unregister. */
+export declare function withNotificationRootRegistryFence(input: {
+    settings: Settings;
+    registryFingerprint: string;
+    action: () => Promise<void>;
+    fs?: TelegramDaemonFs;
+}): Promise<boolean>;
 /**
  * Leak artifact prefixes left when native exact-unlink cleanup is retained
  * (#2956). Nothing previously reaped these; they accumulate in the notifications
@@ -319,6 +376,7 @@ export declare function isFreshLiveOwner(input: {
     chatId: string;
     pidAlive: (pid: number) => boolean;
     pidIncarnation?: (pid: number) => string | undefined;
+    effectiveHeartbeatAt?: number;
 }): boolean;
 /** True only when a physically live matching owner can serve this build's daemon lifecycle contract. */
 export declare function isCurrentCompatibleOwner(input: {
@@ -328,6 +386,7 @@ export declare function isCurrentCompatibleOwner(input: {
     chatId: string;
     pidAlive: (pid: number) => boolean;
     pidIncarnation?: (pid: number) => string | undefined;
+    effectiveHeartbeatAt?: number;
 }): boolean;
 export declare function acquireDaemonOwnership(input: {
     settings: Settings;
@@ -399,7 +458,7 @@ export declare function retireProvisionalDaemonOwnership(input: {
     /** Only no-child confirmation may retire a ready-like launcher publication. */
     allowReadyWithoutChildPid?: boolean;
 }): Promise<boolean>;
-/** Wait for a matching current-generation daemon to publish a ready state. */
+/** Wait for a matching compatible owner to publish a ready state. Readiness is serving-epoch gated (same-epoch cross-generation owners attach, per isCurrentCompatibleOwner); generation is inventory-only here. Mutation paths still require exact current-generation equality. */
 export declare function waitForTelegramDaemonReady(input: {
     settings: Settings;
     ownerId?: string;
@@ -548,6 +607,9 @@ export declare function ensureTelegramDaemonRunningDetailed(input: {
     settings: Settings;
     cwd: string;
     sessionId: string;
+    registerRoot?: boolean;
+    /** Receives each registration this ensure operation minted so the caller can fence its own later cleanup. */
+    onRegistered?: (registration: RegisterNotificationRootResult) => void;
 }, deps?: TelegramDaemonDeps): Promise<EnsureTelegramDaemonDetailedResult>;
 /**
  * Legacy compatibility mapping for callers that only distinguish ownership from
@@ -600,7 +662,10 @@ export type TelegramPollResult = {
 export interface TelegramUpdatePollerOptions {
     botApi: BotApi;
     runtime: NotificationOperatorRuntime;
-    backoff: OperatorBackoffPolicy;
+    backoff: {
+        next(): number;
+        reset(): void;
+    };
     processUpdate: (update: unknown) => Promise<TelegramUpdateOutcome>;
     health?: TelegramPollHealth;
 }
@@ -689,7 +754,7 @@ export interface TelegramDaemonOptions {
     richDraft?: {
         enabled: boolean;
     };
-    /** Tool start/completion messages (enabled by default). */
+    /** Tool start/completion messages (off by default; explicit opt-in only). */
     toolActivity?: {
         enabled: boolean;
     };
@@ -723,6 +788,8 @@ interface SessionSocket {
     /** True once the server advertised the `client_ping_pong` capability. */
     capable: boolean;
     ephemeralCapable: boolean;
+    /** Tool activity contract advertised by the connected host. */
+    toolActivityCapability?: "v1" | "v2";
     /** Timestamp (via opts.now) of the last received pong; seeds the TTL window. */
     lastPongAt: number;
     /** Nonce of the most recent in-flight ping, if any. */
@@ -752,6 +819,9 @@ export declare class TelegramNotificationDaemon {
     /** Endpoint-bound ownership for visible or dispatching tool bubbles. */
     private readonly toolActivityOwners;
     private readonly revokedToolEndpoints;
+    /** Exact settlement of each admitted legacy-v1 start; retained only while visible. */
+    private readonly legacyToolStarts;
+    private nextLegacyToolStartId;
     private readonly unresolvedToolTerminalizations;
     private toolTerminalizationChain;
     private toolActivityPolicyEpoch;
@@ -785,6 +855,9 @@ export declare class TelegramNotificationDaemon {
     private readonly pool;
     private readonly poller;
     private readonly dispatchState;
+    /** Bot-wide flood-control window; inbound polling remains eligible during it. */
+    private botCooldownUntil;
+    private warnedBotCooldownUntil;
     /** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
     private readonly replyStore;
     /** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
@@ -871,6 +944,9 @@ export declare class TelegramNotificationDaemon {
     private refreshBotIdentity;
     /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
     private formatLifecycleResponse;
+    private callBotApi;
+    private readonly callBotApiClassified;
+    private botApiWithOutcomeCollector;
     constructor(opts: TelegramDaemonOptions);
     private createSessionRouter;
     loadAliases(): Promise<void>;
@@ -917,8 +993,21 @@ export declare class TelegramNotificationDaemon {
     private topicIdentityKey;
     private topicIdentityBase;
     private topicOwnerForIdentity;
+    private admitLegacyToolStart;
+    private legacyToolStartForTerminal;
+    private settleLegacyToolStart;
+    private cancelUnsentLegacyToolStart;
+    private failLegacyToolStart;
+    private settleRejectedLegacyToolSubmission;
+    private cancelLegacyToolStartsForSession;
+    private cleanLegacyToolStartsForCapabilityUpgrade;
+    private cancelLegacyToolStartsForPolicyTransition;
     private toolActivityOwner;
+    private renderThreadedFrame;
+    private toolActivityFrameWithoutSummaries;
+    private toolActivitySummariesAreCurrent;
     private toolActivityAuthorityIsCurrent;
+    private toolActivityDeliveryIsCurrent;
     private submitThreadedFrame;
     private existingTopicForPrivateChat;
     private topicAuthorityLease;

package/dist/types/sdk/host/control/operations.d.ts

@@ -18,6 +18,7 @@ export interface ControlSurface {
     operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
     replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;
     setModel(id: string, thinkingLevel?: ControlValue): Promise<ControlValue> | ControlValue;
+    setModelProfile(id: string): Promise<ControlValue> | ControlValue;
     cycleModel(): Promise<ControlValue> | ControlValue;
     setThinking(level: ControlValue): Promise<ControlValue> | ControlValue;
     cycleThinking(): Promise<ControlValue> | ControlValue;

package/dist/types/sdk/lifecycle-session.d.ts

@@ -10,5 +10,14 @@ export type CreateLifecycleAgentSessionResult = {
     rollback: SdkStartupRollbackTracker;
     failure: SdkStartupFailure;
 };
+/** Options accepted by lifecycle-only session construction. */
+export type CreateLifecycleAgentSessionOptions = CreateAgentSessionOptions & {
+    /**
+     * Startup budget for ACP lifecycle MCP launches, in milliseconds. Set only
+     * when the lifecycle request supplies `mcpServers`; ordinary consumers keep
+     * the manager's short default ceiling.
+     */
+    mcpStartupTimeoutMs?: number;
+};
 /** Internal lifecycle-only session construction with an owner-bound SDK startup result. */
-export declare function createLifecycleAgentSession(options?: CreateAgentSessionOptions): Promise<CreateLifecycleAgentSessionResult>;
+export declare function createLifecycleAgentSession(options?: CreateLifecycleAgentSessionOptions): Promise<CreateLifecycleAgentSessionResult>;