@gajae-code/coding-agent 0.11.7 → 0.11.8

package/dist/types/modes/interactive-mode.d.ts

@@ -3,7 +3,7 @@ import type { CompactionOutcome } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, UsageReport } from "@gajae-code/ai";
 import type { Component, EditorTheme, SlashCommand } from "@gajae-code/tui";
 import { Container, Loader, Spacer, Text, TUI } from "@gajae-code/tui";
-import { KeybindingsManager } from "../config/keybindings";
+import { KeybindingsManager, type KeyDisplayContext } 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";
@@ -30,9 +30,11 @@ import { GoalModeController } from "./controllers/goal-mode-controller";
 import { PlanModeController } from "./controllers/plan-mode-controller";
 import { IrcObservationLedger } from "./irc-observation-ledger";
 import { OAuthManualInputManager } from "./oauth-manual-input";
+import { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import { type CompactionQueuedMessage, type ComposerSubmissionOptions, type InteractiveModeContext, type IrcArrivalSnapshot, type SubmittedUserInput, type TodoItem, type TodoPhase, type TranscriptRebuildPolicy } from "./types";
 import type { ParsedIrcMessage } from "./utils/irc-message";
+export declare function getDefaultComposerPlaceholder(context?: KeyDisplayContext): string;
 export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
 export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
@@ -115,12 +117,13 @@ export declare class InteractiveMode implements InteractiveModeContext {
     fileSlashCommands: Set<string>;
     skillCommands: Map<string, Skill>;
     oauthManualInput: OAuthManualInputManager;
+    promptSuggestion: PromptSuggestionController;
     readonly lspServers: LspStartupServerInfo[] | undefined;
     mcpManager?: import("../runtime-mcp").MCPManager;
     /** Direct controller capabilities for consumers that coordinate mode transitions. */
     get planModeController(): PlanModeController;
     get goalModeController(): GoalModeController;
-    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../runtime-mcp").MCPManager, eventBus?: EventBus);
+    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../runtime-mcp").MCPManager, eventBus?: EventBus, keyDisplayContext?: KeyDisplayContext);
     getCurrentSessionNotificationStatus(): NotificationSessionStatus | undefined;
     setCurrentSessionNotificationsEnabled(enabled: boolean): Promise<NotificationSessionReconcileResult | undefined>;
     init(): Promise<void>;

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -22,10 +22,15 @@ interface PromptActionAutocompleteOptions {
     moveCursorToMessageStart: () => void;
     moveCursorToLineStart: () => void;
     moveCursorToLineEnd: () => void;
+    /**
+     * Ghost-text next-prompt prediction shown in the empty composer as a dim
+     * inline hint (Tab accepts it via the editor's onTab handler).
+     */
+    getPromptSuggestion?: () => string | null;
 }
 export declare class PromptActionAutocompleteProvider implements AutocompleteProvider {
     #private;
-    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]);
+    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[], getPromptSuggestion?: () => string | null);
     getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
         items: AutocompleteItem[];
         prefix: string;

package/dist/types/modes/prompt-suggestion-controller.d.ts

@@ -0,0 +1,35 @@
+import type { InteractiveModeContext } from "./types";
+/**
+ * Owns the ghost-text next-prompt prediction lifecycle for interactive mode.
+ *
+ * After each agent turn ends (and only when `promptSuggestions` is enabled
+ * and the composer is empty), a smol-model prediction of the user's next
+ * prompt is generated in the background. The result renders as dim ghost
+ * text in the empty composer via the autocomplete provider's inline hint;
+ * Tab accepts it, typing dismisses it, and a new turn clears it.
+ */
+export declare class PromptSuggestionController {
+    #private;
+    constructor(ctx: InteractiveModeContext);
+    /** Current suggestion to render as ghost text, or null. */
+    get current(): string | null;
+    /** Drop the current suggestion and invalidate any in-flight generation. */
+    clear(): void;
+    /** A new agent turn started; any pending suggestion is stale. */
+    onAgentStart(): void;
+    /**
+     * Editor content changed. A non-empty composer means the user is writing
+     * their own prompt: dismiss the suggestion and cancel pending generation.
+     */
+    notifyEditorChanged(text: string): void;
+    /**
+     * Agent turn ended; kick off background generation when the feature is
+     * enabled and the composer is idle and empty.
+     */
+    onAgentEnd(): void;
+    /**
+     * Tab handler for the composer: accept the suggestion when the composer
+     * is empty. Returns true when Tab was consumed.
+     */
+    tryAcceptOnTab(text: string): boolean;
+}

