@gajae-code/coding-agent 0.11.10 → 0.12.0

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/runtime-mcp/smithery-auth.d.ts

@@ -7,6 +7,11 @@ type SmitheryCliPollResponse = {
     apiKey?: string;
     message?: string;
 };
+/** Test seam: the Smithery origin and env API key as resolved from trusted env. */
+export declare function resolveSmitheryEnvForTest(): {
+    url: string;
+    apiKey: string | undefined;
+};
 export declare function getSmitheryLoginUrl(): string;
 export declare function createSmitheryCliAuthSession(): Promise<SmitheryCliAuthSession>;
 export declare function pollSmitheryCliAuthSession(sessionId: string, signal?: AbortSignal): Promise<SmitheryCliPollResponse>;

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;
@@ -71,6 +73,11 @@ export interface SessionLifecycleLaunchRequest {
 export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
 type CleanupEvidence = BrokerCleanupEvidence;
 export declare function validateBrokerModelPresetForTest(agentDir: string, requestedProfile: string): string | BrokerResponse;
+/** Test seam: the session-host command override as resolved from trusted env. */
+export declare function sdkSessionCommandOverrideForTest(): {
+    file: string;
+    args: string[];
+} | undefined;
 export declare function setProcessIncarnationForTest(broker: Broker, value: ((pid: number) => string | undefined) | undefined): void;
 /** The child writes this only after its endpoint and semantic ready event are both live. */
 export declare function writeSessionLifecycleReady(root: string, id: string, effectMarker: string): Promise<void>;

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/control-drain-lease.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Ordering seam for an in-band SDK identity transition.
+ *
+ * A request arrives through predecessor A, so a successful terminal response cannot
+ * be published until successor B is ready. Native builds may provide a true
+ * send-only connection lease; source/dev builds use the conservative fallback in
+ * which the predecessor server remains alive until the terminal write completes.
+ */
+export type TerminalSendOutcome = "written" | "disconnected" | "write_failed";
+/** Fence/capability hooks may return false to reject; undefined means ok. */
+export type IdentityControlGateResult = boolean | undefined;
+export type IdentityControlGate = () => IdentityControlGateResult | Promise<IdentityControlGateResult>;
+export interface IdentityControlSuccessPathInput {
+    /** Fence predecessor inbound work. The fence must not close its response writer. */
+    fence: IdentityControlGate;
+    /** Optional explicit proof that the predecessor writer is still usable. */
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    /** Start successor B and resolve only after its public endpoint is ready. */
+    startSuccessor: () => Promise<void>;
+    /** Write and flush either the success or non-success terminal response. */
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    /** Release predecessor A after the terminal response has settled. */
+    stopPredecessor: () => Promise<void>;
+    /** Set only when a caller cannot use the retained-writer fallback. */
+    requireNativeControlDrain?: boolean;
+}
+export interface IdentityControlTerminalPathInput {
+    fenceInbound: IdentityControlGate;
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    startSuccessorReady: () => Promise<void>;
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    stopPredecessor: () => Promise<void>;
+    requireNativeControlDrain?: boolean;
+}
+/**
+ * Probe the loaded native addon, never an environment flag or a TypeScript shim.
+ * Older/source installs intentionally report false so callers can select the
+ * retained-writer fallback or fail closed when detach is mandatory.
+ */
+export declare function isNativeControlDrainAvailable(): boolean;
+/**
+ * Run the only safe ordering for a successful identity-control response.
+ *
+ * The `finally` is deliberately around both successor startup and terminal
+ * delivery: a failed startup must not leave the fenced predecessor alive, and a
+ * failed/disconnected terminal write must still release it. When native detach
+ * is unavailable the caller is expected to keep A's server up (not call
+ * `stopAndWait`) until `sendTerminal` settles.
+ */
+export declare function runIdentityControlSuccessPath(input: IdentityControlSuccessPathInput): Promise<TerminalSendOutcome>;
+/** Compatibility spelling used by the host wiring design notes. */
+export declare function runIdentityControlTerminalPath(input: IdentityControlTerminalPathInput): Promise<TerminalSendOutcome>;

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

@@ -30,6 +30,8 @@ import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
 import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
+export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
+export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -297,6 +299,8 @@ interface SessionRuntime {
     disposeGateListener: () => void;
     /** Whether notification-only delivery and answer resources are active. */
     notificationsActive: boolean;
+    /** Rejects new SDK frames while a leased terminal response drains. */
+    inboundFenced: boolean;
     /** Set as soon as terminal teardown is requested, before startup settles. */
     stopping: boolean;
     /** Recreates notification-only resources after `/notify on`. */
@@ -374,6 +378,7 @@ interface SessionRuntime {
         sessionId: string;
         commandId?: string;
         turnId?: string;
+        finalText?: string;
     } | {
         type: "agent_failed";
         sessionId: string;
@@ -423,7 +428,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 +517,17 @@ export declare class EphemeralTurnHost {
  * an identity for a transport that never became available is false success.
  */
 export declare function ensureConfiguredProviderDaemons(settings: Settings, cfg: NotificationConfig, ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>): Promise<void>;
+/**
+ * Classify whether a session identity event must await notification endpoint startup.
+ * Only an interactive selector resume may defer this ancillary startup; all other
+ * events, including branches and unknown origins, fail closed to awaiting it.
+ */
+export declare function shouldAwaitNotificationStartup(event: {
+    type: "session_switch" | "session_branch";
+    transition?: {
+        origin: string;
+    };
+}): boolean;
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
@@ -537,4 +554,3 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     readNotificationFile?: (path: string) => Promise<Buffer>;
     readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
 }): void;
-export {};

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
+ * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
+ */
+import { type PromptCorrelation, type PromptReconciliationStatus, type TurnPromptReconciliation } from "./prompt-reconciliation";
+import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
+export type { ReconciliationKind };
+export interface KindCorrelation extends PromptCorrelation {
+    kind: ReconciliationKind;
+}
+export interface KindAwareReconciliation {
+    admit(kind: ReconciliationKind, clientRef?: string): void;
+    releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
+    noteAccepted(kind: ReconciliationKind, correlation: PromptCorrelation, clientRef?: string, extra?: {
+        skillName?: string;
+    }): Promise<void>;
+    noteTransition(kind: ReconciliationKind, correlation: PromptCorrelation | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }): Promise<void>;
+    lookup(kind: ReconciliationKind, selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): TurnPromptReconciliation;
+    cleanup(): void;
+    activeCount(kind: ReconciliationKind): number;
+    /** Hydrate from durable store (call once at session host start). */
+    hydrateFromStore(): Promise<void>;
+}
+export declare function createKindAwareReconciliation(options?: {
+    now?: () => number;
+    store?: ReconciliationStore | null;
+}): KindAwareReconciliation;
+export type { PromptReconciliationStatus };

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -12,7 +12,8 @@
  * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
  *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
  *   does a lookup honestly report `unknown`.
- * - The durability floor is the live session process: restart means `unknown`.
+ * - Process-local durability floor is the live session process: restart means `unknown`.
+ *   Session-scoped durable retention (kind-aware store) is provided by reconciliation-store.ts (#3032).
  * - The clientRef index is session-runtime scoped; a ref conflicts only while
  *   retained and must never be reused as a retry mechanism.
  * - Terminal transitions settle once: the first terminal outcome wins.

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/reconciliation-store.d.ts

@@ -0,0 +1,65 @@
+import type { PromptCorrelation, PromptReconciliationStatus } from "./prompt-reconciliation";
+export declare const RECONCILIATION_STORE_VERSION = 1;
+export declare const RECONCILIATION_SESSION_ID_PATTERN: RegExp;
+export declare const RECONCILIATION_DIR_NAME = ".sdk-reconciliation";
+export type ReconciliationKind = "prompt" | "skill";
+export interface DurableReconciliationRecord extends PromptCorrelation {
+    kind: ReconciliationKind;
+    clientRef?: string;
+    status: PromptReconciliationStatus;
+    error?: {
+        code: string;
+        message: string;
+    };
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+    /** Skill-only safe token; never skill args bodies. */
+    skillName?: string;
+}
+export interface ReconciliationStoreDocument {
+    version: typeof RECONCILIATION_STORE_VERSION;
+    sessionId: string;
+    records: DurableReconciliationRecord[];
+}
+export interface ReconciliationStoreFs {
+    mkdir(directory: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<unknown>;
+    readFile(file: string, encoding: "utf8"): Promise<string>;
+    writeFile(file: string, data: string, options: {
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(file: string): Promise<void>;
+    open(file: string, flags: string): Promise<{
+        sync(): Promise<void>;
+        close(): Promise<void>;
+        writeFile(data: string, encoding: "utf8"): Promise<void>;
+    }>;
+}
+export declare function isSafeReconciliationSessionId(sessionId: string): boolean;
+/** Derive private store path; throws if sessionId is unsafe (path escape). */
+export declare function reconciliationStorePath(sessionFile: string, sessionId: string): string;
+/**
+ * Settle non-terminal durable records after process death: failed/process_restart.
+ * Meaning: reconciliation incomplete — not proof of agent failure.
+ */
+export declare function settleProcessRestart(records: DurableReconciliationRecord[], now: number): DurableReconciliationRecord[];
+export interface ReconciliationStore {
+    readonly path: string | null;
+    readonly sessionId: string;
+    /** Serialize mutations; reload not required for single-process host (in-memory + write). */
+    transact(mutator: (records: DurableReconciliationRecord[]) => DurableReconciliationRecord[]): Promise<void>;
+    load(): Promise<DurableReconciliationRecord[]>;
+    /** Snapshot currently held in memory after last load/transact. */
+    snapshot(): DurableReconciliationRecord[];
+    delete(): Promise<void>;
+}
+export declare function createReconciliationStore(options: {
+    sessionFile: string | null | undefined;
+    sessionId: string;
+    fs?: ReconciliationStoreFs;
+    now?: () => number;
+}): ReconciliationStore;

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

@@ -37,11 +37,13 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * 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 = 29;
+export declare const DAEMON_GENERATION = 30;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers
- * all builds published before this field existed; bump this to force serving
- * convergence and reload of compatible live predecessors.
+ * 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 = 2;
+export declare const SERVING_EPOCH = 3;

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

@@ -107,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
@@ -752,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;
     };
@@ -786,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. */
@@ -815,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;
@@ -986,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

@@ -13,11 +13,12 @@ export interface ControlSurface {
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
     answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
     approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-    invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+    invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
     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/host/host.d.ts

@@ -7,6 +7,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     /** Best-effort diagnostic observation of accepted control/query frames. */
     onRequest?: SdkRequestObserver;
+    /** Runs before a control response is sent; identity transitions use sendTerminal. */
+    beforeControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame, sendTerminal: () => Promise<void>) => void | Promise<void>;
     /** Runs only after a successful control response has been sent to the client. */
     afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
     installProviderDefinitions?: (capability: string, definitions: unknown) => void;

package/dist/types/sdk/host/query/handlers.d.ts

@@ -37,6 +37,11 @@ export interface SessionSurface {
         turnId?: string;
         clientRef?: string;
     }): unknown | Promise<unknown>;
+    getSkillInvokeStatus?(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): unknown | Promise<unknown>;
     /** Q27 effective model-profile catalog from the live session registry. */
     getModelProfiles?(): unknown[] | Promise<unknown[]>;
     /** Query rows backed by the session's installed binding map. */

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>;

package/dist/types/sdk/startup-capability.d.ts

@@ -16,6 +16,12 @@ export type SdkStartupResult = {
 };
 /** Internal symbols for lifecycle-only SDK startup construction and bus wiring. */
 export declare const lifecycleStartupCapabilityOption: unique symbol;
+/**
+ * Internal option carrying the startup budget for ACP lifecycle MCP launches.
+ * Only set when the lifecycle request actually supplies `mcpServers`, so the
+ * longer ceiling never leaks to ordinary CLI/SDK `mcpConfigPath` consumers.
+ */
+export declare const lifecycleMcpStartupTimeoutOption: unique symbol;
 export declare function attachLifecycleStartupCapability(api: object, capability: SdkStartupCapability): void;
 export declare function lifecycleStartupCapabilityForApi(api: object): SdkStartupCapability | undefined;
 export interface SdkStartupRollbackResult {