@gajae-code/coding-agent 0.11.8 → 0.11.10

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

@@ -13,7 +13,9 @@ export type ChatDaemonAction = "stop" | "reload";
  * 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.
+ * 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.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

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

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

@@ -29,7 +29,7 @@ import { CursorRegistry, RevisionStore } from "../host/query";
 import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
-import { type EnsureDaemonResult } from "./telegram-daemon";
+import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -324,6 +324,12 @@ interface SessionRuntime {
     hostStopped: boolean;
     serverStopped: boolean;
     brokerRegistrationReleased: boolean;
+    /** Managed Telegram root registration released during terminal teardown. */
+    notificationRootRegistration?: {
+        settings: Settings;
+        cwd: string;
+        registrationToken?: string;
+    };
     verbosity: "lean" | "verbose";
     sessionTag: string;
     /** Whether the agent loop is currently running (drives the typing indicator). */
@@ -511,6 +517,7 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
         settings: Settings;
         cwd: string;
         sessionId: string;
+        onRegistered?: (registration: RegisterNotificationRootResult) => void;
     }) => Promise<EnsureDaemonResult>;
     ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>;
     /** Suppress auto-delivery for a GJC-spawned child under `sessionScope=primary`. */

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

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

package/dist/types/sdk/bus/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
@@ -36,5 +33,15 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * 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).
  */
-export declare const DAEMON_GENERATION = 26;
+export declare const DAEMON_GENERATION = 29;
+/**
+ * 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.
+ */
+export declare const SERVING_EPOCH = 2;

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

@@ -5,10 +5,10 @@ import { HEARTBEAT_TTL_MS } from "./daemon-paths";
 import { type DaemonTransitionLock, type NotificationEndpointFile, type NotificationEndpointFileIdentity, type NotificationExactUnlinkResult } from "./notification-service";
 import { type DaemonProcessReference } from "./telegram-daemon-control";
 import { type TelegramSetupPreflight } from "./telegram-setup";
-export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION } from "./telegram-daemon-contract";
+export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION, SERVING_EPOCH } from "./telegram-daemon-contract";
 import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
 import type { OrchestratorDeps } from "./lifecycle-orchestrator";
-import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
+import { NotificationOperatorRuntime } from "./operator-runtime";
 import { type AliasTable, type CallbackRoute } from "./telegram-reference";
 import { type TopicEndpointBinding } from "./topic-registry";
 export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
