@gajae-code/coding-agent 0.11.6 → 0.11.8

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

@@ -70,6 +70,7 @@ 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;
 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>;
@@ -79,6 +80,11 @@ export interface LifecycleTranscriptEvidence {
 }
 /** The child writes bounded startup diagnostics before exiting without readiness. */
 export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string): Promise<void>;
+export declare function readSessionLifecycleFailureForTest(root: string, id: string, expected: {
+    pid: number;
+    effectMarker: string;
+    incarnation: string;
+}): Promise<SdkStartupFailure | undefined>;
 export interface LifecycleExecutionOutcome {
     response: BrokerResponse;
     durableEffects?: LifecycleDurableEffectsReceipt;

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

@@ -8,7 +8,12 @@ export type ChatDaemonAction = "stop" | "reload";
  * Generation 6 carries the retained managed filesystem authority boundary.
  * Generation 7 restores macOS daemon signaling (kill(2) with a start-time
  * incarnation recheck) so a live/hung owner can be replaced without an external
- * `kill -9`.
+ * `kill -9`. Generation 8 adopts Windows expected-identity ACL verification and
+ * repair for shared native authority. Generation 9 refreshes the shared native
+ * authority declaration contract with bounded frame-delivery acknowledgement.
+ * Generation 11 accepts typed retained exact-unlink cleanup authority — a
+ * concrete detached quarantine plus a proven-absent canonical lock pathname —
+ * when deleting an observed owner-lock lease.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -5,8 +5,8 @@
  * removed), but the user can still adjust per-surface behaviour from inside a
  * session thread with small slash commands:
  *
