@gajae-code/coding-agent 0.11.0 → 0.11.2

package/dist/types/modes/types.d.ts

@@ -1,13 +1,12 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { CompactionOutcome } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, UsageReport } from "@gajae-code/ai";
-import type { Component, Container, EditorTheme, Loader, Spacer, Text, TUI } from "@gajae-code/tui";
+import type { Component, Container, EditorTheme, Loader, SlashCommand, Spacer, Text, TUI } from "@gajae-code/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import type { Settings } from "../config/settings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import type { Skill } from "../extensibility/skills";
-import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { MCPManager } from "../runtime-mcp";
 import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
@@ -17,14 +16,15 @@ import type { CredentialAutoImportOptions } from "../setup/credential-auto-impor
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
+import type { CommandPaletteAction } from "./components/command-palette";
 import type { CustomEditor } from "./components/custom-editor";
 import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { PetMode } from "./components/gajae-pet-widget";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
-import type { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { StatusLineComponent } from "./components/tool-status-header";
 import type { IrcObservationLedger } from "./irc-observation-ledger";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
@@ -43,6 +43,11 @@ export type SubmittedUserInput = {
     cancelled: boolean;
     started: boolean;
 };
+export type ComposerSubmissionOptions = Readonly<{
+    ownsComposer: boolean;
+    editor: CustomEditor;
+}>;
+export declare function canApplyComposerSubmission(options: ComposerSubmissionOptions | undefined, editor: CustomEditor): boolean;
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 export type TodoItem = {
     content: string;
@@ -92,10 +97,6 @@ export interface InteractiveModeContext {
     isBashNoContext: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
-    planModeEnabled: boolean;
-    goalModeEnabled: boolean;
-    goalModePaused: boolean;
-    planModePlanFilePath?: string;
     hideThinkingBlock: boolean;
     pendingImages: ImageContent[];
     compactionQueuedMessages: CompactionQueuedMessage[];
@@ -149,12 +150,11 @@ export interface InteractiveModeContext {
     showNewVersionNotification(newVersion: string): void;
     clearEditor(): void;
     updatePendingMessagesDisplay(): void;
-    queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void;
     flushCompactionQueue(options?: {
         willRetry?: boolean;
     }): Promise<void>;
     flushPendingBashComponents(): void;
-    flushPendingModelSwitch(): Promise<void>;
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
     ensureLoadingAnimation(): void;
@@ -178,7 +178,7 @@ export interface InteractiveModeContext {
         images?: ImageContent[];
         customType?: string;
         display?: boolean;
-    }): SubmittedUserInput;
+    }, options?: ComposerSubmissionOptions): SubmittedUserInput;
     cancelPendingSubmission(): boolean;
     markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
     finishPendingSubmission(input: SubmittedUserInput): void;
@@ -239,9 +239,9 @@ export interface InteractiveModeContext {
     handleContextCommand(): void;
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
-    handleClearCommand(): Promise<void>;
+    handleClearCommand(): Promise<boolean>;
     handleContextClearCommand(): Promise<void>;
-    handleDropCommand(): Promise<void>;
+    handleDropCommand(): Promise<boolean>;
     handleForkCommand(): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
@@ -256,7 +256,10 @@ export interface InteractiveModeContext {
     handleSTTToggle(): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     openInBrowser(urlOrPath: string): void;
+    /** Resolved source of truth for slash autocomplete and command palette entries. */
+    getSlashCommands?(): readonly SlashCommand[];
     refreshSlashCommandState(cwd?: string): Promise<void>;
+    showCommandPalette(commands: SlashCommand[], actions: CommandPaletteAction[], executeSlashCommand: (name: string) => Promise<void>): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
     showPetSelector(): void;
@@ -272,6 +275,7 @@ export interface InteractiveModeContext {
     showUserMessageSelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
+    showSessionsDashboard(): void;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
@@ -279,6 +283,10 @@ export interface InteractiveModeContext {
     showDebugSelector(): void;
     showSessionObserver(): void;
     showJobsOverlay(): void;
+    showTasksPane(): void;
+    showTranscriptViewer(): void;
+    isTranscriptViewerOpen(): boolean;
+    refreshTranscriptViewer(): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;
     handleCtrlD(): void;
@@ -298,11 +306,10 @@ export interface InteractiveModeContext {
     toggleThinkingBlockVisibility(): void;
     openExternalEditor(): void;
     registerExtensionShortcuts(): void;
-    handlePlanModeCommand(initialPrompt?: string): Promise<void>;
-    handleGoalModeCommand(rest?: string): Promise<void>;
-    handlePlanApproval(details: PlanApprovalDetails): Promise<void>;
     initHooksAndCustomTools(): Promise<void>;
     emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
+    planModeController: Pick<import("./controllers/plan-mode-controller").PlanModeController, "enabled" | "paused" | "planFilePath" | "handleCommand" | "handleApproval" | "flushPendingModelSwitch">;
+    goalModeController: Pick<import("./controllers/goal-mode-controller").GoalModeController, "enabled" | "paused" | "handleCommand">;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     setHookStatus(key: string, text: string | undefined): void;
     showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -1,7 +1,7 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { AssistantMessage, Message } from "@gajae-code/ai";
 import { type Component, type TUI } from "@gajae-code/tui";
-import type { InteractiveModeContext, IrcArrivalSnapshot, TranscriptRebuildPolicy } from "../../modes/types";
+import { type ComposerSubmissionOptions, type InteractiveModeContext, type IrcArrivalSnapshot, type TranscriptRebuildPolicy } from "../../modes/types";
 import { type SessionContext } from "../../session/session-manager";
 import { type ParsedIrcMessage } from "./irc-message";
 export type { TranscriptRebuildPolicy } from "../../modes/types";
@@ -63,7 +63,7 @@ export declare class UiHelpers {
     showWarning(warningMessage: string): void;
     showNewVersionNotification(newVersion: string): void;
     updatePendingMessagesDisplay(): void;
-    queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void;
     isKnownSlashCommand(text: string): boolean;
     flushCompactionQueue(options?: {
         willRetry?: boolean;

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

@@ -181,7 +181,7 @@ export declare class MCPManager {
      */
     executePrompt(name: string, promptName: string, args?: Record<string, string>, options?: MCPRequestOptions): Promise<MCPGetPromptResult | undefined>;
     /**
-     * Get all server instructions (for system prompt injection).
+     * Get connected-server instructions for request-scoped untrusted user-role context.
      */
     getServerInstructions(): Map<string, string>;
     /**

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

@@ -1,4 +1,6 @@
-import { type BrokerDiscovery, redactBrokerDiscovery } from "./discovery";
+import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
+import { type DirectoryMigrationPolicy } from "../session-directory";
+import { type BrokerDiscovery, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
 import { SessionIndex } from "./session-index";
 export interface BrokerSettings {
@@ -6,18 +8,81 @@ export interface BrokerSettings {
     packageGeneration?: string;
     port?: number;
     heartbeatTtlMs?: number;
+    /** Broker-owned migration policy. Client lifecycle frames cannot select it. */
+    resolveDirectoryMigration?: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 }
+type ResolvedBrokerSettings = {
+    agentDir: string;
+    packageGeneration: string;
+    port: number;
+    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" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
+export type BrokerCleanupIdentity = {
+    dev: string;
+    ino: string;
+    size: number;
+    mtimeNs: string;
+    sha256: string;
+};
+/** Exact retry evidence; detached paths are managed-receipt references, never caller authority. */
+export type BrokerLifecycleCleanupFile = {
+    /** Original lifecycle-owned path, retained only for exact identity validation. */
+    path: string;
+    identity: BrokerCleanupIdentity;
+    /** Monotonic append-only cleanup attempt. */
+    attempt?: number;
+    /** Immutable no-replace quarantine destination persisted before native detach. */
+    plannedPath: string;
+    /** Native-returned detached path, persisted after a failed post-detach cleanup. */
+    detachedPath?: string;
+    /** Append-only terminal proof for this exact artifact; completed entries are never retried. */
+    completed?: true;
+};
+/** Durable root-tree authority for broker artifact cleanup. */
+export type BrokerArtifactTree = {
+    identity: BrokerCleanupIdentity;
+    snapshot: NativeDirectoryTreeSnapshot;
+    plannedPath: string;
+    detachedPath?: string;
+    completed?: true;
+};
 export type BrokerCleanupEvidence = {
-    phase: "artifacts" | "transcript" | "metadata";
-    artifactsIdentity?: {
-        dev: string;
-        ino: string;
-    };
-    transcriptIdentity?: {
-        dev: string;
-        ino: string;
-    };
+    phase: "artifacts" | "transcript" | "metadata" | "lifecycle";
+    /** Ledger-bound deletion target; never reconstructed from a retry request. */
+    sessionsRoot?: string;
+    transcriptPath?: string;
+    cwd?: string;
+    metadataRoot?: string;
+    sessionId?: string;
+    artifactsIdentity?: BrokerCleanupIdentity;
+    transcriptIdentity?: BrokerCleanupIdentity;
+    /** Identity-bound lifecycle metadata marker retained when exact cleanup is deferred. */
+    metadataIdentity?: BrokerCleanupIdentity;
+    metadataPath?: string;
+    /** Monotonic append-only cleanup attempt. */
+    metadataAttempt?: number;
+    /** No-replace quarantine destination persisted before lifecycle metadata detach. */
+    plannedMetadataPath?: string;
+    /** Native-returned metadata quarantine path retained until identity-bound reconciliation succeeds. */
+    detachedMetadataPath?: string;
+    /** Append-only terminal proof for lifecycle metadata cleanup. */
+    metadataCompleted?: true;
+    detachedArtifactsPath?: string;
+    detachedTranscriptPath?: string;
+    /** Durable proof that artifact cleanup completed before transcript mutation. */
+    artifactsRemoved?: boolean;
+    /** Preauthorized no-replace artifact quarantine path persisted before detach. */
+    plannedArtifactsPath?: string;
+    /** Identity-bound artifact tree authority persisted before broker detach and replayed exactly. */
+    artifactTree?: BrokerArtifactTree;
+    /** Preauthorized no-replace transcript quarantine path persisted before detach. */
+    plannedTranscriptPath?: string;
+    /** Fully identity-bound startup-failure cleanup plan, persisted before any detach. */
+    lifecycleFiles?: BrokerLifecycleCleanupFile[];
+    /** Delete metadata receipts authorize only the canonical marker/ready sibling pair. */
+    lifecycleDeleteMetadata?: true;
 };
 export type BrokerResponse = {
     ok: true;
@@ -37,17 +102,18 @@ export type BrokerResponse = {
 };
 export declare class Broker {
     #private;
-    readonly settings: Required<BrokerSettings>;
+    readonly settings: ResolvedBrokerSettings;
     readonly index: SessionIndex;
     readonly ledger: LifecycleLedger;
     discovery: BrokerDiscovery | null;
     constructor(settings: BrokerSettings);
     start(): Promise<BrokerDiscovery>;
     get ownsDiscovery(): boolean;
-    status(): ReturnType<typeof redactBrokerDiscovery> | null;
+    status(): RedactedBrokerDiscovery | null;
     heartbeat(): Promise<void>;
     stop(): Promise<void>;
     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;
+export {};

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

@@ -11,6 +11,13 @@ export interface EnsureBrokerSettings {
      */
     env?: NodeJS.ProcessEnv;
 }
+export interface FixtureBrokerLease {
+    close(): Promise<void>;
+}
+export interface StartedFixtureBroker {
+    discovery: BrokerDiscovery;
+    lease: FixtureBrokerLease;
+}
 interface BrokerOwner {
     stop(): Promise<void>;
     canReuse(discovery: BrokerDiscovery | null): boolean;
@@ -22,6 +29,8 @@ interface ReapTiming {
 }
 /** Starts the detached broker entrypoint when discovery has no live owner. */
 export declare function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery>;
+/** Starts one fresh fixture broker and returns its sole exact-child close lease. */
+export declare function startFixtureBrokerWithLeaseForTest(settings: EnsureBrokerSettings): Promise<StartedFixtureBroker>;
 /** Test hook: returns a stop handle for the detached broker this process spawned. */
 export declare function brokerOwnerForTest(agentDir: string): BrokerOwner | undefined;
 /** Test hook: drives the detached-broker reap on a controllable child surface. */

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

@@ -0,0 +1,4 @@
+/** Decodes persisted lifecycle bytes without replacement characters before JSON parsing. */
+export declare function decodeLifecycleUtf8(bytes: Uint8Array): string;
+/** Parses persisted lifecycle JSON only after fatal UTF-8 decoding. */
+export declare function parseLifecycleJson(bytes: Uint8Array): unknown;

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

@@ -83,10 +83,24 @@ export type BeginResult = {
     kind: "in_progress";
     entry: LifecycleLedgerEntry;
 };
+export interface LifecycleLedgerLimits {
+    maxBytes?: number;
+    maxLineBytes?: number;
+    maxRows?: number;
+}
 export declare class LifecycleLedger {
     #private;
-    constructor(agentDir: string);
+    constructor(agentDir: string, limits?: LifecycleLedgerLimits);
     open(): Promise<this>;
+    /**
+     * Reads terminal proof for one request without recovering or changing the ledger.
+     *
+     * This intentionally accepts an unrelated unterminated final write: concurrent
+     * appenders may have started a different row after this request's synced terminal
+     * row. Complete rows are still decoded and validated strictly, and any incomplete
+     * tail that identifies this request withholds proof.
+     */
+    readTerminal(identity: string, requestHash: string): Promise<LifecycleLedgerEntry | undefined>;
     get warnings(): readonly string[];
     begin(identity: string, requestHash: string): Promise<BeginResult>;
     transition(identity: string, state: LifecycleState, fields?: Omit<Partial<LifecycleLedgerEntry>, "identity" | "requestHash" | "state" | "ts">): Promise<LifecycleLedgerEntry>;

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

@@ -1,5 +1,5 @@
 import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
-import type { Broker, BrokerResponse } from "./broker";
+import type { Broker, BrokerCleanupEvidence, BrokerResponse } from "./broker";
 import type { LifecycleDurableEffectsReceipt, LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
 import { type ProcessIncarnationCommandRunner, type ProcessIncarnationOptions, parseDarwinProcessIncarnation, processIncarnation } from "./process-incarnation";
 import { type SdkInternalSpawnCommand } from "./runtime";
@@ -21,6 +21,8 @@ type LifecycleCommand = SdkInternalSpawnCommand | {
     args: string[];
 };
 type LifecycleCommandResolver = () => LifecycleCommand;
+/** Test-only hook for simulating a crash immediately after one exact lifecycle detach. */
+export declare function setLifecycleCleanupHookForTest(broker: Broker, hook: (() => void) | undefined): void;
 export declare function setLifecycleCommandResolverForTest(broker: Broker, resolver: LifecycleCommandResolver | undefined): void;
 export declare function setLifecycleTimingForTest(broker: Broker, timing: LifecycleTiming | undefined): void;
 export declare function hasValidLifecycleDeadlines(value: LifecycleDeadlines, now?: number): boolean;
@@ -43,6 +45,7 @@ export interface SessionLifecycleTranscriptIdentity {
     size: number;
     mtimeMs: number;
     mtimeNs: string;
+    sha256: string;
 }
 export interface SessionLifecycleLaunchRequest {
     operation: "session.create" | "session.fork" | "session.resume";
@@ -66,6 +69,7 @@ export interface SessionLifecycleLaunchRequest {
     lifecycleCleanupDeadlineAt: number;
 }
 export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
+type CleanupEvidence = BrokerCleanupEvidence;
 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>;
@@ -82,4 +86,4 @@ export interface LifecycleExecutionOutcome {
     deferredArtifactCleanup?: () => Promise<void>;
 }
 /** Returns the response together with every durable lifecycle fact needed for truthful replay. */
-export declare function executeLifecycle(broker: Broker, operation: string, input: Input, identity: string): Promise<LifecycleExecutionOutcome>;
+export declare function executeLifecycle(broker: Broker, operation: string, input: Input, identity: string, cleanup?: CleanupEvidence): Promise<LifecycleExecutionOutcome>;

package/dist/types/sdk/broker/process-incarnation.d.ts

@@ -9,6 +9,8 @@ export interface ProcessIncarnationOptions {
 }
 /** Parse the microsecond-resolution start timestamp returned by Darwin proc_pidinfo. */
 export declare function parseDarwinProcessIncarnation(info: Uint8Array): string | undefined;
+/** Whether `value` is a canonical process-incarnation string (`linux:`/`darwin:`/`windows:`). */
+export declare function isProcessIncarnation(value: unknown): value is string;
 /** A PID is reusable; bind it to the strongest OS-provided process start incarnation available. */
 export declare function processIncarnation(pid: number, options?: ProcessIncarnationOptions): string | undefined;
 export {};

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

@@ -46,7 +46,6 @@ export declare class SessionIndex {
     get indexSeq(): number;
     append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;
     snapshot(): Promise<void>;
-    assertSupportedStateVersions(): Promise<void>;
     listSessions(): SessionList;
     hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId">): {
         indexSeq: number;

package/dist/types/sdk/broker/state-version.d.ts

@@ -1,4 +1,5 @@
 export declare const SDK_STATE_VERSION = 1;
+export declare const SESSION_INDEX_SNAPSHOT_VERSION = 2;
 export declare class UnsupportedStateVersionError extends Error {
     readonly file: string;
     readonly version: number;
@@ -6,3 +7,4 @@ export declare class UnsupportedStateVersionError extends Error {
     constructor(file: string, version: number);
 }
 export declare function assertSupportedStateVersion(file: string, value: unknown): void;
+export declare function assertSupportedSnapshotVersion(file: string, value: unknown): void;

package/dist/types/sdk/bus/chat-effect-journal.d.ts

@@ -62,6 +62,7 @@ export declare class ChatEffectJournal {
         pidIncarnation?: (pid: number) => string | undefined;
         sleep?: (ms: number) => Promise<void>;
         lockTimeoutMs?: number;
+        maxTerminalEffects?: number;
     });
     get filePath(): string;
     read<TPayload = unknown>(id: string): Promise<ChatEffect<TPayload> | undefined>;

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

@@ -5,7 +5,7 @@
  * removed), but the user can still adjust per-surface behaviour from inside a
  * session thread with small slash commands:
  *
- * - `/verbose`            switch the mirror to verbose (full tool output + reasoning)
+ * - `/verbose`            switch the mirror to bounded tool-owned summaries + provider-displayable reasoning summaries
  * - `/lean`               switch back to lean (assistant text + tool names)
  * - `/verbosity lean|verbose`
  * - `/redact on|off`      toggle redaction of streamed content

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

@@ -28,6 +28,9 @@ export interface NotificationSettingsSnapshot {
         botToken?: string;
         chatId?: string;
         activation?: Record<string, unknown>;
+        btw: {
+            enabled: boolean;
+        };
         rich: {
             enabled: boolean;
         };
@@ -65,6 +68,11 @@ export interface NotificationSettingsReader {
     getNotificationSettingsSnapshot(): NotificationSettingsSnapshot;
     getAgentDir(): string;
 }
+/**
+ * Validate and snapshot the raw global notification configuration used by both
+ * the interactive host and the lightweight daemon process.
+ */
+export declare function parseNotificationSettingsSnapshot(rawConfig?: unknown): NotificationSettingsSnapshot;
 export interface NotificationConfig {
     enabled: boolean;
     botToken?: string;
@@ -92,6 +100,9 @@ export interface NotificationConfig {
      */
     sessionScope: "all" | "primary";
     idleTimeoutMs: number;
+    btw: {
+        enabled: boolean;
+    };
     rich: {
         enabled: boolean;
     };

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

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

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

@@ -9,6 +9,10 @@ export interface DiscordEndpointBinding {
     isCurrent(): boolean;
     send(frame: Record<string, unknown>): void | Promise<void>;
 }
+export interface DiscordLeaseRecoveryScheduler {
+    setTimeout(callback: () => void | Promise<void>, delayMs: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
 export interface DiscordNotificationDaemonOptions {
     agentDir: string;
     repo: string;
@@ -16,6 +20,7 @@ export interface DiscordNotificationDaemonOptions {
     parentChannelId: string;
     provider: DiscordProvider;
     now?: () => number;
+    leaseRecoveryScheduler?: DiscordLeaseRecoveryScheduler;
     resolveEndpoint: (sessionId: string, expectedGeneration?: number) => Promise<DiscordEndpointBinding | null>;
     onCommand?: (sessionId: string, content: string, endpoint: DiscordEndpointBinding, idempotencyKey: string) => Promise<boolean>;
 }

package/dist/types/sdk/bus/html-format.d.ts

@@ -26,8 +26,9 @@ export declare function code(raw: string): string;
 export declare function pre(raw: string): string;
 /**
  * Convert a bounded markdown subset into Telegram HTML. Supported: fenced code,
- * inline code, `**bold**`, `*italic*`, `[text](url)` (safe schemes only),
- * `#` headers, `>` blockquotes, and GFM tables (rendered as a monospace block).
+ * inline code, `**bold**`, `*italic*`, `~~strikethrough~~`, `[text](url)`
+ * (safe schemes only), `#` headers, `>` blockquotes, and GFM tables (rendered
+ * as a monospace block).
  * Unsupported or malformed markdown is left as escaped literal text — never
  * emitted as unbalanced tags.
  */

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

@@ -17,6 +17,7 @@
  * Enable with Settings notifications config, `GJC_NOTIFICATIONS=1` (a token is
  * generated), or `GJC_NOTIFICATIONS_TOKEN`.
  */
+import type { Tool } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
@@ -259,6 +260,9 @@ export declare class PresentationArbiter {
     cancel(gateId: string, reason: string): void;
     dispose(): void;
 }
+/** Stable projection of the tool-owned safe-display seam (never the full Tool surface). */
+type SafeSummaryTool = Pick<Tool, "safeSummary" | "safeSummaryFields">;
+export declare function projectToolSummary(tool: SafeSummaryTool | undefined, kind: "args" | "result", value: unknown): string | undefined;
 export declare function notificationsEnabled(): boolean;
 /** Workflow-gate answer shape. */
 interface GateAnswer {
@@ -304,6 +308,26 @@ export interface NotificationControlCommandResult {
     }>;
 }
 export declare function executeNotificationControlCommand(command: NotificationControlCommandPayload | undefined, ctx: ExtensionContext, api: ExtensionAPI, expectedSessionId?: string): Promise<NotificationControlCommandResult>;
+interface EphemeralTurnAuthority {
+    sessionId: string;
+    endpointDigest: string;
+    eventGeneration: number;
+}
+/** Host-owned, bounded idempotency and cancellation lifecycle for v3 side turns. */
+export declare class EphemeralTurnHost {
+    #private;
+    constructor(sendTo: (connectionId: string, frame: Record<string, unknown>) => void, execute: (question: string, signal: AbortSignal) => Promise<{
+        replyText: string;
+    }>, now?: () => number);
+    configureAuthority(authority: EphemeralTurnAuthority): void;
+    disable(): void;
+    enable(): void;
+    dispose(): void;
+    handle(connectionId: string, frame: Record<string, unknown>): boolean;
+    sessionUnavailable(sessionId: string): void;
+    /** Testable event-ring eviction boundary; tombstones remain idempotency authority. */
+    evictTerminalEvents(): void;
+}
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
@@ -315,5 +339,8 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     spawnedByGjc?: boolean;
     controller?: NotificationSessionController;
     onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
+    runEphemeralTurn?: (promptText: string, signal: AbortSignal) => Promise<{
+        replyText: string;
+    }>;
 }): void;
 export {};

package/dist/types/sdk/bus/lifecycle-control-runtime.d.ts

@@ -68,6 +68,8 @@ export declare function daemonCloseSession(env?: NodeJS.ProcessEnv, deps?: {
  *  prefix against saved history and fail closed (`ambiguous`/`notFound`) before
  *  cold-restarting exactly one resolved session via the daemon-safe launcher. */
 export declare function daemonResumeSession(env?: NodeJS.ProcessEnv, opts?: {
+    agentDir?: string;
+    /** Explicit managed root for isolated tests. */
     sessionsRoot?: string;
     listSessions?: (env: NodeJS.ProcessEnv) => GjcTmuxSessionStatus[];
     ownerIsolationProbe?: OwnerIsolationProbe;
@@ -100,6 +102,8 @@ export declare function buildOrchestratorDeps(input: {
     auditRedactionKey: Uint8Array;
     /** Root of saved session histories (`<agentDir>/sessions`), for resume resolution. */
     sessionsRoot?: string;
+    /** Agent directory used for readonly managed-session resume resolution. */
+    agentDir?: string;
     env?: NodeJS.ProcessEnv;
 }): OrchestratorDeps;
 /**

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

@@ -5,10 +5,29 @@ import type { Settings } from "../../config/settings";
  * can never leak a credential regardless of where the string originated.
  */
 export declare function sanitizeDiagnostic(text: string, token?: string): string;
+/** Identity evidence required to remove precisely the endpoint that was inspected. */
+export interface NotificationEndpointFileIdentity {
+    dev: bigint;
+    ino: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+    sha256: string;
+}
+export interface NotificationEndpointFile {
+    bytes: Buffer;
+    identity: NotificationEndpointFileIdentity;
+}
+export interface NotificationExactUnlinkResult {
+    ok: boolean;
+    code?: string;
+    detachedPath?: string;
+}
 /** Minimal filesystem surface the service needs; injectable for tests. */
 export interface NotificationServiceFs {
     readdir(dir: string): Promise<string[]>;
     readFile(file: string, encoding: "utf8"): Promise<string>;
+    readEndpointFile(file: string): Promise<NotificationEndpointFile>;
+    exactUnlink(file: string, identity: NotificationEndpointFileIdentity): Promise<NotificationExactUnlinkResult>;
     unlink(file: string): Promise<void>;
     /**
      * Atomically create `file` with O_EXCL semantics: resolves `true` when this
@@ -123,6 +142,7 @@ export interface NotificationRecoveryReport {
     endpointsRemoved: RecoveredEndpoint[];
     endpointsKept: number;
     endpointsUnreadable: number;
+    endpointsDetached?: string[];
     daemon: {
         action: DaemonRecoveryAction;
         detail: string;