@@ -41,6 +41,8 @@ export interface DaemonState {
      * notification wire protocol version. Absent on pre-generation state.
      */
     generation?: number;
+    /** Lifecycle-serving compatibility epoch; absent pre-epoch records are epoch 1. */
+    servingEpoch?: number;
     stoppedAt?: number;
 }
 export interface TelegramDaemonFs {
@@ -201,15 +203,59 @@ export declare function liveOwnershipLockDecision(input: {
     attached: false;
     provisional: true;
 } | undefined;
+type OwnerHeartbeatSidecar = {
+    pid: number;
+    incarnation: string;
+    ownerId: string;
+    acquisitionId: string;
+    heartbeatAt: number;
+};
+export interface OwnerFreshnessSnapshot {
+    ownerTag: Pick<OwnerHeartbeatSidecar, "pid" | "incarnation" | "ownerId" | "acquisitionId"> | null;
+    effectiveHeartbeatAt: number | undefined;
+    legacyEmbedded: boolean;
+    state: DaemonState | undefined;
+}
+export declare function readOwnerFreshnessSnapshot(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+}): Promise<OwnerFreshnessSnapshot>;
+/** Marker-free steady heartbeat renewal. The final lock reread fences a stale writer. */
+export declare function renewOwnerHeartbeatSidecar(input: {
+    settings: Settings;
+    ownerId: string;
+    acquisitionId?: string;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    pid?: number;
+    pidIncarnation?: (pid: number) => string | undefined;
+}): Promise<boolean>;
+export interface NotificationRootRegistration {
+    root?: string;
+    managed?: boolean;
+    token?: string;
+}
+export declare function readNotificationRootRegistration(input: {
+    settings: Settings;
+    sessionId: string;
+    fs?: TelegramDaemonFs;
+}): Promise<NotificationRootRegistration>;
+export interface RegisterNotificationRootResult {
+    root: string;
+    /** Per-registration ownership token fencing a stale same-session cleanup from deleting a live replacement registration. */
+    token: string;
+}
 export declare function registerNotificationRoot(input: {
     settings: Settings;
     cwd: string;
     sessionId: string;
     fs?: TelegramDaemonFs;
-}): Promise<string>;
+}): Promise<RegisterNotificationRootResult>;
 export interface UnregisterNotificationRootResult {
     root: string;
     remainingRoots: number;
+    /** Opaque fingerprint of the exact registry written by this successful unregister. */
+    registryFingerprint?: string;
 }
 /** Remove one session's Telegram scan root without disturbing other live session roots. */
 export declare function unregisterNotificationRoot(input: {
@@ -217,7 +263,16 @@ export declare function unregisterNotificationRoot(input: {
     cwd: string;
     sessionId: string;
     fs?: TelegramDaemonFs;
+    /** Ownership token minted by this runtime's own registration; a stale cleanup presenting an older token never deletes a replacement registration. */
+    registrationToken?: string;
 }): Promise<UnregisterNotificationRootResult>;
+/** Run an action while the roots registry lock excludes any registration or unregister. */
+export declare function withNotificationRootRegistryFence(input: {
+    settings: Settings;
+    registryFingerprint: string;
+    action: () => Promise<void>;
+    fs?: TelegramDaemonFs;
+}): Promise<boolean>;
 /**
  * Leak artifact prefixes left when native exact-unlink cleanup is retained
  * (#2956). Nothing previously reaped these; they accumulate in the notifications
@@ -319,6 +374,7 @@ export declare function isFreshLiveOwner(input: {
     chatId: string;
     pidAlive: (pid: number) => boolean;
     pidIncarnation?: (pid: number) => string | undefined;
+    effectiveHeartbeatAt?: number;
 }): boolean;
 /** True only when a physically live matching owner can serve this build's daemon lifecycle contract. */
 export declare function isCurrentCompatibleOwner(input: {
@@ -328,6 +384,7 @@ export declare function isCurrentCompatibleOwner(input: {
     chatId: string;
     pidAlive: (pid: number) => boolean;
     pidIncarnation?: (pid: number) => string | undefined;
+    effectiveHeartbeatAt?: number;
 }): boolean;
 export declare function acquireDaemonOwnership(input: {
     settings: Settings;
@@ -399,7 +456,7 @@ export declare function retireProvisionalDaemonOwnership(input: {
     /** Only no-child confirmation may retire a ready-like launcher publication. */
     allowReadyWithoutChildPid?: boolean;
 }): Promise<boolean>;
-/** Wait for a matching current-generation daemon to publish a ready state. */
+/** Wait for a matching compatible owner to publish a ready state. Readiness is serving-epoch gated (same-epoch cross-generation owners attach, per isCurrentCompatibleOwner); generation is inventory-only here. Mutation paths still require exact current-generation equality. */
 export declare function waitForTelegramDaemonReady(input: {
     settings: Settings;
     ownerId?: string;
@@ -548,6 +605,9 @@ export declare function ensureTelegramDaemonRunningDetailed(input: {
     settings: Settings;
     cwd: string;
     sessionId: string;
+    registerRoot?: boolean;
+    /** Receives each registration this ensure operation minted so the caller can fence its own later cleanup. */
+    onRegistered?: (registration: RegisterNotificationRootResult) => void;
 }, deps?: TelegramDaemonDeps): Promise<EnsureTelegramDaemonDetailedResult>;
 /**
  * Legacy compatibility mapping for callers that only distinguish ownership from
@@ -600,7 +660,10 @@ export type TelegramPollResult = {
 export interface TelegramUpdatePollerOptions {
     botApi: BotApi;
     runtime: NotificationOperatorRuntime;
-    backoff: OperatorBackoffPolicy;
+    backoff: {
+        next(): number;
+        reset(): void;
+    };
     processUpdate: (update: unknown) => Promise<TelegramUpdateOutcome>;
     health?: TelegramPollHealth;
 }
@@ -785,6 +848,9 @@ export declare class TelegramNotificationDaemon {
     private readonly pool;
     private readonly poller;
     private readonly dispatchState;
+    /** Bot-wide flood-control window; inbound polling remains eligible during it. */
+    private botCooldownUntil;
+    private warnedBotCooldownUntil;
     /** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
     private readonly replyStore;
     /** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
@@ -871,6 +937,9 @@ export declare class TelegramNotificationDaemon {
     private refreshBotIdentity;
     /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
     private formatLifecycleResponse;
+    private callBotApi;
+    private readonly callBotApiClassified;
+    private botApiWithOutcomeCollector;
     constructor(opts: TelegramDaemonOptions);
     private createSessionRouter;
     loadAliases(): Promise<void>;

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

@@ -149,6 +149,13 @@ export interface CreateAgentSessionOptions {
     goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
+    /**
+     * Discoverable built-in tools that must stay in the initial active set even when
+     * `tools.discoveryMode === "all"` would otherwise hide them behind `search_tool_bm25`.
+     * Used for coordination tools (e.g. `irc`) that a subagent must be able to use
+     * immediately without first spending a discovery round-trip to find them.
+     */
+    alwaysActiveToolNames?: readonly string[];
     /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */

package/dist/types/session/agent-session.d.ts

@@ -677,6 +677,8 @@ export declare class AgentSession {
      * Get a tool by name from the registry.
      */
     getToolByName(name: string): AgentTool | undefined;
+    /** Get a registered tool with the same guards used for model-facing execution. */
+    getToolForExecution(name: string): AgentTool | undefined;
     /**
      * Register a UI/control-plane request handler for a currently foregrounded
      * managed bash execution. This is intentionally narrower than generic

package/dist/types/session/internal/managed-session-scope.d.ts

@@ -1,6 +1,7 @@
 import * as native from "@gajae-code/natives";
 import type { ResumeSessionIdentity } from "../session-manager";
-import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy } from "./managed-session-storage";
+import { type NativeDirectoryTreeSnapshot } from "../session-storage";
+import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy, type ManagedStorageLock } from "./managed-session-storage";
 export declare const MANAGED_SESSION_LAYOUT_VERSION: 2;
 export declare const MANAGED_SESSION_IDENTITY_VERSION: 1;
 export declare const MANAGED_SESSION_BINDING_FILE = ".gjc-managed-session-scope.v2.json";
@@ -67,7 +68,7 @@ export type ManagedCandidateListing = {
     code: "scan_failed" | "unsafe_root" | "invalid_candidate";
     message: string;
 };
-export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
+export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
 export type ManagedOpenCandidateResult = {
     kind: "opened";
     path: string;
@@ -114,12 +115,21 @@ interface ManagedScopeInput {
 export declare function resolveManagedScope(input: ManagedScopeInput): ManagedScopeResolution;
 /** Resolve a scope for a synchronous write without mutating an existing ACL mismatch. */
 export declare function resolveManagedScopeForWrite(input: ManagedScopeInput): ManagedScopeResolution;
+export declare function canonicalBindingOpenFlags(platform?: NodeJS.Platform): number;
+export declare function fsyncCanonicalBinding(bindingPath: string, expected: string): void;
 export declare function ensureManagedScope(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy): Promise<ManagedScopeResolution>;
 /** Synchronously create and validate the v2 binding before a default session writer exists. */
 export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority): ManagedScopeResolution;
 export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+export declare function matchesMigrationArtifactRoot(pathname: string, identity: {
+    dev: bigint;
+    ino: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+}, expectedTree: NativeDirectoryTreeSnapshot, platform?: NodeJS.Platform): boolean;
+export declare function restorePreparedArtifactRoot(scope: ManagedScope, source: ManagedCandidate, lock?: ManagedStorageLock): void;
 /** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
-export declare function reconcileManagedTombstones(scope: ManagedScope): Promise<void>;
+export declare function reconcileManagedTombstones(scope: ManagedScope, expectedCandidate?: ManagedCandidate): Promise<void>;
 /** Create the v2 binding and private write protocol directories before managed writes. */
 export declare function prepareManagedSessionScopeForWrite(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority, expectedCandidate?: ManagedCandidate, expectedIdentity?: ResumeSessionIdentity): Promise<ManagedScopeResolution>;
 /**

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -1,9 +1,10 @@
 import { type NativeDirectoryTreeSnapshot, type NativeOwnerOnlySecurityResult, type RecoveryFsRoot } from "@gajae-code/natives";
 import { type NativePublishOutcome } from "./native-publish-outcome";
 export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
-export declare const MANAGED_ARTIFACT_MAX_FILES = 10000;
+export declare const MANAGED_ARTIFACT_MAX_FILES = 50000;
 export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
 export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
+export declare const MANAGED_ARTIFACT_COPY_BATCH_SIZE = 256;
 export declare class ManagedPublishError extends Error {
     readonly classification: "destination_conflict" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "identity_mismatch" | "io_error" | "durability_failed";
     readonly diagnostic: string;
@@ -12,7 +13,7 @@ export declare class ManagedPublishError extends Error {
 /** Cleanup is safe only when the native move reports that it did not commit. */
 export declare function mayCleanManagedTreeStaging(error: unknown): boolean;
 export type ManagedSessionSecurityPolicy = "default" | "windows-existing-verify-first";
-export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "atomic_unavailable" | "durability_not_provable" | "migration_retired" | "managed_storage_unsupported";
+export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "durability_not_provable" | "migration_retired" | "managed_storage_unsupported";
 export interface ManagedStorageLock {
     path: string;
     attemptId: string;
@@ -104,8 +105,12 @@ export declare function replaceManagedFile(destination: string, bytes: Uint8Arra
 export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 /** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
 export declare function acquireManagedLock(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<ManagedStorageLock>;
+export interface ManagedArtifactTreeLimits {
+    maxFiles?: number;
+    maxTotalBytes?: number;
+}
 /** Bounds a no-follow artifact tree before it can be copied or deleted. */
-export declare function validateManagedArtifactTree(root: string): void;
+export declare function validateManagedArtifactTree(root: string, limits?: ManagedArtifactTreeLimits): void;
 /** Flush a copied managed artifact tree, including empty directories, before publishing its receipt. */
 export declare function fsyncManagedArtifactTree(root: string): NativeDirectoryTreeSnapshot;
 export declare function publishManagedTombstone(destination: string, record: Record<string, unknown>, assertOwned?: () => void): Promise<void>;

package/dist/types/session/session-manager.d.ts

@@ -327,6 +327,9 @@ export declare class SessionMigrationPolicyError extends Error {
     readonly code = "legacy_migration_disabled";
     constructor();
 }
+export declare class SessionArtifactCapacityError extends Error {
+    constructor(message: string);
+}
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
     kind: "opened";
@@ -334,7 +337,8 @@ export interface StrictSessionOpenSuccess {
 }
 export interface StrictSessionOpenFailure {
     kind: "error";
-    reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required";
+    reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required" | "artifact_capacity_exceeded";
+    message?: string;
 }
 /** Exact transcript bytes and authority captured from one descriptor-bound read. */
 export interface CapturedSessionTranscriptSnapshot {

package/dist/types/session/session-storage.d.ts

@@ -112,6 +112,11 @@ export interface SessionStorage {
     readSnapshotSync?(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    /** List matching files with mtimes without issuing one JavaScript stat call per path. */
+    listFilesByMtime?(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     /**
      * Strict directory scan that never suppresses scan/root errors. Used by strict
      * authorization inventory; the forgiving {@link listFilesSync} stays display-only.
@@ -267,6 +272,10 @@ export declare class FileSessionStorage implements SessionStorage {
     readSnapshotSync(fpath: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesByMtime(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
@@ -299,6 +308,10 @@ export declare class MemorySessionStorage implements SessionStorage {
     readSnapshotSync(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesByMtime(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;

package/dist/types/skill-state/active-state.d.ts

@@ -45,6 +45,8 @@ export interface SkillActiveEntry {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     source_state_revision?: number;
+    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
+    committed_mode_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -85,6 +87,8 @@ export interface SyncSkillActiveStateOptions {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     sourceRevision?: number;
+    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
+    committedModeRevision?: number;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;

package/dist/types/task/provider-retry-status.d.ts

@@ -0,0 +1,13 @@
+import type { AgentProgress, TaskToolDetails } from "./types";
+export type ProviderRetryKind = NonNullable<AgentProgress["retryState"]>["kind"];
+export declare function classifyProviderRetry(errorMessage: string): ProviderRetryKind;
+export declare function providerNameFromModel(model: string | undefined): string | undefined;
+export declare function providerRetryPhaseLabel(kind: ProviderRetryKind): string;
+export declare function providerProgressAgeLabel(retryState: NonNullable<AgentProgress["retryState"]>, nowMs: number): string;
+export declare function hasActiveProviderRetryInTaskDetails(details: TaskToolDetails, seen?: WeakSet<object>): boolean;
+export declare function hasActiveProviderRetryInProgress(progress: AgentProgress, seen?: WeakSet<object>): boolean;
+export interface ProviderDegradationGroup {
+    provider: string;
+    count: number;
+}
+export declare function collectProviderDegradationGroups(progress: readonly AgentProgress[]): ProviderDegradationGroup[];

package/dist/types/task/types.d.ts

@@ -416,6 +416,9 @@ export interface AgentProgress {
         attempt: number;
         maxAttempts: number;
         unbounded?: boolean;
+        kind: "first_event_timeout" | "idle_stream_stall" | "provider_error";
+        provider?: string;
+        lastProviderProgressAtMs?: number;
         delayMs: number;
         errorMessage: string;
         startedAtMs: number;

package/dist/types/tools/index.d.ts

@@ -198,9 +198,11 @@ export interface ToolSession {
     /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
     getAgentId?: () => string | null;
     /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    getToolByName?: (name: string) => AgentTool | undefined;
+    /** Look up a registered tool with the session's execution guards applied. */
+    getToolForExecution?: (name: string) => AgentTool | undefined;
     /** Purge undelivered queued custom messages matching the predicate. Returns counts. */
     purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
-    getToolByName?: (name: string) => AgentTool | undefined;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;
     /** Optional restricted bash command prefixes for read-only role agents and constrained modes. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.8",
+	"version": "0.11.10",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.8",
-		"@gajae-code/agent-core": "0.11.8",
-		"@gajae-code/ai": "0.11.8",
-		"@gajae-code/bridge-client": "0.11.8",
-		"@gajae-code/natives": "0.11.8",
-		"@gajae-code/tui": "0.11.8",
-		"@gajae-code/utils": "0.11.8",
+		"@gajae-code/stats": "0.11.10",
+		"@gajae-code/agent-core": "0.11.10",
+		"@gajae-code/ai": "0.11.10",
+		"@gajae-code/bridge-client": "0.11.10",
+		"@gajae-code/natives": "0.11.10",
+		"@gajae-code/tui": "0.11.10",
+		"@gajae-code/utils": "0.11.10",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/generate-sdk-operation-inventory.ts

@@ -70,6 +70,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:getAsyncDeliveryStateForAcp":
 		"internal ACP lifecycle quiescence plumbing, not a user-facing control seam",
 	"agent_session:getToolByName": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:getToolForExecution": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:registerForegroundBashBackgroundRequestHandler":
 		"internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:hasForegroundBashBackgroundRequestHandler":

package/src/cli/mcp-cli.ts

@@ -6,6 +6,7 @@
  */
 import { getMCPConfigPath, getProjectDir } from "@gajae-code/utils";
 import { getMCPServer, readMCPConfigFile, removeMCPServer, upsertMCPServer } from "../runtime-mcp/config-writer";
+import { redactMCPEndpoint } from "../runtime-mcp/redaction";
 import type { MCPConfigFile, MCPServerConfig } from "../runtime-mcp/types";
 
 export type MCPAction = "add" | "list" | "remove";
@@ -141,24 +142,6 @@ function redactRecord(
 	);
 }
 
-function redactUrl(value: string | undefined): string | undefined {
-	if (!value) return value;
-	try {
-		const url = new URL(value);
-		if (url.username) url.username = REDACTED;
-		if (url.password) url.password = REDACTED;
-		if (url.search) {
-			for (const key of Array.from(url.searchParams.keys())) {
-				url.searchParams.set(key, REDACTED);
-			}
-		}
-		url.hash = "";
-		return url.toString();
-	} catch {
-		return SENSITIVE_KEY_PATTERN.test(value) ? REDACTED : value;
-	}
-}
-
 function redactArgs(args: string[] | undefined): string[] | undefined {
 	if (!args) return undefined;
 	const redacted: string[] = [];
@@ -196,7 +179,7 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 		if (headers) redacted.headers = headers;
 	}
 	if ("url" in redacted) {
-		const url = redactUrl(redacted.url);
+		const url = redactMCPEndpoint(redacted.url);
 		if (url) redacted.url = url;
 	}
 	if ("args" in redacted) {
@@ -207,7 +190,7 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 		redacted.auth = {
 			type: redacted.auth.type,
 			credentialId: redacted.auth.credentialId ? REDACTED : undefined,
-			tokenUrl: redactUrl(redacted.auth.tokenUrl),
+			tokenUrl: redactMCPEndpoint(redacted.auth.tokenUrl),
 			clientId: redacted.auth.clientId ? REDACTED : undefined,
 			clientSecret: redacted.auth.clientSecret ? REDACTED : undefined,
 		};
@@ -216,7 +199,7 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 		redacted.oauth = {
 			clientId: redacted.oauth.clientId ? REDACTED : undefined,
 			clientSecret: redacted.oauth.clientSecret ? REDACTED : undefined,
-			redirectUri: redactUrl(redacted.oauth.redirectUri),
+			redirectUri: redactMCPEndpoint(redacted.oauth.redirectUri),
 			callbackPort: redacted.oauth.callbackPort,
 			callbackPath: redacted.oauth.callbackPath,
 		};

package/src/cli/notify-cli.ts

@@ -413,6 +413,7 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 								settings,
 								cwd: process.cwd(),
 								sessionId: `notify-cli-${process.pid}`,
+								registerRoot: false,
 							}),
 				persistInactive: async marker => await persistTelegramActivationMarker(settings, marker),
 				clearInactive: async marker => await clearTelegramActivationMarker(settings, marker),

package/src/cli.ts

@@ -118,6 +118,36 @@ Options:
 `);
 }
 
+export function interactiveBootstrapText(
+	argv: readonly string[],
+	stdinIsTTY = process.stdin.isTTY,
+	stdoutIsTTY = process.stdout.isTTY,
+): string | undefined {
+	if (!stdinIsTTY || !stdoutIsTTY || argv[0] !== "launch") return undefined;
+	for (let index = 1; index < argv.length; index++) {
+		const arg = argv[index];
+		if (
+			arg === "--print" ||
+			arg?.startsWith("--print=") ||
+			arg === "-p" ||
+			arg === "--export" ||
+			arg?.startsWith("--export=") ||
+			arg === "--list-models" ||
+			arg?.startsWith("--list-models=") ||
+			arg === "--mode" ||
+			arg?.startsWith("--mode=") ||
+			arg === "--help" ||
+			arg?.startsWith("--help=") ||
+			arg === "-h" ||
+			arg === "--version" ||
+			arg?.startsWith("--version=") ||
+			arg === "-v"
+		)
+			return undefined;
+	}
+	return "\u001b[?25h\u001b[38;5;45mGJC\u001b[0m warming workspace\r\n\r\n> ";
+}
+
 function isNotifyDaemonInternalFastPath(argv: string[]): boolean {
 	return argv[0] === "notify" && argv[1] === "daemon-internal";
 }
@@ -412,6 +442,8 @@ export async function runCli(argv: string[]): Promise<void> {
 		showStatsFastHelp();
 		return;
 	}
+	const bootstrap = interactiveBootstrapText(runArgv);
+	if (bootstrap) process.stdout.write(bootstrap);
 	await installRuntimeGlobals();
 	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
 }