@gajae-code/coding-agent 0.13.2 → 0.14.0

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

@@ -1,10 +1,12 @@
 /**
  * MCP (Model Context Protocol) type definitions.
  *
- * Based on MCP specification 2025-03-26:
- * https://modelcontextprotocol.io/specification/2025-03-26/
+ * Legacy sessionful surface based on MCP specification 2025-03-26; the modern
+ * stateless generation (2026-07-28, "MCP v2") is modeled in ./protocol.ts.
+ * https://modelcontextprotocol.io/specification/2026-07-28/
  */
 import type { SourceMeta } from "../capability/types";
+import type { MCPCacheHints, MCPProtocolObservation, MCPProtocolPreference } from "./protocol";
 export interface JsonRpcRequest {
     jsonrpc: "2.0";
     id: string | number;
@@ -47,15 +49,23 @@ export interface MCPServerConfigBase {
     enabled?: boolean;
     /**
      * Whether an explicit runtime MCP consumer should connect this server
-     * automatically when that consumer starts (default: true). Normal standalone
-     * `gjc`, `gjc --tmux`, and print-mode sessions do not consume `gjc mcp`
-     * registrations today.
+     * automatically when that consumer starts (default: true). Ordinary
+     * standalone `gjc`, `gjc --tmux`, and print-mode sessions honor autoload for
+     * conventional registrations; `autoload: false` keeps a server configured
+     * for on-demand `/mcp` connection. `--no-mcp` opts a session out entirely.
      */
     autoload?: boolean;
     /** Connection timeout in milliseconds (default: 30000) */
     timeout?: number;
     /** Pool identity mode. W2 defaults to one physical connection per session. */
     sharing?: "per-session" | "shared";
+    /**
+     * Protocol preference for remote (http/sse) servers: `auto` (default) negotiates
+     * the modern 2026-07-28 stateless protocol first with a bounded, observable
+     * legacy fallback; `2026-07-28` is strict modern-only; `legacy` forces the
+     * bounded compatibility handshake. Ignored by stdio servers (always legacy-era).
+     */
+    protocol?: MCPProtocolPreference;
     /** Authentication configuration (optional) */
     auth?: MCPAuthConfig;
     /** OAuth configuration for servers requiring explicit client credentials */
@@ -113,6 +123,10 @@ export interface MCPClientCapabilities {
         listChanged?: boolean;
     };
     sampling?: Record<string, never>;
+    /** Form-mode elicitation support (modern MRTR `elicitation/create` input requests). */
+    elicitation?: {
+        form?: Record<string, never>;
+    };
     experimental?: Record<string, unknown>;
 }
 /** MCP server capabilities */
@@ -155,7 +169,7 @@ export interface MCPToolDefinition {
     };
 }
 /** tools/list response */