package/dist/types/modes/shared/agent-wire/workflow-gate-broker.d.ts

@@ -59,7 +59,7 @@ export interface AskSelectedAckRecoveryParticipant {
 }
 /** SDK-native surface for emitting a workflow gate and awaiting its answer. */
 export interface WorkflowGateEmitter {
-    isUnattended(): boolean;
+    supportsRemoteGateAnswers(): boolean;
     emitGate(input: OpenGateInput): Promise<unknown>;
     onGateEmitted?(listener: (gate: WorkflowGate) => void): () => void;
     resolveGate?(response: WorkflowGateResponse): Promise<WorkflowGateResolution>;
@@ -96,7 +96,7 @@ export interface WorkflowGateEmitter {
 export declare class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
     #private;
     constructor(runId: string, store: GateStore, emitterHooks?: Pick<BrokerHooks, "advance">);
-    isUnattended(): boolean;
+    supportsRemoteGateAnswers(): boolean;
     setRuntimeTurnProvider(provider: (() => string | undefined) | null): void;
     emitGate(input: OpenGateInput): Promise<unknown>;
     onGateEmitted(listener: (gate: WorkflowGate) => void): () => void;

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

@@ -27,6 +27,7 @@ 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 { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import type { ParsedIrcMessage } from "./utils/irc-message";
 export type TranscriptRebuildPolicy = "replace-identity" | "reconcile-same-transcript";
@@ -133,6 +134,8 @@ export interface InteractiveModeContext {
     skillCommands: Map<string, Skill>;
     oauthManualInput: OAuthManualInputManager;
     todoPhases: TodoPhase[];
+    /** Ghost-text next-prompt prediction; absent in ACP/lightweight test contexts. */
+    promptSuggestion?: PromptSuggestionController;
     init(): Promise<void>;
     shutdown(): Promise<void>;
     checkShutdownRequested(): Promise<void>;

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -1,5 +1,6 @@
 import type { KeybindingsManager } from "../../config/keybindings";
 export interface HotkeysMarkdownBindings {
-    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+    keybindings: Pick<KeybindingsManager, "formatAccessibleKeyHint" | "getAccessibleDisplayString">;
 }
+export declare function formatHotkeyMarkdownCode(label: string, escapeTablePipes?: boolean): string;
 export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

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

@@ -1,4 +1,4 @@
-import type { TSchema } from "@gajae-code/ai";
+import { type TSchema } from "@gajae-code/ai";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";

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

@@ -52,8 +52,3 @@ export declare class MCPOAuthFlow extends OAuthCallbackFlow {
     }>;
     exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials>;
 }
-/**
- * Refresh an MCP OAuth token using the standard refresh_token grant.
- * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
- */
-export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string): Promise<OAuthCredentials>;

package/dist/types/runtime-mcp/plugin-network-boundary.d.ts

@@ -0,0 +1,14 @@
+import { type AddressResolver } from "../web/insane/url-guard";
+import type { MCPHttpServerConfig, MCPSseServerConfig } from "./types";
+/** Mark an in-memory plugin-bundle remote MCP config for connection-bound public-network enforcement. */
+export declare function bindPluginMcpToPublicNetwork<T extends MCPHttpServerConfig | MCPSseServerConfig>(config: T): T;
+/** The marker is an internal symbol, so persisted user MCP configs cannot opt into or forge this path. */
+export declare function isPluginMcpPublicNetworkBound(config: MCPHttpServerConfig | MCPSseServerConfig): boolean;
+/**
+ * Fetch a plugin-bundle MCP request through a DNS-pinned public address. Every
+ * redirect is handled manually and revalidated before the next connection.
+ */
+export declare function fetchPluginMcpRequest(rawUrl: string, init: BunFetchRequestInit, options?: {
+    resolver?: AddressResolver;
+    maxRedirects?: number;
+}): Promise<Response>;

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

@@ -1,4 +1,5 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
+import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -93,6 +94,7 @@ export type BrokerResponse = {
     error: {
         code: BrokerErrorCode;
         message: string;
+        details?: ModelProfileErrorDetails;
         endpoint?: "unavailable";
         cleanup?: BrokerCleanupEvidence;
     };

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

@@ -9,7 +9,11 @@ export type ChatDaemonAction = "stop" | "reload";
  * 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`. Generation 8 adopts Windows expected-identity ACL verification and
- * repair for shared native authority.
+ * 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. */

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/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

@@ -24,7 +24,17 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * 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, and fail-closed blank-token validation plus lifecycle-startup
- * stop fencing in generation 18.
+ * 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 = 18;
+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. */