crewly 1.20.171 → 1.20.173

package/dist/cli/backend/src/services/harness/harness-relogin.service.d.ts

@@ -1,47 +1,51 @@
 /**
- * Harness re-login coordinator — Phase 2 of onboarding: re-login over Slack.
+ * Harness re-login coordinator — re-login from the owner's phone, with no
+ * agent involved.
  *
- * When a harness login expires, Crewly notices by itself, starts ONE login
- * broker session for that harness, DMs the owner what to do on their phone,
- * and resumes the agents that were stuck once the login succeeds. Nobody
- * has to touch the machine.
+ * The instance backend (never an agent: every agent may be stuck on the very
+ * login that expired) notices that a harness's login is gone, tells the owner
+ * once, runs the harness's login itself when the owner replies, relays the
+ * link and the code, and brings the agents back with the messages that
+ * waited for them.
  *
- * Inputs:
- * - {@link HarnessReloginService.reportExpiry} — called by the OAuth
- *   re-login monitor when an agent's terminal output matches an expiry rule
- *   (login-expiry-rules.ts), and by the periodic status check of the
- *   orchestrator's harness ({@link HarnessReloginService.checkOrcHarness}).
- * - {@link HarnessReloginService.handleOwnerReply} — an owner's Slack DM
- *   reply. A reply is consumed only when it belongs to a flow: Claude's
- *   authorization code (while Claude's login is waiting for it and the reply
- *   looks like a code), the retry keyword, or a reply to an unrecognised
- *   login screen. Everything else goes through the normal chat path.
- * - The broker's `update` / `finished` events.
- * - {@link HarnessReloginService.startOwnerLogin} — the owner asked for a
- *   login: 「重新登录 claude」 in the orc DM (parsed by
- *   {@link HarnessReloginService.handleOwnerReply}, no LLM involved) or the
- *   orchestrator's `harness-login` skill. Such a flow is *forced*: it runs
- *   even when the harness is still logged in (switching accounts), skips the
- *   silent API-key path, and answers in the conversation it was asked in.
+ * Flow per harness (at most one at a time):
  *
- * Rules:
- * - One flow per harness. Repeated detections only add stuck sessions. A
- *   flow that failed is followed up by a new detection at most once per
- *   {@link HARNESS_CONSTANTS.RELOGIN.REMIND_INTERVAL_MS} (the re-reminder),
- *   or restarted at once when the owner replies `relogin` / `重新登录`.
- *   When the last link simply expired unused (`timed_out`), the reminder is
- *   a text DM asking the owner to reply when they are ready — it does NOT
- *   start a new login: a device code lives 15 minutes, so a link sent while
- *   the owner is away is wasted, and `codex login` revokes whatever
- *   credentials exist when it starts (steamfun-ops 2026-09-30: five links at
- *   night, all expired unused).
- * - A login is started only when the harness's own status says
- *   `logged_out`; `unknown` is not enough, for the same revocation reason.
- * - If Crewly holds an API key for the harness it is used silently (no DM).
- * - Claude → `subscription` (`claude setup-token`), Codex → `device`.
- * - Secrets: Claude's code is passed to the broker and never stored, logged
- *   or echoed; DMs are built from {@link LoginSession} snapshots, which never
- *   contain a token, and the screen text is redacted again.
+ * 1. **Detect.** {@link HarnessReloginService.reportExpiry} — an agent's
+ *    output or screen matched an expiry rule (login-expiry-rules.ts, via the
+ *    OAuth re-login monitor), or the periodic check
+ *    ({@link HarnessReloginService.checkHarnesses}) found a harness in use
+ *    signed out. The periodic check covers every harness the orchestrator or
+ *    a team member is configured on, so it works with zero agents running.
+ * 2. **Confirm.** The harness's status command, then — because Claude Code's
+ *    stored credential survives an expiry — a live probe
+ *    (harness-login-probe.ts). Only a confirmed `logged_out` goes on;
+ *    `unknown` never does (`codex login` revokes a working login).
+ * 3. **Tell the owner once.** A stored API key is used silently if Crewly has
+ *    one. Otherwise one DM — "Claude Code on <machine> is signed out, so N
+ *    agents can't work. Reply `login` …" — then re-reminders with backoff
+ *    (3 h, doubling, 24 h cap), persisted so restarts do not re-send it. No
+ *    login is started yet: a link sent while the owner is away expires unused.
+ * 4. **The owner replies `login`** (or 「重新登录」, `relogin claude`, …) in
+ *    the DM. The Slack bridge offers owner DMs to
+ *    {@link HarnessReloginService.handleOwnerReply} before anything else, so
+ *    this works with no agent awake. The login broker runs the harness's
+ *    login in its own PTY (`claude setup-token` / `codex login --device-auth`)
+ *    and the link (and Codex's one-time code) is sent back.
+ * 5. **The code.** For Claude the owner replies with the code from the page;
+ *    it is typed into the waiting login. A rejected code is reported once; an
+ *    expired link puts the flow back to "signed out" ("reply `login` for a
+ *    new link").
+ * 6. **Success** is confirmed with the probe, then the stuck agents are
+ *    restarted (conversation resumed) and the owner messages that waited are
+ *    re-delivered ({@link HarnessReloginDeps.onLoginRestored}). One DM says so.
+ *
+ * Owner-requested logins ({@link HarnessReloginService.startOwnerLogin}:
+ * 「重新登录 claude」 / "relogin codex" / the orchestrator's `harness-login`
+ * skill) start the broker at once, even while logged in (account switch).
+ *
+ * Secrets: Claude's code is passed to the broker and never stored, logged
+ * or echoed; DMs are built from {@link LoginSession} snapshots, which never
+ * contain a token, and the screen text is redacted again.
  *
  * @module services/harness/harness-relogin.service
  */