- * - `/verbose`            switch the mirror to bounded tool-owned summaries + provider-displayable reasoning summaries
- * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbose`            switch the mirror to per-turn assistant text + tool summaries + reasoning summaries
+ * - `/lean`               settled assistant answer at idle + immediate ask lead-ins (no intermediate tool-turn flood)
  * - `/verbosity lean|verbose`
  * - `/redact on|off`      toggle redaction of streamed content
  *

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

@@ -287,6 +287,8 @@ export interface RedactableAction {
     question?: string;
     options?: string[];
     summary?: string;
+    /** Optional zero-based recommendation into the authoritative raw options. */
+    recommendedIndex?: number;
 }
 /**
  * When redact is true, strip sensitive content for remote delivery:

package/dist/types/sdk/bus/conversation-store.d.ts

@@ -56,6 +56,7 @@ export declare class ConversationStore<T extends ConversationRecord> {
         pidAlive?: (pid: number) => boolean;
         sleep?: (ms: number) => Promise<void>;
         lockTimeoutMs?: number;
+        platform?: NodeJS.Platform;
     });
     get filePath(): string;
     load(): Promise<ConversationStoreDocument<T>>;

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

@@ -204,6 +204,7 @@ interface UnattendedGatePresentation {
     question: string;
     options: string[];
     controls: readonly AskRemoteControl[];
+    recommendedIndex?: number;
     multi: boolean;
     allowEmpty: boolean;
     navigationLabel?: "Next" | "Done";
@@ -343,6 +344,21 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     } | undefined) => boolean;
+    /** Transitions the authoritative reconciliation record at lifecycle ingress; terminal outcomes settle once. */
+    notePromptReconciliation: (correlation: {
+        commandId: string;
+        turnId: string;
+    } | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }) => void;
+    /** Settles and emits one sanitized correlated prompt failure. */
+    emitPromptFailure: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, error: unknown) => void;
     /** Records correlated lifecycle frames for replay and delivers them only to the accepted requester after acknowledgement. */
     emitPromptLifecycle: (correlation: {
         commandId: string;
@@ -385,6 +401,15 @@ interface SessionRuntime {
         text?: string;
         messageRef?: string;
     };
+    /**
+     * Lean-mode deferred final answer: latest assistant text observed at `turn_end`,
+     * emitted once at `agent_end` so intermediate tool-turn narration does not flood
+     * remote clients. Cleared after flush or when replaced by a newer turn.
+     */
+    pendingSettled?: {
+        text: string;
+        messageRef?: string;
+    };
     /** Durable gates emitted while ownership is provisional; presented only after stable activation. */
     deferredGatePresentations: Array<() => void>;
     /** SDK control frames received during provisional ownership; replayed only after stable activation. */
@@ -494,7 +519,7 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     /** Whether this host mode can own the root SDK endpoint. Default: true. */
     sdkHostModeSupported?: boolean;
     onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
-    runEphemeralTurn?: (promptText: string, signal: AbortSignal) => Promise<{
+    runBtwTurn?: (question: string, signal: AbortSignal) => Promise<{
         replyText: string;
     }>;
     /** Observes settlement of optional session-branch startup after reconciliation completes. */

package/dist/types/sdk/bus/lifecycle-commands.d.ts

@@ -62,8 +62,9 @@ export declare function normalizeLifecyclePath(value: string): string | undefine
 /**
  * Map a lifecycle response/error to a user-facing Telegram message (G010).
  *
- * Only derives text from sessionId, mode, reason, a safe message, and candidate
- * {sessionId,path} — never a token or prompt. Each error reason gets tailored,
- * actionable copy; an "in progress" pending response is surfaced distinctly.
+ * Only derives text from sessionId, mode, reason, a safe message, the originating
+ * lifecycle verb, and candidate {sessionId,path} — never a token or prompt. Each
+ * error reason gets tailored, actionable copy; an "in progress" pending response
+ * is surfaced distinctly.
  */
-export declare function formatLifecycleOutcome(r: SessionLifecycleResponse): string;
+export declare function formatLifecycleOutcome(r: SessionLifecycleResponse, verb?: LifecycleCommandVerb): string;

package/dist/types/sdk/bus/notification-orchestration.d.ts

@@ -30,6 +30,7 @@ export interface ProposedTelegramIdentityPreflightInput {
     deps?: {
         fs?: TelegramDaemonFs;
         pidAlive?: (pid: number) => boolean;
+        pidIncarnation?: (pid: number) => string | undefined;
     };
 }
 /**

package/dist/types/sdk/bus/notification-service.d.ts

@@ -74,6 +74,40 @@ export interface NotificationStatusReport {
 export declare function buildNotificationStatusReport(settings: Settings): NotificationStatusReport;
 /** Render a status report as human-readable lines (no secrets). */
 export declare function formatNotificationStatusReport(report: NotificationStatusReport): string;
+export interface NotificationEndpointView {
+    sessionId: string;
+    pid: number | undefined;
+    stale: boolean;
+}
+export type NotificationEndpointLiveness = "live" | "dead" | "unknown";
+/**
+ * Classification used by recovery and startup takeover. A file is an endpoint
+ * only when it has endpoint authority fields; lifecycle/audit records are never
+ * candidates for endpoint cleanup.
+ */
+export type NotificationEndpointClassification = {
+    kind: "endpoint";
+    view: NotificationEndpointView;
+    liveness: NotificationEndpointLiveness;
+    identity: NotificationEndpointFileIdentity;
+} | {
+    kind: "non-endpoint";
+} | {
+    kind: "unreadable";
+};
+/**
+ * Classify an endpoint using owner-proof semantics. An endpoint is only `dead`
+ * with positive proof: an explicit `stale` tombstone, or a recorded pid that is
+ * confirmed not alive. A PID-less endpoint is `unknown` (not provably dead) and
+ * must never be treated as dead — removing it could delete a live session's
+ * discovery file that simply omitted a pid.
+ */
+export declare function notificationEndpointLiveness(view: NotificationEndpointView, pidAlive: (pid: number) => boolean): NotificationEndpointLiveness;
+/**
+ * Read and classify one endpoint candidate. The returned identity belongs to
+ * exactly the bytes inspected and is required for any later deletion.
+ */
+export declare function classifyNotificationEndpoint(fs: Pick<NotificationServiceFs, "readEndpointFile">, file: string, pidAlive: (pid: number) => boolean): Promise<NotificationEndpointClassification>;
 export type HealthLevel = "ok" | "warn" | "error";
 export interface HealthCheck {
     name: string;

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

@@ -0,0 +1,105 @@
+/**
+ * Bounded authoritative reconciliation state for Q26 `turn.prompt_status`.
+ *
+ * Separate from the lifecycle delivery buffers (promptSubmissions /
+ * promptTerminalTombstones), which exist to deliver frames and intentionally
+ * forget outcomes. This record preserves accepted/in_flight/terminal_ok/failed
+ * plus bounded sanitized failure metadata so a caller can reconcile a prior
+ * `turn.prompt` after disconnect/reconnect.
+ *
+ * Semantics (public contract, mirrored in sdk/prompt-status.ts):
+ * - Active records are NEVER converted to terminal by age or capacity.
+ * - 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`.
+ * - 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.
+ */
+export declare const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
+export declare const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
+export declare const PROMPT_RECONCILIATION_TERMINAL_TTL_MS: number;
+export declare const PROMPT_FAILURE_CODE_MAX = 64;
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+export interface PromptCorrelation {
+    commandId: string;
+    turnId: string;
+}
+export interface PromptReconciliationRecord extends PromptCorrelation {
+    clientRef?: string;
+    status: PromptReconciliationStatus;
+    error?: {
+        code: string;
+        message: string;
+    };
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+}
+export type TurnPromptReconciliation = {
+    status: "accepted";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+} | {
+    status: "in_flight";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt: number;
+} | {
+    status: "terminal_ok";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt: number;
+} | {
+    status: "failed";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt: number;
+    error: {
+        code: string;
+        message: string;
+    };
+} | {
+    status: "unknown";
+};
+export interface PromptReconciliation {
+    /** Fail-closed admission BEFORE any execution; holds an identity-bound reservation. */
+    admit(clientRef?: string): void;
+    /** Discard one admission reservation without creating a record (rejection/cancellation). */
+    releaseAdmission(clientRef?: string): void;
+    /** Transition a reservation into the accepted record at preflight acceptance. */
+    noteAccepted(correlation: PromptCorrelation, clientRef?: string): void;
+    /** Lifecycle transition; terminal outcomes settle exactly once. */
+    noteTransition(correlation: PromptCorrelation | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }): void;
+    lookup(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): TurnPromptReconciliation;
+    cleanup(): void;
+    activeCount(): number;
+}
+/** Safe-token code capped at 64; arbitrary failure text is never retained. */
+export declare function sanitizePromptFailure(error: unknown): {
+    code: string;
+    message: string;
+};
+export declare function createPromptReconciliation(options?: {
+    now?: () => number;
+}): PromptReconciliation;

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

