@songsid/agend 2.1.4-beta.2 → 2.1.4-beta.20

package/dist/fleet-manager.d.ts

@@ -36,6 +36,25 @@ export declare function selectLruEvictions(warm: string[], cap: number, opts: {
     isIdle: (name: string) => boolean;
     lastInboundAt: (name: string) => number;
 }): string[];
+/**
+ * Answer shape for `list_models`. `scope` reports where the LIST came from —
+ * "instance" only when it was read through that instance's own backend config,
+ * "global" for the account/CLI catalog — so a caller can tell an authoritative
+ * per-instance list from a best-effort account-wide one.
+ */
+export interface ModelCatalog {
+    backend: string;
+    scope: "instance" | "global";
+    /** Set whenever an instance was asked about, even if the list is global. */
+    instance?: string;
+    current_model: string | null;
+    models: import("./backend/types.js").ModelOption[];
+    /** "cache" = startup probe cache, "live" = probed now, "fallback" = none available. */
+    source: "cache" | "live" | "fallback";
+    probed_at?: string;
+    /** Caveat the caller should read before trusting the list. */
+    note?: string;
+}
 export interface DeliveryOptions {
     /** Explicitly identify agent-to-agent delivery when metadata is unavailable. */
     isCrossInstance?: boolean;
@@ -83,6 +102,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     costGuard: CostGuard | null;
     private statuslineWatcher;
     private dailySummary;
+    private dailyTipScheduler;
     private webhookEmitter;
     private topicIcons;
     private lastActivity;
@@ -94,6 +114,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private warmCapEvicting;
     /** Per-instance tail keeps cross-instance and scheduled deliveries FIFO. */
     private idleGatedDeliveryTails;
+    /**
+     * Per-instance cancellation epoch for deliveries which have not reached the
+     * daemon yet. A cancel advances the epoch; queued work captures the old value
+     * and becomes a no-op, while messages arriving after the click capture the new
+     * value and remain deliverable.
+     */
+    private deliveryEpochs;
     /** Non-user work must observe a fresh idle snapshot after the latest delivery. */
     private lastDeliveryAt;
     /** State-cache updates wake event-driven idle waiters without busy polling. */
@@ -106,6 +133,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     readonly replyDeduper: ReplyDeduper;
     /** instanceName → what it is doing right now, when the backend can tell us. */
     private instanceActivity;
+    /** instanceName → this turn's tool list (multi-line), for the bubble. */
+    private instanceProgress;
     /** instanceName → tail of deliveries waiting for its IPC to come back. */
     private ipcWaitTails;
     /** instanceName → restart currently executing; concurrent callers join it. */
@@ -119,8 +148,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     private pendingEffortSelects;
     private pendingModelSelects;
-    /** One-shot General assistance buttons for stable interactive terminal prompts. */
-    private pendingInteractivePromptAssists;
+    /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
+    private pendingNonceButtons;
     private failoverActive;
     /** instance → when a click with no live button entry last fired a cancel. */
     private staleCancelClickAt;
@@ -137,6 +166,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private healthServer;
     private healthPortRetried;
     private updateCheckTimer;
+    private updateProgressTimer;
+    private updateProgressEditRunning;
+    private lastUpdateProgressText;
+    private updateCompletionTipText;
     private eventLogPruneTimer;
     private logRotateTimer;
     /** Days of event/activity history to keep. */
@@ -218,6 +251,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private isModelAdmin;
     private handlePauseWakeSlash;
+    private handleUpdateSlash;
+    private handleTipsSlash;
     /** Admin-only full conversation reset for fleet-topic and Classic instances. */
     private handleClearSlash;
     /** Get the adapter bound to an instance, falling back to primary adapter */
@@ -248,6 +283,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     bindInstanceAdapter(name: string, adapterId: string, fromInbound?: boolean): void;
     getInstanceStatus(name: string): "running" | "paused" | "stopped" | "crashed";
     getInstanceExecutionState(name: string): InstanceState | null;
+    /**
+     * Subscription providers currently relevant to this fleet. Stopped/crashed
+     * rows do not keep a usage card alive, while persisted paused instances do.
+     * Classic channels use their effective backend merge chain, not the raw row.
+     */
+    getActiveUsageProviderIds(): ReadonlySet<string>;
     isClassicInstance(name: string): boolean;
     private cacheInstanceExecutionState;
     private cancelIdleButtonRetirement;
@@ -264,6 +305,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private enforceWarmCap;
     private waitForInstanceIdle;
+    /**
+     * Ask the daemon to capture the pane before answering, then wait for any state
+     * report produced after this request. The ordinary query is intentionally
+     * cache-only (idle gates call it frequently); this opt-in refresh is reserved
+     * for lifecycle decisions where a stale state would strand UI.
+     */
+    private refreshInstanceExecutionState;
     private deliverWithIdleGate;
     /**
      * Hand a payload to an instance's IPC, waiting out a *transient* disconnect.
@@ -331,6 +379,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         ready: boolean;
         token: string | null;
     };
+    beginUpdateProgress(adapter: ChannelAdapter, chatId: string, threadId: string | undefined, messageId: string): void;
+    failUpdateProgress(message: string): void;
+    /** The old fleet edits CLI install stages; the new fleet adopts the same message below. */
+    private startUpdateProgressMonitor;
     /** Start all instances from fleet config */
     startAll(configPath: string): Promise<void>;
     /**
@@ -437,6 +489,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private handleDecisionCrud;
     /** Resolve display name for an instance, fallback to instance name. */
     resolveDisplayName(instanceName: string): string;
+    /** Persist identity to the instance's actual config store. Classic instances
+     * are registry rows in classicBot.yaml, not fleet.yaml instance entries. */
+    private setInstanceDisplayName;
+    private setInstanceDescription;
     private handleSetDisplayName;
     private handleSetDescription;
     handleScheduleCrudHttp(instance: string, op: string, args: Record<string, unknown>): Promise<unknown>;
@@ -457,9 +513,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private startTopicCleanupPoller;
     /**
      * Patch only values changed in the effective config into the original YAML
-     * document. Unknown keys, explicit overrides and comments remain untouched.
+     * document. Unknown keys and comments remain untouched; redundant
+     * non-identity instance leaves are canonicalized to inheritance afterward.
      */
     saveFleetConfig(explicitPatches?: RawConfigPatch[]): void;
+    /** One-time upgrade migration; invalid YAML is never rewritten. */
+    private slimFleetConfigAtStartup;
+    private writeFleetConfigBackup;
     private patchFleetDocument;
     removeInstance(name: string): Promise<void>;
     startStatuslineWatcher(name: string): void;
@@ -532,6 +592,57 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private static readonly FLEET_ERROR_THROTTLE_MS;
     private fleetErrorNotices;
     notifyInstanceTopic(instanceName: string, text: string, extraOpts?: import("./channel/types.js").SendOpts): void;
+    /**
+     * Post decision buttons whose callback ids are `<prefix><nonce>:<action>`.
+     * The entry is registered before the send and rolled back if the send
+     * fails, so a nonce in the map always refers to a message that exists (or
+     * is about to). Returns the nonce, or null when the alert could not be sent.
+     */
+    private postNonceButtonPrompt;
+    /**
+     * Claim a nonce-armed callback exactly once.
+     *
+     * Returns:
+     *  - null       — the callback is not for this prefix; try the next handler
+     *  - "consumed" — for this prefix but stale/denied/malformed; stop dispatch
+     *  - the entry+action — the click is authorized and now claimed (removed
+     *    from the map before any await, so double clicks cannot act twice)
+     *
+     * A stale click (expired nonce, or a pre-upgrade button whose payload no
+     * longer parses) collapses the clicked message so the dead button stops
+     * inviting clicks — the same courtesy the cancel button extends.
+     */
+    private consumeNonceCallback;
+    /** Collapse a consumed prompt's buttons into a final status line. */
+    private retireNonceButtons;
+    private tipsEnabled;
+    private readTipState;
+    private pickAvailableTip;
+    private tipText;
+    private formatTip;
+    /** Post one fresh nonce-armed tip in a known General channel. */
+    promptTip(generalName: string, adapter: ChannelAdapter, chatId: string, threadId?: string): Promise<"posted" | "empty" | "unavailable">;
+    private promptAdvancedTipUnlock;
+    private sendTipToGeneral;
+    private handleTipDismiss;
+    private handleTipUnlock;
+    /** Post the destructive `/clear` confirmation in the invoking channel. */
+    promptClearConfirmation(instanceName: string, channelId: string, adapter: ChannelAdapter, chatId: string, threadId?: string): Promise<string | null>;
+    /** Consume `/clear` Confirm/Cancel exactly once; only Confirm reaches IPC. */
+    private handleClearConfirmation;
+    /**
+     * Drop every pending prompt that refers to an instance being stopped or
+     * restarted — a restart offer for an instance the operator just restarted
+     * (or an assist for one they stopped) must not stay clickable for the rest
+     * of its 15 minutes.
+     */
+    clearNoncePromptsForInstance(instanceName: string): void;
+    /** A clean exit is intentional from the CLI's perspective, but often not from
+     * the operator's. Keep the instance notice passive and put the action in the
+     * same-world General topic where an administrator can make the choice. */
+    notifyNormalExit(instanceName: string): Promise<void>;
+    /** Consume a clean-exit Restart/Ignore button exactly once. */
+    private handleExitRestartPrompt;
     private interactivePromptLabel;
     /**
      * Surface a stable terminal prompt in both places that matter:
@@ -542,7 +653,6 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * contain usernames or secret-adjacent text and stays in daemon.log.
      */
     notifyInteractivePrompt(instanceName: string, kind: string): Promise<void>;
-    private retireInteractivePromptButtons;
     /** Consume a General assist button exactly once. */
     private handleInteractivePromptAssist;
     /** Send a "🛑 Cancel" button to the instance's topic/channel after delivery. */
@@ -570,7 +680,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private handleCancelClick;
     private hasCancelButton;
-    sendCancelButton(instanceName: string, correlationId?: string): Promise<void>;
+    sendCancelButton(instanceName: string, correlationId?: string, preserveProgress?: boolean): Promise<void>;
     /**
      * The cancel button's text for a given elapsed time.
      *
@@ -580,6 +690,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * and once the agent had replied once there was no sign it was still going.
      */
     static progressText(elapsedMs: number, activity?: string | null, minElapsedMs?: number): string;
+    /** Render elapsed time consistently in live and retained progress bubbles. */
+    private static formatProgressElapsed;
+    /** Final read-only form of a bubble that contains semantic tool history.
+     * Neutral wording is intentional: the same retirement primitive is used for
+     * normal completion, a mid-turn bubble replacement, and user cancellation,
+     * so claiming every retained checkpoint is "completed" would be false. */
+    private composeRetiredBubbleText;
     /**
      * Make a tool summary safe to paste into a channel message.
      *
@@ -597,6 +714,26 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * never used to decide anything — purely what the user is shown.
      */
     private cacheInstanceActivity;
+    /**
+     * Cache the turn's tool-progress list and push it into the instance's live
+     * bubble, coalesced so a burst of tool events cannot flood the Bot API
+     * (Telegram's flood limit is per-chat across ALL forum topics, so edits are
+     * rate-limited per bubble AND ride behind the daemon-side 3s coalescer).
+     */
+    private cacheInstanceProgress;
+    /** At most one progress-driven edit per bubble per TOOL_PROGRESS_EDIT_MIN_MS. */
+    private scheduleProgressEdit;
+    /**
+     * The ONE composer for the bubble text. Both writers — the elapsed-time
+     * ticker and the tool-progress push — go through here; two independent
+     * renderers editing the same message is how the progress list used to get
+     * wiped by the next elapsed tick (#528 trap 2).
+     */
+    private composeBubbleText;
+    /** Pure composition of header + tool list, exposed for tests. */
+    static bubbleText(elapsedMs: number, activity: string | undefined, minElapsedMs: number, progress: string | undefined): string;
+    /** Recompose and edit the bubble in place; skips when nothing changed. */
+    private refreshBubble;
     /**
      * Refresh the button's text in place while the instance keeps working.
      *
@@ -609,10 +746,14 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private startProgressTicker;
     /**
      * After a reply: give the instance REPLY_RETIRE_GRACE_MS to resume working; if
-     * it has not, retire its button. Re-arming replaces the previous timer, so a
-     * burst of replies ends with exactly one pending check.
+     * it has not, retire its button. The daemon is asked for a fresh pane capture
+     * before deciding. Reading only the transition cache stranded the first
+     * post-restart bubble when its startup "working" report never got a matching
+     * idle edge. Re-arming replaces the previous timer, so a burst of replies ends
+     * with exactly one pending check.
      */
     private armReplyGrace;
+    private finishReplyGrace;
     /** Retire (delete) every cancel button belonging to an instance. */
     private retireInstanceButtons;
     /** Begin retiring one button (delete + bounded retry on failure). Idempotent:
@@ -637,7 +778,9 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private sweepOrphanedCancelButtons;
     /** Re-attempt a failed button delete up to CANCEL_BTN_MAX_RETRIES times. */
     private scheduleButtonRetry;
-    /** Delete one button's message via its own adapter. Resolves on success,
+    /** Retire one cancel bubble via its own adapter. A bubble that accumulated
+     * tool progress is kept as a read-only history message; a plain bubble keeps
+     * the legacy delete/edit-to-checkmark behavior. Resolves on success and
      * rejects on failure so the caller can retry. */
     private deleteButtonMessage;
     /** Retire all cancel buttons for an instance — on reply or cancel. */
@@ -661,6 +804,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private reactDone;
     /** Interrupt an instance's current generation (cancel button / /cancel). */
     cancelInstance(instanceName: string): boolean;
+    getDeliveryEpoch(instanceName: string): number;
+    private isDeliveryEpochCurrent;
+    /** Invalidate work queued before a user cancel and wake idle-gate waiters. */
+    private cancelPendingDeliveries;
     queueMirrorMessage(text: string): void;
     /** Push an SSE event to all connected Web UI clients. */
     emitSseEvent(event: string, data: unknown): void;
@@ -669,12 +816,57 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         title: string;
     }>;
     sendHangNotification(instanceName: string, unchangedForMs?: number): Promise<void>;