@@ -49,6 +53,7 @@ import type { HarnessApiKeyService } from './harness-api-key.service.js';
 import { type HarnessCredentialsStore } from './harness-credentials.store.js';
 import { type HarnessId, type HarnessLogger, type LoginSession, type LoginState, type ReloginPending } from './harness.types.js';
 import { type LoginBrokerService } from './login-broker.service.js';
+import { type ReloginStateStore } from './relogin-state.store.js';
 /** Where an expiry report came from. */
 export type ExpirySource = 'output' | 'screen' | 'status';
 /** An expired-login report. */
@@ -58,31 +63,35 @@ export interface ExpiryReport {
     sessionName: string | null;
     /**
      * `output`: a live PTY chunk; `screen`: the periodic screen sweep (may show
-     * old scrollback); `status`: the harness's own status command
+     * old scrollback); `status`: the harness's own status command or probe
      */
     source: ExpirySource;
 }
 /**
- * Where an owner-requested login answers: the Slack conversation (and thread)
- * the owner asked in. `agentSession` is set when that conversation is a DM
- * with an agent's own bot (the orc's "Crewly Orc" app), whose token must be
- * used to post there.
+ * A Slack conversation (and thread) to answer in. `agentSession` is set when
+ * that conversation is a DM with an agent's own bot (the orc's "Crewly Orc"
+ * app), whose token must be used to post there.
  */
 export interface ReloginReplyTarget {
     channelId: string;
     threadTs?: string;
     agentSession?: string;
 }
