@songsid/agend 2.2.0-beta.4 → 2.2.0-beta.6

package/dist/fleet-context.d.ts

@@ -105,7 +105,10 @@ export interface FleetContext {
     getInstanceAdapterId?(instanceName: string): string | undefined;
     changeInstancePauseState(name: string, action: "pause" | "wake"): Promise<"paused" | "awake" | "not_idle">;
     startInstance(name: string, config: InstanceConfig, topicMode: boolean): Promise<void>;
-    stopInstance(name: string): Promise<void>;
+    /** #1716: resolves whether the stop ended background work that was running. */
+    stopInstance(name: string): Promise<{
+        backgroundWorkEnded: boolean;
+    }>;
     connectIpcToInstance(name: string): Promise<void>;
     saveFleetConfig(): void;
     getInstanceDir(name: string): string;

package/dist/fleet-manager.d.ts

@@ -51,6 +51,7 @@ export declare function applyTaskListCap<T extends {
     omitted: number;
     hint: string;
 } | T[];
+import { type PublicPreviewForUi } from "./web-api.js";
 import { WebChatHistory } from "./web-chat-history.js";
 import { SeenUsers, type MentionNames, type MentionQuery } from "./web-mentions.js";
 import { WebPrefsStore } from "./web-prefs.js";
@@ -74,6 +75,7 @@ import { type PreviewAvailability } from "./web-preview.js";
 import { type ConnectionMetadata, type ConnectionBinding, type BindingProbe, type SecretApplyJob, type ProviderSecretApplyJob } from "./connection-secrets.js";
 import { type ProviderSecretStatus } from "./provider-secret-registry.js";
 import { ApplyJobStore, type ApplyJob, type ApplyTargetKind, type SelfRestartResult } from "./apply-job.js";
+import { type CarryResult } from "./backend/claude-carry.js";
 import { StormWindow } from "./storm-window.js";
 import { SpawnGate } from "./spawn-gate.js";
 import { BackendOutageTracker } from "./backend-outage.js";
@@ -101,6 +103,17 @@ export declare function selectLruEvictions(warm: string[], cap: number, opts: {
  * must match here, or a deleted instance's CLI is left running (#1305 P2-3).
  */
 export declare function isOrphanInstanceWindowName(name: string): boolean;
+/** restartSingleInstance's options. `carry` (#1753): a credential-profile switch; its outcome is written into `result`. */
+export interface RestartOpts {
+    freshStart?: boolean;
+    explicit?: boolean;
+    carry?: {
+        backend: string;
+        from: string | null;
+        to: string | null;
+        result?: CarryResult | null;
+    };
+}
 /**
  * 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,
@@ -304,6 +317,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private webChannelEchoGuards;
     /** instanceName → restart currently executing; concurrent callers join it. */
     private restartsInFlight;
+    /**
+     * #1753: each in-flight restart's stop → start gap — the conversation carry it will run there (its own, or one a later
+     * caller joined with before the gap), and whether the gap has been reached.
+     */
+    private readonly restartGaps;
     /**
      * Delayed automatic retries for instances whose startup failed. Before this a
      * failed start was logged once and the instance stayed `stopped` until an
@@ -402,6 +420,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private connectionBindingInFlight;
     private collabInstances;
     private healthServer;
+    private healthServerDrain;
     /** #1306: the preview listener (health_port + 1 by default), and whether it is listening. */
     private previewListener;
     private previewListening;
@@ -414,6 +433,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private updateProgressEditRunning;
     private lastUpdateProgressText;
     private updateCompletionTipText;
+    /**
+     * #1660: an adopted update whose retire outcome is still owed. The
+     * completion summary was (or will be) posted; this watch appends the
+     * cleanup outcome to the same receipt instead of letting stage edits
+     * clobber it — and refuses a receipt that no longer matches (checklist 3/5).
+     */
+    private updateCleanupWatch;
     /** Injectable only to keep the chat→CLI reload hand-off deterministic in tests. */
     private fullRestartLauncher;
     private eventLogPruneTimer;
@@ -602,6 +628,18 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     isPlannedRestart(): boolean;
     private finishStartup;
+    /**
+     * We are the post-update fleet: the update is over by definition. Clearing it here (rather than in the update
+     * command, which exits before the new fleet is up) is what keeps the quiet window from outliving the restart.
+     * #1660 exception: an update still owing its retire outcome keeps its receipt until the cleanup watch resolves it —
+     * deleting it here is what lost the warning. Terminal stages are still cleared unconditionally.
+     * #1735: and while the watch is armed it owns the marker — even if the outcome landed after the completion posted
+     * (a launchd kickstart or a detached restart returns at once, so it can land at any point of the boot): the watch
+     * appends it, then clears.
+     * #1737 review: and only the marker this boot adopted. One written since — a `/restart full` or a new `/update`
+     * landing while this boot's completion was still being edited — belongs to its writer and is left alone.
+     */
+    private clearSettledUpdateMarker;
     lastActivityMs(name: string): number;
     /** Capture the current daemon and delivery owner for a background context read. */
     getPaneContextSource(name: string): import("./pane-context-cache.js").PaneContextSource | null;
@@ -1097,12 +1135,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Last-resort completion after RestartProgress could not deliver to its
      * adopted target. It stays bounded and never wakes a not-ready gateway. */
     private sendFleetStartCompletionFallback;
-    stopInstance(name: string, transition?: TransitionHandle): Promise<void>;
+    stopInstance(name: string, transition?: TransitionHandle): Promise<{
+        backgroundWorkEnded: boolean;
+    }>;
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
-    restartSingleInstance(name: string, opts?: {
-        freshStart?: boolean;
-        explicit?: boolean;
-    }): Promise<void>;
+    restartSingleInstance(name: string, opts?: RestartOpts): Promise<void>;
     isInstanceRestarting(name: string): boolean;
     /** InstanceLifecycleContext: an explicit wake joins the restart in flight. */
     restartInFlight(name: string): Promise<void> | undefined;
@@ -1123,6 +1160,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * One-shot: the daemon deletes it on startup.
      */
     private writeFreshStartMarker;
+    /**
+     * #1753: a credential-profile switch, between the old CLI's stop and the new one's start. Where the backend can take
+     * the conversation along (claude-code), copy it into the new profile and make it the one `--continue` picks; when that
+     * cannot be done, or the backend cannot, start fresh as before. Null when nothing was tried.
+     */
+    private switchConversation;
     /** Load .env file from data dir into process.env */
     private loadEnvFile;
     /** Initialize auth before any adapter can answer /dashboard. */
@@ -1138,11 +1181,31 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         ttlMinutes: number;
     } | null;
     private tunnelPurposeLane;
+    private previewTunnel;
     private publicWebLink;
+    /** #1723: the public link's preview tunnel — a manager and lease of its own, never the fleet's one tunnel lane. */
+    private getPreviewTunnel;
     private getTunnelLane;
     private publicOwnerCurrent;
     /** Exact owning General. No primary-adapter or name fallback participates in authorization. */
     private dashboardOwner;
+    /**
+     * #1742: the General a fleet admin's DM speaks for (`/start web`): the same owner `/web` in that General would make
+     * — this bot's configured group and its one General topic. No address to match in a DM, so it must be unambiguous:
+     * no General, or more than one on this bot and group, and there is no owner (nothing is guessed).
+     */
+    private dmDashboardOwner;
+    /**
+     * #1742: a fleet admin whose Telegram `/web` could not reach them privately may next open the bot's DM and press
+     * Telegram's START, which sends a bare `/start` — read as `/start web` (the DM menu) for 10 minutes, once, for that
+     * admin on that bot. Monotonic: a wall-clock jump neither opens nor shuts it.
+     */
+    private readonly tgWebStartWindows;
+    private openTgWebStartWindow;
+    /** Uses the window up: true when it was open. */
+    private takeTgWebStartWindow;
+    /** #1742: `/start web` from a fleet admin: the /web menu right here in the DM, for the General this bot serves. */
+    private startWebInDm;
     private getPublicWebLink;
     getPublicWebStatus(): {
         state: string;
@@ -1180,6 +1243,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Why the DM did not go, for the log only (Discord 50007 = the user does not accept DMs from this server's members). */
     private logDashboardDmFailure;
     /** False when the menu was not shown (the caller still owes the user an answer). */
+    /**
+     * `dmChatId` (#1742): show it in the owner's own private chat with the bot instead of the General — the owner, its
+     * gates and the code's route are the same; only where the menu sits (and its clicks are good) changes.
+     */
     private showDashboardMenu;
     private handleDashboardCallback;
     /** `/dashboard revoke`: sign out every browser and withdraw any unused code. */
@@ -1232,6 +1299,36 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private reportFullRestartFailure;
     failUpdateProgress(message: string): void;
     /** The old fleet edits CLI install stages; the new fleet adopts the same message below. */
+    /**
+     * #1660: arm the post-completion cleanup watch and make sure its monitor
+     * actually runs. The new fleet adopts the receipt at boot but nothing else
+     * starts this timer on that path (Prism a) — without this, the owed
+     * outcome would sit in the marker unwatched. READY never waits for it.
+     */
+    /**
+     * #1735: what the completion of an adopted update does about its retire outcome, read from the marker as it is now.
+     * Already landed with a warning (a detached restart returns before this fleet boots, so the updater retires first)
+     * → render it in the completion. Still owed (`cleanup: "pending"` — a service restart waits for READY, which comes
+     * after the completion) → watch for it. Anything else (no retire on this update, done silently, another receipt)
+     * → nothing.
+     */
+    /**
+     * #1716: background work this restart/update ended, scoped to the operation
+     * so an older stop never reports (`sinceAt` null = plain boot, report
+     * nothing). A method — not a module function — because the #1737
+     * extracted-completion harness runs this region verbatim with only
+     * `this`-methods plus a fixed context.
+     */
+    private collectBackgroundWorkEndedNames;
+    private updateCleanupAtCompletion;
+    private armCleanupWatch;
+    /**
+     * #1660: append a recorded cleanup outcome to the adopted update message,
+     * then release the receipt — but only if this receipt still owns the
+     * marker. The await yields, so a newer receipt (e.g. a full-restart that
+     * landed mid-edit) must not be cleared or disturbed (Prism b).
+     */
+    private appendCleanupWarning;
     private startUpdateProgressMonitor;
     /** Start all instances from fleet config */
     startAll(configPath: string): Promise<void>;
@@ -1436,6 +1533,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private resolveInboundTarget;
     private handleInboundMessage;
+    /**
+     * #1752: the bot that speaks back about an inbound message — in a fleet topic the owning instance's adapter, never
+     * the sibling that happened to win the dedup race; elsewhere (ClassicBot rooms, no routed instance) the receiver.
+     */
+    private inboundNoticeAdapter;
     private handleInboundMessageCore;
     /** Handle outbound tool calls from a daemon instance */
     /** Warn (but don't block) when rate limits are high. 30-min debounce per instance. */
@@ -3121,6 +3223,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     previewForUi(hostHeader: string | undefined, secure: boolean): PreviewAvailability & {
         boot: string | null;
     };
+    /**
+     * #1723: for one page of the public link (exposure `exposureId`, at `dashboardOrigin`): its own preview tunnel's
+     * origin once up, "starting" until then, why it failed if it did — or a configured web.preview_origin, used instead.
+     */
+    publicPreviewForUi(exposureId: string, dashboardOrigin: string): PublicPreviewForUi;
     getUiStatus(): unknown;
     private getUiStatusSync;
 }