+    /**
+     * Consume a hang Force-restart / Keep-waiting button exactly once. Restart
+     * goes through restartSingleInstance — serialized against concurrent restart
+     * sources, and with a Classic-instance fallback (the previous hand-rolled
+     * stop+start silently left Classic instances stopped while reporting
+     * "restarted").
+     */
+    private handleHangPrompt;
     private static INSTRUCTIONS_FILENAME;
     private static GENERAL_INSTRUCTIONS;
     /** Ensure the general instance has its project instructions file + knowledge */
     private ensureGeneralInstructions;
-    /** Copy general-knowledge steering + skills to the general instance's workspace */
+    /** Resolve the workspace path a backend actually uses before publishing knowledge. */
+    private resolveKnowledgeWorkDir;
+    /**
+     * Where each backend natively loads on-demand skills from, relative to the
+     * workspace. Backends without a native skill mechanism (opencode, grok,
+     * antigravity, gemini-cli) are deliberately absent: dropping files a CLI
+     * never reads is clutter, not capability. Unknown directories are ignored
+     * by older CLI versions, so publishing is fail-open across upgrades.
+     */
+    private static SKILLS_DIR_SEGMENTS;
+    /** Copy general-knowledge steering + all role-eligible skills to General. */
     private syncGeneralKnowledge;