+/**
+ * Result of a DM: false when nothing was delivered; true, or the
+ * conversation it landed in (so a code reply can be matched to it).
+ */
+export type ReloginDelivery = boolean | ReloginReplyTarget;
 /** Sends a Slack DM to the owner. */
 export interface ReloginOwnerNotifier {
     /**
      * Send a DM to the owner.
      *
      * @param text - Slack mrkdwn text (never contains a secret)
-     * @param target - Conversation to answer in; absent = the owner's DM with the master bot
-     * @returns True when delivered
+     * @param target - Conversation to answer in; absent = this machine's own DM with the owner
+     * @returns Where it was delivered (or true), false when it was not
      */
-    sendToOwner(text: string, target?: ReloginReplyTarget | null): Promise<boolean>;
+    sendToOwner(text: string, target?: ReloginReplyTarget | null): Promise<ReloginDelivery>;
     /**
      * Whether a DM can be sent right now (Slack connected).
      *
@@ -92,11 +101,13 @@ export interface ReloginOwnerNotifier {
 }
 /** What started a flow. */
 export type ReloginTrigger = 'expiry' | 'owner';
+/** Where an owner reply was written: the orc's / master DM, or another agent's bot DM. */
+export type OwnerReplyScope = 'orc' | 'agent';
 /** Options of an owner-requested login. */
 export interface OwnerLoginOptions {
     /** The owner wants a different account (only changes the wording) */
     switchAccount?: boolean;
-    /** Conversation to answer in (null = the owner's master-bot DM) */
+    /** Conversation to answer in (null = this machine's DM with the owner) */
     replyTarget?: ReloginReplyTarget | null;
     /** Who relayed the request, for logs */
     requestedBy: 'owner_dm' | 'orchestrator';
@@ -114,7 +125,7 @@ export interface OwnerLoginUnsupported {
     /** The harness has no link login (Antigravity: API key; Gemini: enterprise only) */
     status: 'no_broker_login';
     harnessId: HarnessId;
-    /** What to tell the owner, in Chinese */
+    /** What to tell the owner */
     message: string;
 }
 /** Result of {@link HarnessReloginService.startOwnerLogin}. */
@@ -139,6 +150,14 @@ export interface ReloginAgentResumer {
         failed: string[];
     }>;
 }
+/** An agent configured on this machine (running or not). */
+export interface ConfiguredAgent {
+    sessionName: string;
+    /** Runtime type (= harness id for the harnesses Crewly can log in) */
+    harnessId: string;
+    /** Name the owner knows ("Ella") */
+    displayName?: string;
+}
 /** The slice of the login broker the coordinator uses. */
 export type ReloginBroker = Pick<LoginBrokerService, 'start' | 'get' | 'input' | 'cancel' | 'on'>;
 /** Injectable dependencies. */
@@ -146,15 +165,40 @@ export interface HarnessReloginDeps {
     broker: ReloginBroker;
     credentials: Pick<HarnessCredentialsStore, 'read' | 'getClaudeCredentialKind'>;
     apiKeys: Pick<HarnessApiKeyService, 'submit'>;
-    /** The harness's login state from its own status command */
+    /** The harness's login state from its own status command (cheap; a stored Claude credential reads as logged in) */
     checkLoginState: (harnessId: HarnessId) => Promise<LoginState>;
+    /**
+     * Live sign-in probe (harness-login-probe.ts): `logged_out` / `logged_in`
+     * when it could tell, `unknown` otherwise. Absent = status only.
+     */
+    verifyLogin?: (harnessId: HarnessId) => Promise<LoginState>;
     /** The orchestrator's harness (null before setup recorded one) */
     getOrcHarness: () => Promise<string | null>;
+    /** Every agent configured on this machine, running or not (orc included) */
+    listAgents?: () => Promise<ConfiguredAgent[]>;
+    /** Whether a live agent session is sitting at a sign-in screen (OAuth monitor flag) */
+    sessionNeedsLogin?: (sessionName: string) => boolean;
+    /**
+     * After a login came back and the agents were restarted: re-deliver what
+     * waited for them (owner-message watchdog). Returns how many messages.
+     */
+    onLoginRestored?: (harnessId: HarnessId, resumed: readonly string[]) => Promise<number> | number;
+    /** This machine's name, for the owner ("iriss-air.lan") */
+    machineName?: () => string;
+    /** Persisted notice / backoff state */
+    state?: ReloginStateStore;
     notifier?: ReloginOwnerNotifier | null;
     resumer?: ReloginAgentResumer | null;
     now?: () => number;
     logger?: HarnessLogger;
 }
+/**
+ * The word the owner types after `relogin` for a harness.
+ *
+ * @param harnessId - Harness id
+ * @returns e.g. "claude"
+ */
+export declare function harnessCommandWord(harnessId: HarnessId): string;
 /**
  * Whether a reply asks to start the login over.
  *
@@ -162,6 +206,19 @@ export interface HarnessReloginDeps {
  * @returns True for `relogin`, `re-login` or `重新登录`
  */
 export declare function isRetryKeyword(text: string): boolean;
+/**
+ * Whether a bare reply asks to sign in (`login`, `sign in`, 「登录」, the retry keywords).
+ *
+ * @param text - Owner reply
+ * @returns True when the whole reply is a login keyword
+ *
+ * @example
+ * ```ts
+ * isLoginKeyword('Login!'); // true
+ * isLoginKeyword('login to gmail'); // false
+ * ```
+ */
+export declare function isLoginKeyword(text: string): boolean;
 /**
  * Strip formatting Slack clients add around a pasted value (backticks).
  *
@@ -178,10 +235,10 @@ export declare function unwrapReply(text: string): string;
  */
 export declare function looksLikeAuthCode(text: string): boolean;
 /**
- * "2 agents are waiting: a, b" — capped list of waiting agents.
+ * "Ella, Rex and 3 more" — capped list of agent names.
  *
- * @param agents - Session names
- * @returns Sentence fragment
+ * @param agents - Agent names
+ * @returns List text ('' when empty)
  */
 export declare function describeWaitingAgents(agents: readonly string[]): string;
 /**
@@ -191,37 +248,55 @@ export declare function describeWaitingAgents(agents: readonly string[]): string
  */
 export declare const SCREEN_REPLY_PREFIXES: readonly ["输入", "input"];
 /**
- * The text after a screen-reply prefix ("输入 1" → "1"), or null.
+ * The text after a screen-reply prefix ("input 1" → "1"), or null.
  *
  * @param reply - Owner reply (already unwrapped)
  * @returns Text to type, or null when the reply has no prefix
  */
 export declare function stripScreenReplyPrefix(reply: string): string | null;
-/** How a DM introduces the login. */
+/** How a link DM introduces the login. */
 export interface LoginDmWording {
-    /** The owner asked for this login (not an expiry) */
+    /** The owner asked for this login (not an expiry) — kept for callers; the header is the same */
     ownerRequested?: boolean;
     /** The owner asked for a different account */
     switchAccount?: boolean;
+    /** This machine's name */
+    machine?: string;
 }
+/**
+ * The first "signed out" DM, a re-reminder, or the note after a link expired unused.
+ *
+ * @param harnessId - Harness
+ * @param machine - This machine's name
+ * @param agents - Names of the agents that run on it
+ * @param kind - `notice` (first), `reminder`, or `link_expired`
+ * @returns Slack mrkdwn text
+ *
+ * @example
+ * ```ts
+ * formatSignedOutDm('claude-code', 'iriss-air.lan', ['Ella', 'Rex'], 'notice');
+ * // "*Claude Code on iriss-air.lan is signed out*, so 2 agents can't work (Ella, Rex).\nReply `login` …"
+ * ```
+ */
+export declare function formatSignedOutDm(harnessId: HarnessId, machine: string, agents: readonly string[], kind?: 'notice' | 'reminder' | 'link_expired'): string;
 /**
  * DM with the sign-in link (and Codex's one-time code on its own line).
  *
  * @param session - Broker session (never contains a secret)
- * @param waiting - Agents waiting on the login
- * @param wording - Owner-requested / account-switch wording (default: expiry)
+ * @param _waiting - Agents waiting on the login (unused; kept for callers)
+ * @param wording - Account switch / machine
  * @returns Slack mrkdwn text
  */
-export declare function formatLinkDm(session: LoginSession, waiting: readonly string[], wording?: LoginDmWording): string;
+export declare function formatLinkDm(session: LoginSession, _waiting?: readonly string[], wording?: LoginDmWording): string;
 /**
  * DM for a login screen the broker did not recognise.
  *
  * @param session - Broker session
- * @param waiting - Agents waiting on the login
- * @param wording - Owner-requested / account-switch wording (default: expiry)
+ * @param _waiting - Agents waiting on the login (unused; kept for callers)
+ * @param wording - Account switch / machine
  * @returns Slack mrkdwn text
  */
-export declare function formatScreenDm(session: LoginSession, waiting: readonly string[], wording?: LoginDmWording): string;
+export declare function formatScreenDm(session: LoginSession, _waiting?: readonly string[], wording?: LoginDmWording): string;
 /**
  * DM after the harness rejected the owner's reply (e.g. a wrong code).
  *
@@ -230,27 +305,30 @@ export declare function formatScreenDm(session: LoginSession, waiting: readonly
  */
 export declare function formatRejectedDm(session: LoginSession): string;
 /**
- * DM after the login succeeded and the agents were restarted.
+ * DM after a login came back and the agents were restarted.
  *
  * @param harnessId - Harness
  * @param result - Resume result
+ * @param redelivered - Owner messages re-delivered to them
+ * @param machine - This machine's name
  * @returns Slack mrkdwn text
  */
 export declare function formatSuccessDm(harnessId: HarnessId, result: {
     resumed: string[];
     failed: string[];
-}): string;
+}, redelivered?: number, machine?: string): string;
 /**
  * One-line DM after an owner-requested login succeeded.
  *
  * @param harnessId - Harness
  * @param result - Which agents were restarted onto the new login
+ * @param redelivered - Owner messages re-delivered to them
  * @returns Slack mrkdwn text
  */
 export declare function formatOwnerSuccessDm(harnessId: HarnessId, result: {
     resumed: string[];
     failed: string[];
-}): string;
+}, redelivered?: number): string;
 /**
  * Reply to a login request that named no harness Crewly can log in.
  *
@@ -266,7 +344,7 @@ export declare function formatWhichHarnessDm(name: string | null): string;
  */
 export declare function formatNoBrokerLoginDm(harnessId: HarnessId): string;
 /**
- * DM after the login failed or timed out (sent once per failure).
+ * DM after the login failed (sent once per failure).
  *
  * @param harnessId - Harness
  * @param reason - Broker message (redacted here)
@@ -274,35 +352,50 @@ export declare function formatNoBrokerLoginDm(harnessId: HarnessId): string;
  */
 export declare function formatFailureDm(harnessId: HarnessId, reason: string | null): string;
 /**
- * Re-reminder text for a login whose last link expired unused. It carries no
- * link: a new one is made when the owner replies, so it is fresh when used.
+ * Re-reminder text for a login whose last link expired unused.
  *
  * @param harnessId - Harness
  * @param waiting - Agents waiting on the login
+ * @param machine - This machine's name
  * @returns DM text
  */