-export interface MCPToolsListResult {
+export interface MCPToolsListResult extends MCPCacheHints {
     tools: MCPToolDefinition[];
     nextCursor?: string;
 }
@@ -195,12 +209,66 @@ export interface MCPToolCallResult {
 export declare class MCPExpectedFailure extends Error {
     constructor(cause?: unknown);
 }
+/** HTTP-level request failure carrying structured detail for era classification. */
+export declare class MCPHttpRequestError extends Error {
+    /** HTTP status code. */
+    readonly status: number;
+    /** Parsed JSON body when the error payload was JSON; undefined otherwise. */
+    readonly body: unknown;
+    constructor(status: number, message: string, body?: unknown);
+}
+/** JSON-RPC error response failure carrying the protocol error code. */
+export declare class MCPJsonRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
 export interface MCPRequestOptions {
     /** Abort signal (e.g. Escape-to-interrupt) */
     signal?: AbortSignal;
     /** Shared lease policy: never retry the original request after transport/auth failure. */
     noReplay?: boolean;
+    /**
+     * Handler for modern MRTR `input_required` results (elicitation, roots, sampling).
+     * When absent, an `input_required` result fails explicitly instead of hanging.
+     */
+    inputHandler?: MCPInputRequestHandler;
+    /** Extra mirrored headers for modern requests (`Mcp-Param-*` from x-mcp-header bindings). */
+    mcpParamHeaders?: Record<string, string>;
+}
+/** Context for one server input request gathered during a modern MRTR exchange. */
+export interface MCPInputRequestContext {
+    /** Server being called. */
+    serverName: string;
+    /** Original client request method (`tools/call`, `prompts/get`, `resources/read`). */
+    originMethod: string;
+    /**
+     * Stable correlation id shared by the initial request and its exactly-once
+     * retry, fencing the accepted input to this exchange.
+     */
+    correlationId: string;
+    /** Request-scoped abort signal (cancellation/timeout of the original call). */
+    signal?: AbortSignal;
 }
+/**
+ * Outcome of gathering one server input request. `result` values are placed in
+ * the retry's `inputResponses` under the request key. `failed` outcomes abort
+ * the MRTR exchange with an explicit error — except elicitation decline/cancel,
+ * which the handler expresses as an ElicitResult-shaped `result`.
+ */
+export type MCPInputRequestHandlerResult = {
+    kind: "result";
+    result: unknown;
+} | {
+    kind: "failed";
+    reason: "declined" | "cancelled" | "timeout" | "unavailable" | "error";
+    message?: string;
+};
+/** Handler for one server input request inside an `input_required` result. */
+export type MCPInputRequestHandler = (key: string, request: {
+    method: string;
+    params?: Record<string, unknown>;
+}, context: MCPInputRequestContext) => Promise<MCPInputRequestHandlerResult>;
 /** Transport interface - abstracts stdio/http */
 export interface MCPTransport {
     /** Send a request and wait for response */
@@ -246,6 +314,15 @@ export interface MCPServerConnection {
     instructions?: string;
     /** Cached prompts (populated on demand) */
     prompts?: MCPPrompt[];
+    /**
+     * Authoritative protocol observation for this connection (preference,
+     * negotiated era/version, downgrade decision, deprecation state). Secret-free.
+     */
+    protocol: MCPProtocolObservation;
+    /** Freshness deadline (ms epoch) for the cached tool catalog, from server ttlMs hints. */
+    toolsFreshUntil?: number;
+    /** Cache scope of the cached tool catalog; private entries never cross credential identities. */
+    toolsCacheScope?: "public" | "private";
 }
 /** MCP tool with server context */
 export interface MCPToolWithServer {
@@ -278,12 +355,12 @@ export interface MCPResourceTemplate {
     annotations?: MCPAnnotations;
 }
 /** Result of resources/list */
-export interface MCPResourcesListResult {
+export interface MCPResourcesListResult extends MCPCacheHints {
     resources: MCPResource[];
     nextCursor?: string;
 }
 /** Result of resources/templates/list */
-export interface MCPResourceTemplatesListResult {
+export interface MCPResourceTemplatesListResult extends MCPCacheHints {
     resourceTemplates: MCPResourceTemplate[];
     nextCursor?: string;
 }
@@ -295,7 +372,7 @@ export interface MCPResourceContentItem {
     blob?: string;
 }
 /** Result of resources/read */
-export interface MCPResourceReadResult {
+export interface MCPResourceReadResult extends MCPCacheHints {
     contents: MCPResourceContentItem[];
 }
 /** Params for resources/read */
@@ -320,7 +397,7 @@ export interface MCPPrompt {
     arguments?: MCPPromptArgument[];
 }
 /** Result of prompts/list */
-export interface MCPPromptsListResult {
+export interface MCPPromptsListResult extends MCPCacheHints {
     prompts: MCPPrompt[];
     nextCursor?: string;
 }
@@ -347,6 +424,21 @@ export interface MCPGetPromptResult {
     description?: string;
     messages: MCPPromptMessage[];
 }
+/** Result of the optional modern `server/discover` request. */
+export interface MCPDiscoverResult extends MCPCacheHints {
+    /** Protocol versions the server supports. */
+    supportedVersions: string[];
+    /** Capabilities the server supports. */
+    capabilities: MCPServerCapabilities;
+    /** Optional natural-language usage guidance. */
+    instructions?: string;
+    /** Result metadata; `io.modelcontextprotocol/serverInfo` carries the identity. */
+    _meta?: Record<string, unknown>;
+}
+/** Decoded `server/discover` payload with the extracted server identity. */
+export interface MCPDiscoverResultLite extends MCPDiscoverResult {
+    serverInfo?: MCPImplementation;
+}
 /** MCP server notification method names */
 export declare const MCPNotificationMethods: {
     readonly TOOLS_LIST_CHANGED: "notifications/tools/list_changed";

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

@@ -1,4 +1,6 @@
-import { SdkClient, SdkClientError, type SdkFrame } from "../client";
+import { type SdkClient, SdkClientError } from "../client";
+import type { AbortScope } from "../host/control/operations";
+import { type SessionAttachment, type SessionRouter } from "../router";
 import { ACP_SESSION_RECONNECT } from "../session-reconnect";
 import type { SessionLifecycleMcpServer } from "./mcp";
 type JsonObject = Record<string, unknown>;
@@ -14,9 +16,11 @@ export interface AcpProviderRegistration {
     definitions: unknown;
 }
 export interface AcpSdkAdapterOptions {
-    url: string;
-    token: string;
+    /** Broker lifecycle transport only. Live session work requires `router` plus an opaque attachment. */
     client?: SdkClient;
+    router?: SessionRouter;
+    attachment?: SessionAttachment;
+    sessionId?: string;
     connection?: AcpReverseConnection;
     providers?: AcpProviderRegistration[];
     /** Lease IDs persisted by the ACP host across a WebSocket reconnect. */
@@ -34,7 +38,7 @@ export declare class AcpSdkAdapterError extends Error {
  */
 export declare function acpMcpLaunchFailure(error: unknown, mcpServers: SessionLifecycleMcpServer[]): unknown;
 export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
-export type AcpFrameHandler = (frame: SdkFrame) => void;
+export type AcpFrameHandler = (frame: Record<string, unknown>) => void;
 export { ACP_SESSION_RECONNECT };
 /**
  * Pure ACP-to-SDK adapter. It deliberately owns neither an AgentSession nor an
@@ -44,6 +48,10 @@ export declare class AcpSdkAdapter {
     #private;
     constructor(options: AcpSdkAdapterOptions);
     static connect(options: AcpSdkAdapterOptions): Promise<AcpSdkAdapter>;
+    acceptAttachment(attachment: SessionAttachment): void;
+    revokeAttachment(attachment: SessionAttachment): void;
+    attachmentReady(attachment: SessionAttachment): Promise<void>;
+    acceptFrame(frame: Record<string, unknown>): void;
     get leaseIds(): ReadonlyMap<string, string>;
     get connectionId(): string | undefined;
     onReconnectFailed(handler: AcpReconnectFailedHandler): () => void;
@@ -51,11 +59,24 @@ export declare class AcpSdkAdapter {
     start(): Promise<void>;
     close(): Promise<void>;
     prompt(params: JsonObject | string): Promise<unknown>;
-    cancel(): Promise<unknown>;
+    /**
+     * Ends the active turn with a C04 terminal abort. The default `scope:"turn"`
+     * only stops the current turn, matching the SDK `turn.abort` default and
+     * other ACP clients' cancel behavior; `scope:"owned"` additionally stops
+     * exact causal owned work (background Bash/task jobs, detached subagents) so
+     * an external client can terminate everything a turn spawned. Paseo keeps
+     * owned cancels through its provider config env
+     * (`GJC_ACP_ABORT_SCOPE=owned`) without source changes. A fresh bounded
+     * idempotency key per call keeps terminal-abort replay deterministic across
+     * retries.
+     */
+    cancel(scope?: AbortScope): Promise<unknown>;
     setModel(params: JsonObject | string): Promise<unknown>;
     control(operation: string, input?: JsonObject): Promise<unknown>;
     query(query: string, input?: JsonObject, cursor?: string): Promise<unknown>;
     global(operation: string, input?: JsonObject, idempotencyKey?: string): Promise<unknown>;
+    /** Uses lifecycle endpoint credentials only inside the ACP session owner. */
+    lifecycle(operation: string, input?: JsonObject, idempotencyKey?: string): Promise<unknown>;
     sdkControl(params: {
         operation: string;
         input?: JsonObject;

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

@@ -1,12 +1,8 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
 import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
-import { type ElevationOperation } from "../elevation/digest";
-import { type ElevationAnswerAuthority, type ElevationDispatchOutcome } from "../elevation/dispatch-receipt";
-import { ElevationLedger, type ElevationRequester } from "../elevation/grant-ledger";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type BrokerPublicationObservation, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
-import { OperationReceiptLedger } from "./operation-receipt-ledger";
 import { SessionIndex } from "./session-index";
 export interface BrokerSettings {
     agentDir: string;
@@ -23,7 +19,7 @@ type ResolvedBrokerSettings = {
     heartbeatTtlMs: number;
     resolveDirectoryMigration: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 };
-export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | "ambiguous_session" | (string & {});
+export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
 export type BrokerCleanupIdentity = {
     dev: string;
     ino: string;
@@ -200,8 +196,6 @@ export declare class Broker {
     readonly settings: ResolvedBrokerSettings;
     readonly index: SessionIndex;
     readonly ledger: LifecycleLedger;
-    readonly elevation: ElevationLedger;
-    readonly operationReceipts: OperationReceiptLedger;
     discovery: BrokerDiscovery | null;
     constructor(settings: BrokerSettings);
     runStartup<T>(queueWaitMs: number, timing: StartupAdmissionTiming, task: (admittedAt: number) => Promise<T>): Promise<StartupAdmissionResult<T>>;
@@ -210,14 +204,7 @@ export declare class Broker {
     get completion(): Promise<void>;
     status(): RedactedBrokerDiscovery | null;
     heartbeat(): Promise<void>;
-    /**
-     * Production coalesced heartbeat checkpoint seam (C2): delegates to the session
-     * index writer, which appends at most one `host_heartbeat` per session per
-     * {@link SESSION_HEARTBEAT_INTERVAL_MS} for hosts that are alive and, when recorded,
-     * still carry the same OS process incarnation. Returns the number of checkpoints
-     * written. Used by the periodic publication watch, by session reads so a fresh
-     * registration is observed as live, and by tests.
-     */
+    /** Re-observes provably live session hosts and checkpoints their liveness. */
     heartbeatSessions(now?: number): Promise<number>;
     /**
      * Revalidate retained publication ownership and begin one synchronous effect in
@@ -238,46 +225,7 @@ export declare class Broker {
      * spawns a child the broker has no authority over.
      */
     stop(): Promise<void>;
-    handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string, elevationRequestId?: string): Promise<BrokerResponse>;
-    /**
-     * Elevation issuance (internal). Binds the exact endpoint identity
-     * (endpointStateRoot/generation/incarnation) from the live index record;
-     * the request digest is broker-computed from the full `{kind,sdkId,input}`
-     * triple with the top-level `elevationRequestId` excluded.
-     */
-    elevationIssue(params: {
-        sessionId: string;
-        operation: ElevationOperation;
-        input: Record<string, unknown>;
-        requester: ElevationRequester;
-        elevationRequestId?: string;
-        expiresInMs?: number;
-    }): Promise<BrokerResponse>;
-    /**
-     * Elevation answer (internal, operator-only). There is no public
-     * `elevation.answer` operation: this entry point is reserved for the local
-     * operator approval surface and the separately authorized gate-answer
-     * source, and the ledger enforces the distinct-answer-source boundary.
-     */
-    elevationAnswer(params: {
-        elevationRequestId: string;
-        answer: "approve" | "deny";
-        presentedDigest: string;
-        answerer: ElevationAnswerAuthority;
-    }): Promise<BrokerResponse>;
-    /** Single-use grant claim (internal): consumes the grant before dispatch. */
-    elevationClaim(params: {
-        elevationRequestId: string;
-    }): Promise<BrokerResponse>;
-    /** Records the dispatch outcome for a claimed grant (internal). */
-    elevationDispatch(params: {
-        elevationRequestId: string;
-        outcome: ElevationDispatchOutcome;
-    }): Promise<BrokerResponse>;
-    /** Truthful elevation status read (internal; reconciles expiry and crash state). */
-    elevationResolve(elevationRequestId: string): Promise<BrokerResponse>;
-    /** Truthful elevation listing (internal). */
-    elevationList(): Promise<BrokerResponse>;
+    handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<BrokerResponse>;
 }
 /** Test-only hook for simulating a process crash after terminal persistence verification. */
 export declare function setTerminalPersistenceHookForTest(broker: Broker, hook: (() => void) | undefined): void;

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

@@ -94,6 +94,7 @@ export declare function sdkSessionCommandOverrideForTest(): {
     file: string;
     args: string[];
 } | undefined;
+type BrokerIndex = Pick<Broker, "index">;
 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>;
@@ -165,14 +166,21 @@ export declare function sessionHostWorkInFlight(): boolean;
  * How often a live broker re-checks its own session registrations against OS
  * process liveness.
  *
- * This sweep can never disturb healthy work: a registration is only dropped
- * when `process.kill(pid, 0)` proves the exact published pid is gone, and a
- * working host answers that probe for its entire life no matter how long a turn
- * runs. One minute keeps `gjc_sessions`/`session.get_endpoint` from advertising
- * a corpse for longer than a single poll while costing one index refresh per
- * minute on an otherwise idle broker.
+ * This sweep can never disturb healthy work: a registration is dropped only when
+ * `observeProcess` proves its exact published process identity exited. A live
+ * replacement at the same pid retires the stale registration without being
+ * signaled. One minute keeps `gjc_sessions`/`session.get_endpoint` from
+ * advertising a corpse for longer than a single poll while costing one index
+ * refresh per minute on an otherwise idle broker.
  */
 export declare const BROKER_DEAD_REGISTRATION_SWEEP_MS = 60000;
+/**
+ * Registrations reaped per sweep. Every reap is its own locked index transaction,
+ * so an uncapped sweep over a long-lived index turns one broker into a continuous
+ * holder of the shared session-index lock and starves unrelated `gjc` launches out
+ * of their bounded retry budget. Surplus dead rows are reaped by later sweeps.
+ */
+export declare const BROKER_DEAD_REGISTRATION_SWEEP_LIMIT = 64;
 /** One reaped registration, as recorded by {@link reapDeadSessionRegistrations}. */
 export interface ReapedSessionRegistration {
     sessionId: string;
@@ -188,13 +196,11 @@ export interface ReapedSessionRegistration {
  * missing heartbeat merely makes a session read as not-live — the host may
  * still be running ahead of the next heartbeat checkpoint pass, so it is never
  * grounds for a reap. EPERM and unreadable incarnations stay "uncertain", so an
- * alien or unreadable process is never mistaken for a dead one. Registrations
- * already terminal or marked `terminalUncertain` are left alone: their
- * disposition belongs to the terminal-uncertainty reconciliation path, and
- * silently dropping them would turn a fail-closed `session.close`/
- * `session.delete` refusal into `not_found`.
+ * alien or unreadable process is never mistaken for a dead one. Terminal and
+ * terminal-uncertain identities are retained. Identity-level rows let the sweep
+ * retire a dead losing root without disturbing the surviving authority.
  */
-export declare function reapDeadSessionRegistrations(broker: Pick<Broker, "index">): Promise<ReapedSessionRegistration[]>;
+export declare function reapDeadSessionRegistrations(broker: BrokerIndex, limit?: number): Promise<ReapedSessionRegistration[]>;
 /**
  * Runs {@link reapDeadSessionRegistrations} on {@link BROKER_DEAD_REGISTRATION_SWEEP_MS}.
  * The timer is unref'd, so it never keeps an otherwise idle broker process alive.

package/dist/types/sdk/broker/session-index.d.ts

@@ -68,11 +68,13 @@ export interface IndexedSession {
     activity?: SessionActivity;
     /** Wall-clock timestamp of the latest admitted heartbeat, when one exists. */
     lastHeartbeatAt?: number;
-    /** True when the same sessionId maps to more than one stateRoot (cross-repo duplicate). */
+    /** True when more than one unresolved authority-fencing state-root identity claims this session id. */
     ambiguous: boolean;
-    /** True when the identity's latest event is host_unregistered or session_closed (DR-1: stopped rows are retained). */
+    /** True when the identity's latest event is terminal (DR-1 retains stopped rows for inspection/offline tail). */
     terminal: boolean;
 }
+/** A session can grant endpoint or lifecycle authority only when one authority-fencing state root claims its id. */
+export declare function isSessionAuthorityEligible(session: Pick<IndexedSession, "ambiguous">): boolean;
 export interface SessionList {
     indexSeq: number;
     sessions: IndexedSession[];
@@ -119,6 +121,7 @@ export declare class SessionIndex {
     refresh(): Promise<void>;
     get indexSeq(): number;
     append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;
+    unregisterIfCurrent(expected: IndexedSession): Promise<boolean>;
     /** Hold the canonical index lock across an authority-sensitive operation. */
     withLocked<T>(callback: () => Promise<T>): Promise<T>;
     snapshot(): Promise<void>;
@@ -128,19 +131,25 @@ export declare class SessionIndex {
      */
     compact(): Promise<void>;
     listSessions(): SessionList;
+    /**
+     * Broker-internal current composite-identity rows. Unlike {@link listSessions},
+     * this retains losing roots so an exact dead registration can be retired without
+     * disturbing the surviving authority.
+     */
+    listSessionIdentities(probedIncarnations?: ReadonlyMap<string, string | undefined>): IndexedSession[];
     /**
      * Production coalesced heartbeat checkpoint pass (C2): appends one
      * `host_heartbeat` per session at most once per {@link SESSION_HEARTBEAT_INTERVAL_MS}.
      * The pass observes liveness the same way the projection does — the host process
      * must be alive and, for composite identities, still carry the recorded OS process
-     * incarnation (a reused PID is never checkpointed). Stopped/terminal rows and rows
-     * whose heartbeat is still fresh are skipped. After a broker restart, sessions whose
+     * incarnation (a reused PID is never checkpointed). Stopped, terminal, and ambiguous rows
+     * and rows whose heartbeat is still fresh are skipped. After a broker restart, sessions whose
      * host survived are re-observed as live on the first pass; sessions whose host died
      * while the broker was down keep their stale or missing heartbeat and read as
      * unknown/not-live (never fresh forever). Returns the number of checkpoints written.
      */
     checkpointLiveHeartbeats(now?: number): Promise<number>;
-    hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId">): {
+    hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "locator" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId" | "hostIncarnation" | "processIncarnation">): {
         indexSeq: number;
         lifecycleRequestId?: string;
     } | undefined;

package/dist/types/sdk/broker/startup-failure.d.ts

@@ -4,13 +4,28 @@ export interface BrokerStartupFailureMarker {
     exitCode: number | null;
     signal: string | null;
     writtenAt: number;
+    /**
+     * pid of the exact broker process that wrote this marker. `ensureBroker`
+     * only trusts a marker whose pid matches the exact spawned child it just
+     * reaped -- a marker left behind by a stale or foreign broker process (for
+     * example a losing racer from a concurrent spawn, or a marker predating the
+     * pre-spawn clear) must never be misattributed to a different spawn's
+     * failure.
+     */
+    pid: number;
 }
 export declare function brokerStartupFailurePath(agentDir: string): string;
-/** Best-effort durable marker write; never throws (diagnostics must not mask the exit itself). */
+/**
+ * Best-effort durable marker write; never throws (diagnostics must not mask the
+ * exit itself). `pid` must be the writing broker process's own pid
+ * (`process.pid`) so a later reader can bind the marker to the exact spawned
+ * child it is attributing the failure to.
+ */
 export declare function writeBrokerStartupFailureMarker(agentDir: string, failure: {
     reason: string;
     exitCode: number | null;
     signal: string | null;
+    pid: number;
 }): Promise<void>;
 /** Reads a bounded startup-failure marker; `undefined` when absent or malformed. */
 export declare function readBrokerStartupFailureMarker(agentDir: string): Promise<BrokerStartupFailureMarker | undefined>;

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

@@ -45,7 +45,57 @@ export type ChatDaemonAction = "stop" | "reload";
  * generation 29 / slack generation 28 advance the replay cursor only after a frame is
  * published, so an owner at an earlier generation acknowledges an event before delivering
  * it and loses that event for good the first time a surface refuses it. Discord generation 30 /
- * slack generation 29 invalidate existing owners after SDK discovery validation changes.
+ * slack generation 29 move lifecycle and attachment authority into SDK core; generation 30 also
+ * isolates per-session Router attachment failures so one stale endpoint cannot block healthy sessions.
+ * Discord generation 31 bounds one REST operation across response parsing and multi-request flows.
+ * Slack generation 30 bounds shutdown, tracks outbound work, and fences late effect commits.
+ * Slack generation 31 fences late post admission and tracks close-marker shutdown work.
+ * Slack generation 32 bounds provider teardown and preserves close markers after Router revocation.
+ * Slack generation 33 bounds lifecycle predecessors under the shutdown deadline.
+ * Slack generation 34 CAS-fences cleanup mapping commits against successors.
+ * Slack generation 35 identity-fences detached startup cleanup from restarted daemon state.
+ * Slack generation 36 retains stop ownership for every detached lifecycle generation.
+ * Discord generation 32 / Slack generation 37 bind cleanup to the removed attachment generation.
+ * Discord generation 33 / Slack generation 38 identity-fence cleanup callbacks on exact attachments.
+ * Discord generation 34 / Slack generation 39 clear stale attachment identity before provider reassignment.
+ * Discord generation 35 / Slack generation 40 capture provider ownership before cleanup awaits.
+ * Discord generation 36 / Slack generation 41 drain prior cleanup before provider restart.
+ * Discord generation 37 / Slack generation 42 serialize successor attachment visibility after cleanup.
+ * Discord generation 38 / Slack generation 43 hold successor frames behind cleanup settlement.
+ * Discord generation 39 / Slack generation 44 recover durable cleanup before attachment publication.
+ * Slack generation 45 persists exact pending cleanup intent through recovery.
+ * Discord generation 40 bounds provider lifecycle joins before Router revocation.
+ * Discord generation 41 / Slack generation 46 revoke Router authority despite provider shutdown failure.
+ * Discord generation 42 / Slack generation 47 retain daemon objects across restart to preserve detached lifecycle fences.
+ * Discord generation 43 / Slack generation 48 fence Router attachment publication and Broker-adopted endpoint authority.
+ * Discord generation 44 / Slack generation 49 retain provider shutdown tails and rejected lifecycle errors so no successor transport starts before ownership settles.
+ * Discord generation 45 / Slack generation 50 clean predecessor presentation authority before exact Router replacement and reject post-stop Discord callbacks.
+ * Discord generation 46 / Slack generation 51 establish replay barriers before reconnect awaits, distinguish replacement from terminal cleanup, and await lifecycle-fenced Discord inbound work.
+ * Discord generation 47 / Slack generation 52 preserve presentation continuity across replacement while exact opaque authority fences stale work.
+ * Discord generation 48 / Slack generation 53 allow exact publication-time requests without reconciliation deadlock.
+ * Discord generation 49 / Slack generation 54 revalidate endpoint authority before exact publication-time requests.
+ * Discord generation 50 / Slack generation 55 terminalize predecessor routes only for a changed same-generation endpoint incarnation.
+ * Slack generation 56 clears predecessor inbound receipts before same-generation successor publication.
+ * Discord generation 51 / Slack generation 57 persist restart-stable Router endpoint-incarnation authority in provider mappings.
+ * Discord generation 52 / Slack generation 58 classify reconnect-time endpoint changes before provider retirement.
+ * Discord generation 53 / Slack generation 59 serialize successor attach behind predecessor provider retirement.
+ * Discord generation 54 / Slack generation 60 version-fence attaches already in flight when retirement begins.
+ * Discord generation 55 / Slack generation 61 fence durable inbound work by exact attachment identity.
+ * Discord generation 56 / Slack generation 62 fence durable provider-post and thread-effect recovery by attachment identity.
+ * Discord generation 57 removes missing-authority wildcard behavior from durable binding checks.
+ * Discord generation 58 preserves exact authority through unarchive replacement fallback.
+ * Discord generation 59 / Slack generation 63 derive attachment authority ids from one Router function so persisted provider bindings and live attachments cannot drift apart.
+ * Discord generation 62 / Slack generation 65 fence the Windows process-incarnation
+ * authority change (#4362): the native binding fallback no longer spawns powershell.exe.
+ * Discord generation 63 / Slack generation 66 retain the shared ownership fence
+ * unless a zero-signal process probe returns ESRCH. EPERM and unknown failures are
+ * indeterminate, so earlier owners must not reclaim, replace, or spawn through them.
+ * Discord generation 64 / Slack generation 67 contain synchronous provider-
+ * subscription admission and ready-hook failures without revoking shared Router
+ * attachment authority.
+ * Discord generation 65 / Slack generation 68 fence the off-reconcile-tail
+ * initial attachment replay introduced by #4542 so pre-upgrade daemon owners
+ * cannot retain the earlier SessionRouter attachment contract.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -1,5 +1,4 @@
-import { SessionIndex } from "../broker/session-index";
-import { type SdkSessionEndpoint } from "../client/discovery";
+import type { SessionRouterDeps } from "../router";
 import type { ChatDaemonCommandBindInput, ChatDaemonCommandOutcome } from "./chat-daemon-command-channel";
 import type { ChatDaemonKind } from "./chat-daemon-control";
 import type { DiscordProvider } from "./discord-provider";
@@ -26,22 +25,6 @@ export interface ChatDaemonRuntimeConfig {
         verbosity: "lean" | "verbose";
     };
 }
-export interface ChatDaemonSdkClient {
-    onFrame(handler: (frame: Record<string, unknown>) => void): () => void;
-    /**
-     * Announces that a replacement socket is live. Optional because command-scoped
-     * clients (the broker client, one-shot doubles) never outlive one socket, while
-     * every long-lived attachment's client carries it.
-     */
-    onReconnect?(handler: () => void): () => void;
-    /** Re-dials a retired socket; a no-op on a live one. */
-    connect?(): Promise<void>;
-    request(frame: Record<string, unknown>, options?: {
-        timeoutMs?: number;
-    }): Promise<Record<string, unknown>>;
-    close(): Promise<void>;
-    send(frame: Record<string, unknown>): void;
-}
 export type ChatDeliveryPhase = "pre_send" | "ambiguous";
 /** An authorized SDK command could not be conclusively delivered. */
 export declare class ChatDeliveryError extends Error {
@@ -51,19 +34,11 @@ export declare class ChatDeliveryError extends Error {
 export interface ChatDaemonRuntimeDeps {
     createDiscordProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["discord"]>) => DiscordProvider;
     createSlackProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["slack"]>) => SlackProviderClient;
-    createClient?: (endpoint: SdkSessionEndpoint) => Promise<ChatDaemonSdkClient>;
-    createIndex?: (agentDir: string) => SessionIndex;
-    createBrokerClient?: (endpoint: {
-        url: string;
-        token: string;
-    }) => Promise<ChatDaemonSdkClient>;
-    onReconciled?: () => void;
-    setInterval?: typeof setInterval;
-    clearInterval?: typeof clearInterval;
+    routerDeps?: SessionRouterDeps;
 }
 /**
  * Worker-owned session discovery and event fanout. It connects only through the
- * public SDK transport and retains endpoint tokens solely in live client objects.
+ * public SDK transport and retains SDK credentials solely in live client objects.
  */
 export declare class ChatDaemonRuntime {
     #private;
@@ -77,18 +52,6 @@ export declare class ChatDaemonRuntime {
     start(): Promise<void>;
     transportHealthy(): boolean;
     stop(): Promise<void>;
-    private reconcile;
-    private attach;
-    private resolveEndpoint;
-    /**
-     * Adopt an operator-supplied Slack root for one attached session. Returns a
-     * machine-readable rejection instead of throwing so the daemon control plane
-     * can answer without exposing internal failure detail.
-     */
+    /** Adopt an operator-supplied Slack root through the provider's presentation store. */
     bindExistingRoot(request: ChatDaemonCommandBindInput): Promise<ChatDaemonCommandOutcome>;
-    private schedule;
-    private enqueueFrame;
-    private handleFrame;
-    private close;
-    private resume;
 }

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

@@ -10,6 +10,17 @@ import { type LoadResult } from "../../config/config-file";
  * site marks it, never by inheriting a marked ancestor's environment.
  */
 export declare const SPAWN_PROVENANCE_ENV = "GJC_SPAWNED_BY_SESSION";
+/**
+ * Telegram session eligibility: whether a session may own a forum topic and be
+ * admitted by the notification daemon.
+ *
+ * This follows the user's configuration, never how the session was launched.
+ * Gating it on coordinator/lifecycle provenance made every ordinary
+ * interactive session declare itself ineligible, and the daemon refuses an
+ * identity header that does so — so no notification was ever delivered even
+ * though the daemon looked healthy and attached.
+ */
+export declare function isTelegramSessionEligible(cfg: NotificationConfig): boolean;
 export type TelegramActivationState = "inactive" | "blocked";
 export type TelegramActivationReason = "saved_inactive" | "identity_mismatch";
 /** Non-secret, identity-specific durable Telegram activation state. */