+    /** Publish only the bundled skills eligible for an instance role. */
+    private syncRoleSkills;
+    /**
+     * Steering (always-on rules like core-rules.md). Kiro loads a native
+     * steering directory; every other backend gets the content embedded into
+     * its instructions file (CLAUDE.md / AGENTS.md / …) inside a managed marker
+     * block — the previous behavior dropped bare .md files in the workspace
+     * root, which no CLI ever read. The block is replaced in place on every
+     * sync, so rule updates reach EXISTING workspaces; everything the user
+     * wrote outside the markers is preserved byte-for-byte.
+     */
+    private syncGeneralSteering;
+    private static STEERING_BLOCK_BEGIN;
+    private static STEERING_BLOCK_END;
+    /**
+     * Publish AgEnD's bundled skills into a CLI's native skills directory,
+     * owning ONLY what we published. A manifest records which skill names AgEnD
+     * wrote; a bundled rename/removal deletes the stale managed copy, while a
+     * skill the user created by hand is never listed and therefore never
+     * touched — even if a future bundle happens to reuse its name (the sync
+     * then skips it and logs, rather than overwrite the user's work). The sole
+     * migration exception is the pre-manifest Kiro General layout explicitly
+     * selected by adoptLegacyUnmanaged.
+     */
+    private syncManagedSkills;
+    /** Read AgEnD's roles extension from SKILL.md YAML frontmatter. */
+    private readManagedSkillRoles;
     /** Fetch forum topic icon stickers and pick emoji IDs for each state */
     private resolveTopicIcons;
     /** Set topic icon based on instance state */