-export declare function formatReminderDm(harnessId: HarnessId, waiting: readonly string[]): string;
-/** Coordinates Slack re-login flows, one per harness. */
+export declare function formatReminderDm(harnessId: HarnessId, waiting: readonly string[], machine?: string): string;
+/** Coordinates re-login flows, one per harness. */
 export declare class HarnessReloginService {
     private readonly broker;
     private readonly credentials;
     private readonly apiKeys;
     private readonly checkLoginState;
+    private readonly verifyLogin;
     private readonly getOrcHarness;
+    private listAgents;
+    private sessionNeedsLogin;
+    private onLoginRestored;
+    private readonly machineName;
+    private readonly state;
     private notifier;
     private resumer;
     private readonly now;
     private readonly logger;
     private readonly flows;
+    /** Harnesses whose expiry is being confirmed → sessions reported meanwhile */
+    private readonly confirming;
+    /** Harnesses whose re-reminder is being prepared */
+    private readonly reminding;
     /** Expiry reports are ignored until then (resumed transcripts repeat old errors) */
     private readonly quietUntil;
     /** Last silent API-key recovery per harness */
     private readonly silentKeyAt;
     /** Sessions restarted after a login: screen-sweep reports are ignored until live output reports again */
     private readonly mutedScreens;
-    /** Harnesses the status check has seen logged in */
-    private readonly seenLoggedIn;
+    /** Last probe result per harness */
+    private readonly probeCache;
+    /** Probes in flight per harness */
+    private readonly probeInFlight;
+    /** Agents configured on this machine, from the last {@link listAgents} */
+    private agents;
     private statusTimer;
+    private firstCheckTimer;
     private statusCheckInFlight;
     /**
      * @param deps - Dependencies
@@ -320,6 +413,24 @@ export declare class HarnessReloginService {
      * @param resumer - Resumer, or null
      */
     setResumer(resumer: ReloginAgentResumer | null): void;
+    /**
+     * Set what re-delivers the owner messages that waited for a login.
+     *
+     * @param handler - Handler, or null
+     */
+    setLoginRestoredHandler(handler: HarnessReloginDeps['onLoginRestored'] | null): void;
+    /**
+     * Set how the configured agents (running or not) are listed.
+     *
+     * @param lister - Lister, or null
+     */
+    setAgentLister(lister: HarnessReloginDeps['listAgents'] | null): void;
+    /**
+     * Set the per-session sign-in flag lookup (OAuth monitor).
+     *
+     * @param lookup - Lookup, or null
+     */
+    setSessionNeedsLogin(lookup: HarnessReloginDeps['sessionNeedsLogin'] | null): void;
     /**
      * Report an expired harness login.
      *
@@ -332,17 +443,22 @@ export declare class HarnessReloginService {
     /**
      * Offer an owner's Slack DM to the re-login coordinator.
      *
-     * Consumed, in this order: the retry keyword (while a flow exists), a
-     * login code or screen reply for a running flow, and finally an owner
-     * login request (「重新登录 claude」, "relogin codex" — see
+     * Consumed, in this order: a login keyword (`login`, 「重新登录」…) while a
+     * harness is signed out or signing in; a login code or screen reply for a
+     * running flow (only in the conversation the link went to); and finally an
+     * owner login request (「重新登录 claude」, "relogin codex" — see
      * {@link parseOwnerLoginRequest}), which starts a forced login answered in
      * `target`.
      *
+     * In another agent's bot DM (`scope: 'agent'`) only a request that names a
+     * harness, or a reply to a flow, is taken — the rest is that agent's mail.
+     *
      * @param text - Reply text (never logged)
      * @param target - Conversation the owner wrote in (answers go there)
+     * @param scope - `orc` (orc / master DM) or `agent` (another agent's bot DM)
      * @returns True when consumed; the caller must then NOT pass it on as a chat message
      */
-    handleOwnerReply(text: string, target?: ReloginReplyTarget | null): boolean;
+    handleOwnerReply(text: string, target?: ReloginReplyTarget | null, scope?: OwnerReplyScope): boolean;
     /**
      * Start a login the owner asked for, through the broker: forced (runs
      * even when the harness is still logged in — the owner may be switching
@@ -354,6 +470,21 @@ export declare class HarnessReloginService {
      * @returns What happened (never throws)
      */
     startOwnerLogin(harnessId: HarnessId, options: OwnerLoginOptions): OwnerLoginResult;
+    /**
+     * Harnesses confirmed signed out on this machine (persisted).
+     *
+     * @param harnessId - Harness
+     * @returns True while the owner has not signed it in again
+     */
+    isSignedOut(harnessId: HarnessId): boolean;
+    /**
+     * The signed-out harness an agent is waiting on, if any — for the
+     * owner-message watchdog, which must not wake an agent onto a dead login.
+     *
+     * @param sessionName - Agent session
+     * @returns The harness, or null when its harness is not signed out
+     */
+    signedOutHarnessOf(sessionName: string): HarnessId | null;
     /**
      * Act on a parsed owner login request from the DM.
      *
@@ -362,10 +493,11 @@ export declare class HarnessReloginService {
      */
     private handleOwnerLoginRequest;
     /**
-     * Offer a DM to the running flows: the retry keyword, a login code, or a
-     * reply to an unrecognised screen.
+     * Offer a DM to the flows: a login keyword, a login code, or a reply to
+     * an unrecognised screen.
      *
      * @param text - Reply text (never logged)
+     * @param target - Conversation it was written in
      * @returns True when consumed
      */
     private consumeFlowReply;
@@ -377,36 +509,102 @@ export declare class HarnessReloginService {
      */
     getPending(harnessId: HarnessId): ReloginPending | null;
     /**
-     * Check the orchestrator's harness with its own status command, and
-     * report an expiry when it says logged out. Only a harness that was seen
-     * logged in, or that agents are running on, counts (a machine that was
-     * never logged in is onboarding's job, not a re-login).
+     * Check every harness in use on this machine — the orchestrator's and every
+     * configured agent's, running or not — and report the ones that are signed
+     * out. A harness the status command calls logged in is probed for real now
+     * and then ({@link HARNESS_CONSTANTS.RELOGIN.PROBE_INTERVAL_MS}), because a
+     * stored Claude credential survives its expiry. Signed-out harnesses get
+     * their (backed-off) re-reminder here.
      *
      * @returns Resolves when the check is done; never rejects
      */
+    checkHarnesses(): Promise<void>;
+    /**
+     * Compatibility name of {@link checkHarnesses}.
+     *
+     * @returns Resolves when the check is done
+     */
     checkOrcHarness(): Promise<void>;
     /**
-     * Start the periodic status check of the orchestrator's harness.
+     * One harness of the periodic check.
+     *
+     * @param harnessId - Harness
+     * @param inUse - The orchestrator or a configured agent runs on it
+     */
+    private checkOne;
+    /**
+     * Start the periodic check (first run shortly after boot, so a machine
+     * that comes up signed out says so without waiting a full interval).
      *
      * @param intervalMs - Cadence (defaults to STATUS_CHECK_INTERVAL_MS)
+     * @param firstDelayMs - Delay of the first check (default 60 s)
      */
-    start(intervalMs?: number): void;
+    start(intervalMs?: number, firstDelayMs?: number): void;
     /** Stop the periodic check and forget every flow's timers. */
     stop(): void;
     /**
-     * Start a flow: silent API key if Crewly holds one, else a broker login.
+     * Confirm a suspected expiry, then tell the owner (or use a stored key).
      *
      * @param harnessId - Harness
-     * @param stuck - Sessions known to be stuck
-     * @param options - Trigger, wording and reply target (default: a detected expiry)
      */
-    private begin;
+    private confirmExpiry;
     /**
-     * Body of a flow (async part of {@link begin}).
+     * Login state: the status command, then the live probe when the status
+     * command cannot see an expiry (it says logged in / unknown).
+     *
+     * @param harnessId - Harness
+     * @param fresh - Ignore a cached probe result
+     * @returns The best-known state
+     */
+    private currentState;
+    /**
+     * Run (or reuse) the live probe.
+     *
+     * @param harnessId - Harness
+     * @param fresh - Ignore a cached result
+     * @returns Probe result (`unknown` when there is no probe)
+     */
+    private probe;
+    /**
+     * Re-remind the owner of a signed-out harness once its backoff elapsed. If
+     * the harness is signed in again by then (the owner did it on the
+     * machine or in Setup), the flow finishes and the agents resume instead.
+     *
+     * @param flow - A signed-out flow
+     */
+    private maybeRemind;
+    /**
+     * Whether the backoff allows another "signed out" DM for a harness.
+     *
+     * @param harnessId - Harness
+     * @returns True when no notice was sent yet, or the backoff elapsed
+     */
+    private noticeDue;
+    /**
+     * Send the "signed out" DM (first notice or re-reminder), within the backoff.
      *
      * @param flow - The flow
+     * @param kind - Which text
      */
-    private run;
+    private sendSignedOutNotice;
+    /**
+     * Replace a harness's flow with a new one and start its broker session.
+     *
+     * @param harnessId - Harness
+     * @param previous - The flow it replaces (its stuck agents are kept), or null
+     * @param options - Trigger, wording and reply target
+     */
+    private replaceAndStart;
+    /**
+     * A new flow record.
+     *
+     * @param harnessId - Harness
+     * @param stuck - Sessions known to be stuck
+     * @param options - Trigger, wording and reply target
+     * @param phase - Initial phase
+     * @returns The flow (not registered)
+     */
+    private newFlow;
     /**
      * Start (or adopt) the harness's broker login session for a flow.
      *
@@ -435,32 +633,73 @@ export declare class HarnessReloginService {
      */
     private handleFinished;
     /**
-     * The login is back: restart the stuck agents and tell the owner.
+     * A login finished outside any flow (dashboard chip, Setup, CLI): restart
+     * only the sessions that sit at a sign-in screen and re-deliver what
+     * waited for them. Working agents of the harness are left alone.
+     *
+     * @param harnessId - Harness that was signed in
+     */
+    private adoptOutsideLogin;
+    /**
+     * The broker reported success: confirm it with the probe, then finish.
+     *
+     * @param flow - The flow
+     */
+    private confirmAndSucceed;
+    /**
+     * The login is back: restart the stuck agents, re-deliver what waited,
+     * and tell the owner.
      *
      * @param flow - The flow
      * @param notify - DM the owner (false for the silent API-key path)
      */
     private succeed;
     /**
-     * Re-reminder after a link expired unused: if the harness is logged in by
-     * now (the owner signed in another way), finish the flow and resume the
-     * stuck agents; otherwise send a text reminder. No login is started here —
-     * the owner's `relogin` reply starts one while they are there to use it.
+     * Sessions to restart after a login: the ones whose output matched plus
+     * every live session of the harness (they all hold the dead login).
      *
-     * @param flow - A failed flow whose last session timed out
+     * @param flow - The flow
+     * @returns Session names
      */
-    private remind;
+    private sessionsToRestart;
     /**
-     * Start a flow over (retry keyword or re-reminder).
+     * Names of the agents that run on a flow's harness, for the owner: every
+     * configured agent on it, else the stuck / live ones.
      *
-     * @param flow - The flow to replace
+     * @param flow - The flow
+     * @returns Display names
      */
-    private restart;
+    private agentNamesOn;
+    /**
+     * Re-read the configured agents.
+     *
+     * @returns The agents (the last known list when the read fails)
+     */
+    private refreshAgents;
+    /**
+     * Harness an agent session runs on.
+     *
+     * @param sessionName - Agent session
+     * @returns Harness id, or null when unknown
+     */
+    private harnessOfSession;
+    /**
+     * Record that a harness is signed out (first time only keeps the date).
+     *
+     * @param harnessId - Harness
+     */
+    private markSignedOut;
+    /**
+     * Remember that a harness was seen signed in (written at most hourly).
+     *
+     * @param harnessId - Harness
+     */
+    private markSeenLoggedIn;
     /**
      * DM wording for a flow.
      *
      * @param flow - The flow
-     * @returns Owner-requested / account-switch flags
+     * @returns Account-switch flag and machine name
      */
     private wordingOf;
     /**
@@ -477,25 +716,21 @@ export declare class HarnessReloginService {
      */
     private sendScreenIfUnrecognised;
     /**
-     * Agents waiting on a flow: the stuck ones, else every session of the harness.
-     *
-     * @param flow - The flow
-     * @returns Session names
-     */
-    private waitingAgents;
-    /**
-     * DM the owner (logs when no notifier is wired; never logs the text).
+     * DM the owner in the flow's conversation, and remember where it landed
+     * so later DMs (the link, the result) follow it.
      *
      * @param flow - The flow
      * @param text - DM text
+     * @returns The delivery
      */
     private dm;
     /**
      * Send a message to the owner (logs when no notifier is wired; never logs the text).
      *
      * @param text - DM text
-     * @param target - Conversation to answer in (null = master-bot DM)
+     * @param target - Conversation to answer in (null = this machine's DM)
      * @param harnessId - Harness, for logs
+     * @returns The delivery (false when not delivered)
      */
     private notify;
     /**
@@ -514,8 +749,9 @@ export declare class HarnessReloginService {
 }
 /**
  * The backend's re-login coordinator, bound to the backend harness service
- * (its broker, credentials, API keys and status). Registers itself as the
- * `reloginPending` source of `GET /api/harness`.
+ * (its broker, credentials, API keys and status), the live sign-in probe and
+ * the persisted notice state. Registers itself as the `reloginPending`
+ * source of `GET /api/harness`.
  *
  * @returns The singleton
  */