@songsid/agend 2.1.4-beta.3 → 2.1.4-beta.30

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. */
@@ -140,6 +169,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private updateProgressTimer;
     private updateProgressEditRunning;
     private lastUpdateProgressText;
+    private updateCompletionTipText;
     private eventLogPruneTimer;
     private logRotateTimer;
     /** Days of event/activity history to keep. */
@@ -222,6 +252,7 @@ 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 */
@@ -252,6 +283,14 @@ 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>;
+    /** Effective backends with a running or persisted-paused fleet/Classic instance. */
+    getActiveBackendIds(): ReadonlySet<string>;
     isClassicInstance(name: string): boolean;
     private cacheInstanceExecutionState;
     private cancelIdleButtonRetirement;
@@ -268,6 +307,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.
@@ -445,6 +491,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>;
@@ -465,9 +515,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;
@@ -548,13 +602,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private postNonceButtonPrompt;
     /**
-     * Claim a nonce-armed callback exactly once.
+     * Validate a nonce-armed callback and claim it 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)
+     *  - the entry+action — the click is authorized and claimed before any await
      *
      * A stale click (expired nonce, or a pre-upgrade button whose payload no
      * longer parses) collapses the clicked message so the dead button stops
@@ -563,6 +616,23 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     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;
+    /** Persistently enable advanced tips through the admin-only slash command. */
+    unlockAdvancedTips(userId: string): boolean;
+    /** 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
@@ -613,7 +683,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.
      *
@@ -623,6 +693,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.
      *
@@ -640,6 +717,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.
      *
@@ -652,10 +749,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:
@@ -680,7 +781,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. */
@@ -704,6 +807,74 @@ 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;
+    private activeLogin;
+    /** Post the backend chooser for a bare `/login`. Caller enforces admin. */
+    promptLoginBackends(chat: {
+        adapter: ChannelAdapter;
+        adapterId: string;
+        chatId: string;
+        threadId?: string;
+    }): Promise<void>;
+    /**
+     * Start a login session for one backend. Caller enforces admin.
+     * Returns a status line to post, or null when a confirmation prompt was
+     * posted instead (auth still valid — see the pre-check below).
+     */
+    startLoginSession(backendArg: string, chat: {
+        adapter: ChannelAdapter;
+        adapterId: string;
+        chatId: string;
+        threadId?: string;
+    }, opts?: {
+        skipAuthCheck?: boolean;
+    }): Promise<string | null>;
+    /** Create the login window and session (pre-check already settled). */
+    private launchLoginSession;
+    /** `/login code <text>` — paste admin-supplied text into the login window. */
+    loginSubmitInput(text: string): Promise<string>;
+    /** `/login cancel` — abort the active session and remove its window. */
+    cancelLoginSession(): Promise<string>;
+    /**
+     * The URL (+ code) is a live credential: whoever completes it binds THEIR
+     * account to this fleet's CLI. Telegram gets an HTML spoiler (same treatment
+     * as the dashboard token); other adapters get plain text with the warning.
+     */
+    private sendLoginSecret;
+    /**
+     * After a successful login: wake the paused instances of that backend AND
+     * restart the running ones — a live CLI holds the old token in memory and
+     * only re-reads credentials on process start (a paused instance's CLI is
+     * already dead, so waking it respawns with the new token for free).
+     */
+    private recoverBackendInstances;
+    /** Backend chooser button → start that backend's login session. */
+    private handleLoginBackendSelect;
+    /** Re-login confirmation (auth pre-check said credentials still work). */
+    private handleLoginConfirm;
+    /** Kiro provider button → drive the CLI's arrow-key selector. */
+    private handleLoginMenuSelect;
+    private activeInstall;
+    /** Start a CLI install session. Caller enforces admin. */
+    startInstallSession(backendArg: string, chat: {
+        adapter: ChannelAdapter;
+        adapterId: string;
+        chatId: string;
+        threadId?: string;
+    }): Promise<string>;
+    /** `/install-cli cancel` — abort the active install and remove its window. */
+    cancelInstallSession(): Promise<string>;
+    /** `command -v` on a login shell, so PATH additions from rc files count. */
+    private verifyBinaryOnLoginShell;
+    /** "Sign in now?" button after a successful install. */
+    private handleInstallLoginConfirm;
+    /** Discord native `/login` slash — shared by every adapter dispatch block. */
+    private handleLoginSlash;
+    /** Discord native `/install-cli` slash — shared by every dispatch block. */
+    private handleInstallCliSlash;
     queueMirrorMessage(text: string): void;
     /** Push an SSE event to all connected Web UI clients. */
     emitSseEvent(event: string, data: unknown): void;
@@ -724,8 +895,45 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     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 */
@@ -768,6 +976,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;
@@ -872,7 +1108,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>;