@@ -717,6 +909,34 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private probeCliEnvs;
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     private getModelOptions;
+    /**
+     * Model catalog behind the `list_models` tool.
+     *
+     * The two scopes are not cosmetic. "global" is the account/CLI catalog served
+     * from the startup probe cache; "instance" is resolved through that instance's
+     * OWN backend config, and for a Codex instance on a custom provider that is a
+     * different catalog entirely — `listModels()` reads models_cache.json out of
+     * the instance's private CODEX_HOME. Answering such an instance with the
+     * account list would name models its CLI rejects, which is exactly the
+     * mistake this tool exists to prevent.
+     *
+     * `scope` always describes where the returned LIST came from, not what was
+     * asked for: an instance query that falls back to the account catalog reports
+     * scope "global" and says so in `note`, rather than implying instance-level
+     * accuracy it does not have.
+     *
+     * Never throws — a model listing is an aid, and failing it must not fail a turn.
+     */
+    listModelCatalog(opts?: {
+        backend?: string;
+        instanceName?: string;
+    }): Promise<ModelCatalog>;
+    /** The custom provider an instance overrides its backend with, if any. */
+    private customProviderFor;
+    /** Ask a backend for its catalog using ONE instance's real config. Never throws. */
+    private instanceScopedModels;
+    /** Account-wide catalog: probe cache first, live probe on miss. */
+    private globalModelCatalog;
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
     /** Label an effort choice, marking the one currently configured. */
     private effortChoiceLabel;
@@ -821,7 +1041,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /**
      * Hot-reload: re-read fleet.yaml and reconcile running instances.
      * Starts new, stops removed, restarts modified instances.
-     * Fleet-level config (access, cost_guard, etc.) requires /restart to take effect.
+     * Whitelisted runtime fields are pushed into live daemons; all other instance
+     * fields, plus cold fleet-level settings, retain restart semantics.
      */
     private reconcileInstances;
     restartInstances(): Promise<void>;