@@ -19,7 +19,22 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * confirmed-dead owner's lock in generation 10, legacy stopped-tombstone
  * reclamation in generation 11, force-escalated SIGKILL of an unresponsive
  * older-generation owner during automatic generation-upgrade reload in
- * generation 12, and restored macOS daemon signaling (kill(2) with a start-time
- * incarnation recheck, replacing the darwin no-op) in generation 13.
+ * generation 12, restored macOS daemon signaling (kill(2) with a start-time
+ * incarnation recheck, replacing the darwin no-op) in generation 13, retained
+ * legacy stopped-lock reclamation in generation 14, Windows expected-identity
+ * ACL verification and repair in generation 15, identity-fenced stale endpoint
+ * startup recovery in generation 16, Telegram topic recovery authority fencing
+ * in generation 17, fail-closed blank-token validation plus lifecycle-startup
+ * stop fencing in generation 18, recommended ask metadata rendering in
+ * generation 19, authoritative terminal session-close delivery and cleanup
+ * fencing, attested generation-bearing pre-incarnation owner handoff in
+ * generation 20, guarded modern generation-absent predecessor signaling in
+ * generation 21, dead Windows v0.10 owner replacement in generation 22, and
+ * retained native cleanup authority revalidation in generation 23, and typed
+ * retained exact-unlink cleanup authority acceptance (concrete detached
+ * quarantine plus proven canonical absence) in generation 24.
+ * Generation 25 adds startup dead-root prune + leak-artifact self-heal
+ * on TelegramNotificationDaemon.run (#2958). Generation 26 adds bounded reload
+ * cooldown and lazy Telegram topic lifecycle safeguards (#2956, #2960, #2984).
  */
-export declare const DAEMON_GENERATION = 13;
+export declare const DAEMON_GENERATION = 26;

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

@@ -24,8 +24,11 @@ export declare function writeTelegramControlRequest(settings: Settings, request:
 export declare function clearTelegramControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;
 export interface DaemonProcessReference {
     incarnation: string;
+    /** Whether the platform delivers the requested signal cooperatively or as a hard termination. */
+    termination: "cooperative" | "hard";
     signalRoot(signal: NodeJS.Signals): void;
 }
+export declare function defaultProcessReference(pid: number, platform?: NodeJS.Platform): DaemonProcessReference | undefined;
 export interface TelegramDaemonControlDeps {
     fs?: TelegramDaemonFs;
     now?: () => number;
@@ -58,6 +61,7 @@ export type TelegramGenerationReloadResult = {
     operation: DaemonOperationResult;
 };
 export declare class TelegramDaemonController implements BuiltInDaemonController {
+    #private;
     private readonly settings;
     private readonly deps;
     readonly kind: "telegram";
@@ -81,7 +85,7 @@ export declare class TelegramDaemonController implements BuiltInDaemonController
     private signalCapturedOwner;
     private result;
     reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
-    reloadForGenerationUpgrade(opts?: DaemonOperationOptions): Promise<TelegramGenerationReloadResult>;
+    reloadForGenerationUpgrade(opts?: DaemonOperationOptions, attestedLegacyUpgrade?: boolean): Promise<TelegramGenerationReloadResult>;
     stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
     private stopOrReload;
     /** Clear only our exact control request; a successor request must survive. */