@sayknow-cli/coding-agent 0.4.7 → 0.5.1

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

@@ -0,0 +1,106 @@
+/**
+ * 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`.
+ * - 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.
+ */
+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/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

@@ -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
@@ -19,7 +16,34 @@ 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).
+ * 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 = 13;
+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-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. */