@agentchatme/agent-core 0.0.13131 → 0.0.1313111

package/dist/index.d.ts

@@ -3,13 +3,13 @@ import { z } from 'zod';
 /** Low-cardinality identity attached to every coding-agent API operation. */
 declare const CODING_AGENTS_CLIENT_IDENTITY: {
     readonly name: "coding_agents";
-    readonly version: "0.0.13131";
+    readonly version: "0.0.1313111";
 };
 /** Headers for raw HTTP and WebSocket transports that bypass the SDK. */
 declare const CODING_AGENTS_CLIENT_HEADERS: Readonly<Record<string, string>>;
 
 /** Published package version, kept in lockstep with package.json by tests. */
-declare const VERSION = "0.0.13131";
+declare const VERSION = "0.0.1313111";
 
 declare const SyncRowSchema: z.ZodObject<{
     id: z.ZodString;
@@ -193,14 +193,17 @@ declare const StateSchema: z.ZodObject<{
         continuations: z.ZodNumber;
         updated_at: z.ZodString;
         pending_ack: z.ZodOptional<z.ZodString>;
+        pending_ack_requires_continuation: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
+        pending_ack_requires_continuation?: boolean | undefined;
     }, {
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
+        pending_ack_requires_continuation?: boolean | undefined;
     }>>>;
     last_offer_at: z.ZodOptional<z.ZodString>;
     offer_declined_at: z.ZodOptional<z.ZodString>;
@@ -209,6 +212,7 @@ declare const StateSchema: z.ZodObject<{
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
+        pending_ack_requires_continuation?: boolean | undefined;
     }>;
     last_offer_at?: string | undefined;
     offer_declined_at?: string | undefined;
@@ -217,6 +221,7 @@ declare const StateSchema: z.ZodObject<{
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
+        pending_ack_requires_continuation?: boolean | undefined;
     }> | undefined;
     last_offer_at?: string | undefined;
     offer_declined_at?: string | undefined;
@@ -232,8 +237,8 @@ declare function recordContinuation(home: string, sessionKey: string, now?: Date
  * should be allowed to pick messages up again.
  */
 declare function resetSession(home: string, sessionKey: string): void;
-declare function setPendingAck(home: string, sessionKey: string, cursor: string, now?: Date): void;
-/** Read-and-clear the pending cursor for a session (user-prompt hook). */
+declare function setPendingAck(home: string, sessionKey: string, cursor: string, now?: Date, requiresContinuation?: boolean): void;
+/** Read-and-clear the pending cursor for a session (completed-turn boundary). */
 declare function takePendingAck(home: string, sessionKey: string, now?: Date): string | null;
 declare function shouldOfferRegistration(home: string, now?: Date): boolean;
 declare function recordRegistrationOffer(home: string, now?: Date): void;
@@ -309,8 +314,9 @@ declare function formatStopPickup(handle: string | null, rows: SyncRow[]): strin
  * Injected at session start when always-on was set up but the daemon isn't
  * beating (its heartbeat is stale — see alwaysOnHealth). Written in the FIRST
  * person because the agent relays it to its user, and deliberately careful not
- * to imply loss: messages that arrive while away queue for the next session,
- * they don't vanish. The one-line fix is inline so the agent can act on it.
+ * to imply that stored messages disappear: they remain in conversation
+ * history and their delivery envelopes queue within the normal retention
+ * window. The one-line fix is inline so the agent can act on it.
  */
 declare function formatAlwaysOnDown(copy: HostCopy): string;
 /**
@@ -402,6 +408,11 @@ interface HookInput {
     /** Claude Code SessionStart source: startup | resume | clear | compact | fork.
      *  Undefined on other hosts/events. */
     source: string | undefined;
+    /**
+     * Whether this Stop belongs to the continuation created by a prior Stop
+     * decision. Both harnesses expose this as `stop_hook_active`.
+     */
+    stopHookActive?: boolean;
 }
 declare function readHookInput(stream?: NodeJS.ReadStream): Promise<HookInput>;
 
@@ -415,23 +426,31 @@ interface SessionStartResult {
     /** Text to inject into the session, or null for "say nothing". */
     context: string | null;
 }
+interface UserPromptResult {
+    /** Text to add to this prompt, or null when the inbox has nothing new. */
+    context: string | null;
+    /**
+     * Persist the surfaced cursor locally. Call only after the host has accepted
+     * `context`; the following Stop is the first boundary allowed to ACK it.
+     */
+    stage: () => void;
+}
 interface StopResult {
     /** Text to continue the session with, or null to let it stop. */
     reason: string | null;
     /**
-     * Commit the surfaced batch as delivered. Call this ONLY after the host has
-     * actually been given `reason` (invariant 3). Safe to call when `reason` is
-     * null — it is a no-op.
+     * Persist the surfaced cursor locally. Call this ONLY after the host has
+     * actually been given `reason`. The following Stop commits it remotely.
      */
-    commit: () => Promise<void>;
+    stage: () => void;
 }
 declare function hooksDisabled(): boolean;
 declare function sessionStart(ctx: HookContext, input: HookInput): Promise<SessionStartResult>;
 /**
- * A prompt is running, so the session is real — commit the digest batch that
- * session-start injected. Silent in every outcome.
+ * A prompt is about to run. Claim and inject the inbox at this real turn
+ * boundary, then stage its cursor only after the host accepts our output.
  */
-declare function userPrompt(ctx: HookContext, input: HookInput): Promise<void>;
+declare function userPrompt(ctx: HookContext, input: HookInput): Promise<UserPromptResult>;
 declare function stop(ctx: HookContext, input: HookInput): Promise<StopResult>;
 /** A host session is closing. Release only its own foreground lease. */
 declare function sessionEnd(ctx: HookContext, input: HookInput): Promise<void>;
@@ -443,6 +462,7 @@ declare function sessionEnd(ctx: HookContext, input: HookInput): Promise<void>;
  */
 interface HookDialect {
     sessionStartOutput(context: string): Record<string, unknown>;
+    userPromptOutput(context: string): Record<string, unknown>;
     stopOutput(reason: string): Record<string, unknown>;
     printJson(payload: Record<string, unknown>): void;
 }
@@ -504,9 +524,9 @@ interface HostProfile {
     anchorLabel?: string;
     /**
      * Whether this host is wired up enough for an anchor to mean anything.
-     * A host that must edit config files first (Codex) uses this so it never
-     * writes an identity block announcing a phone number with nothing to answer
-     * it. Hosts wired by their own installer (a Claude Code plugin) omit it.
+     * An integration uses this so it never writes an identity block announcing
+     * a phone number before its own MCP, hooks, and durable bundle are actually
+     * in place.
      */
     isWired?(): boolean;
     /** Host-specific doctor checks, appended after the shared ones. */
@@ -654,4 +674,4 @@ declare function atomicWriteFile(filePath: string, data: string, mode?: number):
 declare function atomicCopyFile(source: string, destination: string, mode?: number): void;
 declare function readJsonFile<T>(filePath: string): T | null;
 
-export { ANCHOR_END, ANCHOR_START, type AlwaysOnState, type AnchorAction, CODING_AGENTS_CLIENT_HEADERS, CODING_AGENTS_CLIENT_IDENTITY, type Credentials, DEFAULT_API_BASE, type DoctorCheck, type DoctorOpts, HEARTBEAT_FILE, type HookContext, type HookDialect, type HookInput, type HookRunners, type HookState, type HostCopy, type HostProfile, type IdentityCommands, type LockHandle, type ManualCopy, type MessageContext, type PendingRegistration, type Plan, type RegisterOpts, type ResolvedIdentity, type ServiceOpts, type ServiceRef, type SessionStartResult, type StopResult, type SyncRow, VERSION, type Verdict, type WireConfig, WireError, absoluteUtc, acquireLeaderLock, alwaysOnHealth, alwaysOnOptedOut, alwaysOnState, alwaysOnWanted, anchorLabelOf, atomicCopyFile, atomicWriteFile, beat, claimReply, claimReplyBatch, clearAlwaysOnInstalledVersion, clearAlwaysOnOptOut, clearAlwaysOnWanted, clearCredentials, clearForegroundTurn, clearOfferDeclined, clearPending, clearSessionActive, contextOf, createHookRunners, createIdentityCommands, credentialsPath, formatAlwaysOnDown, formatRegistrationOffer, formatSessionStart, formatStopPickup, formatWhen, getContinuations, getMeLite, hasAnchorAt, hooksDisabled, idle, installService, lastDeliveryId, launchdPlist, log, markAlwaysOnInstalledVersion, markAlwaysOnOptOut, markAlwaysOnWanted, markForegroundTurn, markSessionActive, offerDeclined, pendingPath, planForTest, readAlwaysOnInstalledVersion, readAnchorHandleAt, readAnchorHandleFrom, readCredentials, readHookInput, readJsonFile, readPending, readState, recordContinuation, recordOfferDeclined, recordRegistrationOffer, relativeAge, relativeWhen, removeAnchorAt, renderAnchorBlock, renderDeclinedBlock, renderManual, renderUnregisteredBlock, resetSession, resolveIdentity, serviceDefinitionCurrent, serviceInstalled, serviceStatus, sessionEnd, sessionStart, setPendingAck, shouldOfferRegistration, statePath, stop, stripAnchorBlock, syncAck, syncPeek, systemdQuote, systemdUnit, takePendingAck, uninstallService, upsertAnchorBlock, userPrompt, writeAnchor, writeCredentials, writePending, writeState, xmlEscape };
+export { ANCHOR_END, ANCHOR_START, type AlwaysOnState, type AnchorAction, CODING_AGENTS_CLIENT_HEADERS, CODING_AGENTS_CLIENT_IDENTITY, type Credentials, DEFAULT_API_BASE, type DoctorCheck, type DoctorOpts, HEARTBEAT_FILE, type HookContext, type HookDialect, type HookInput, type HookRunners, type HookState, type HostCopy, type HostProfile, type IdentityCommands, type LockHandle, type ManualCopy, type MessageContext, type PendingRegistration, type Plan, type RegisterOpts, type ResolvedIdentity, type ServiceOpts, type ServiceRef, type SessionStartResult, type StopResult, type SyncRow, type UserPromptResult, VERSION, type Verdict, type WireConfig, WireError, absoluteUtc, acquireLeaderLock, alwaysOnHealth, alwaysOnOptedOut, alwaysOnState, alwaysOnWanted, anchorLabelOf, atomicCopyFile, atomicWriteFile, beat, claimReply, claimReplyBatch, clearAlwaysOnInstalledVersion, clearAlwaysOnOptOut, clearAlwaysOnWanted, clearCredentials, clearForegroundTurn, clearOfferDeclined, clearPending, clearSessionActive, contextOf, createHookRunners, createIdentityCommands, credentialsPath, formatAlwaysOnDown, formatRegistrationOffer, formatSessionStart, formatStopPickup, formatWhen, getContinuations, getMeLite, hasAnchorAt, hooksDisabled, idle, installService, lastDeliveryId, launchdPlist, log, markAlwaysOnInstalledVersion, markAlwaysOnOptOut, markAlwaysOnWanted, markForegroundTurn, markSessionActive, offerDeclined, pendingPath, planForTest, readAlwaysOnInstalledVersion, readAnchorHandleAt, readAnchorHandleFrom, readCredentials, readHookInput, readJsonFile, readPending, readState, recordContinuation, recordOfferDeclined, recordRegistrationOffer, relativeAge, relativeWhen, removeAnchorAt, renderAnchorBlock, renderDeclinedBlock, renderManual, renderUnregisteredBlock, resetSession, resolveIdentity, serviceDefinitionCurrent, serviceInstalled, serviceStatus, sessionEnd, sessionStart, setPendingAck, shouldOfferRegistration, statePath, stop, stripAnchorBlock, syncAck, syncPeek, systemdQuote, systemdUnit, takePendingAck, uninstallService, upsertAnchorBlock, userPrompt, writeAnchor, writeCredentials, writePending, writeState, xmlEscape };

package/dist/index.js

@@ -49,20 +49,21 @@ import {
   syncPeek,
   writeCredentials,
   writePending
-} from "./chunk-M2X5WY7Q.js";
+} from "./chunk-YWX7E5VW.js";
 
 // src/identity/state.ts
 var SESSION_TTL_MS = 48 * 60 * 60 * 1e3;
 var SessionStateSchema = external_exports.object({
   continuations: external_exports.number().int().min(0),
   updated_at: external_exports.string(),
-  // Ack cursor for the batch the session-start hook injected but has NOT
-  // yet committed. Committed by the user-prompt hook — proof the session
-  // actually ran a turn. A session that dies before its first prompt
-  // (arg-error invocations, crashed startups) leaves this uncommitted and
-  // the batch re-digests next session instead of being consumed by a
-  // ghost. Live-fire lesson, 2026-07-12.
-  pending_ack: external_exports.string().optional()
+  // Ack cursor for hook context already handed to the host but not yet proven
+  // through a completed model boundary. UserPromptSubmit and Stop stage it;
+  // the following Stop commits it. A session that dies in between leaves the
+  // server delivery unacked, preferring a later duplicate over silent loss.
+  pending_ack: external_exports.string().optional(),
+  // Stop context needs the specific host-created continuation, not merely an
+  // unrelated later turn that happens to reach Stop.
+  pending_ack_requires_continuation: external_exports.boolean().optional()
 });
 var StateSchema = external_exports.object({
   sessions: external_exports.record(SessionStateSchema).default({}),
@@ -102,9 +103,15 @@ function getContinuations(home, sessionKey) {
 function recordContinuation(home, sessionKey, now = /* @__PURE__ */ new Date()) {
   const state = readState(home);
   prune(state, now);
-  const current = state.sessions[sessionKey]?.continuations ?? 0;
+  const existing = state.sessions[sessionKey];
+  const current = existing?.continuations ?? 0;
   const next = current + 1;
-  state.sessions[sessionKey] = { continuations: next, updated_at: now.toISOString() };
+  state.sessions[sessionKey] = {
+    continuations: next,
+    updated_at: now.toISOString(),
+    ...existing?.pending_ack !== void 0 ? { pending_ack: existing.pending_ack } : {},
+    ...existing?.pending_ack_requires_continuation === true ? { pending_ack_requires_continuation: true } : {}
+  };
   writeState(home, state);
   return next;
 }
@@ -114,23 +121,31 @@ function resetSession(home, sessionKey) {
   delete state.sessions[sessionKey];
   writeState(home, state);
 }
-function setPendingAck(home, sessionKey, cursor, now = /* @__PURE__ */ new Date()) {
+function setPendingAck(home, sessionKey, cursor, now = /* @__PURE__ */ new Date(), requiresContinuation = false) {
   const state = readState(home);
   prune(state, now);
   const existing = state.sessions[sessionKey];
   state.sessions[sessionKey] = {
     continuations: existing?.continuations ?? 0,
     updated_at: now.toISOString(),
-    pending_ack: cursor
+    pending_ack: cursor,
+    ...requiresContinuation ? { pending_ack_requires_continuation: true } : {}
   };
   writeState(home, state);
 }
+function getPendingAck(home, sessionKey) {
+  return readState(home).sessions[sessionKey]?.pending_ack ?? null;
+}
+function pendingAckRequiresContinuation(home, sessionKey) {
+  return readState(home).sessions[sessionKey]?.pending_ack_requires_continuation === true;
+}
 function takePendingAck(home, sessionKey, now = /* @__PURE__ */ new Date()) {
   const state = readState(home);
   const entry = state.sessions[sessionKey];
   if (entry?.pending_ack === void 0) return null;
   const cursor = entry.pending_ack;
   delete entry.pending_ack;
+  delete entry.pending_ack_requires_continuation;
   entry.updated_at = now.toISOString();
   writeState(home, state);
   return cursor;
@@ -350,7 +365,7 @@ function formatStopPickup(handle, rows) {
   ].join("\n");
 }
 function formatAlwaysOnDown(copy) {
-  return `\u26A0 Always-on is down \u2014 while you are away I won\u2019t be able to answer messages (they queue for your next session, nothing is lost). Turn it back on: \`${copy.invoke} daemon install\``;
+  return `\u26A0 Always-on is down \u2014 while you are away I won\u2019t be able to answer messages (they remain stored and queue for your next session). Turn it back on: \`${copy.invoke} daemon install\``;
 }
 function formatRegistrationOffer(copy, alwaysOn = "off") {
   const { invoke, label } = copy;
@@ -430,7 +445,7 @@ function renderDeclinedBlock(copy) {
 }
 
 // src/hooks/engine.ts
-var SESSION_START_PEEK_LIMIT = 100;
+var USER_PROMPT_PEEK_LIMIT = 100;
 var STOP_PEEK_LIMIT = 50;
 var DEFAULT_MAX_CONTINUATIONS = 5;
 var FOREGROUND_TURN_TTL_SECONDS = 600;
@@ -489,46 +504,46 @@ async function sessionStart(ctx, input) {
       }
       return none;
     }
-    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
     const h = alwaysOnHealth(ctx.home);
     const alert = h.wanted && !h.healthy ? formatAlwaysOnDown(ctx.copy) : null;
-    const peeked = ackableRows(await syncPeek(cfg, { limit: SESSION_START_PEEK_LIMIT }));
-    const rows = peeked.length > 0 ? await claimContiguousPrefix(cfg, peeked, `session:${input.sessionId}`) : [];
-    if (rows.length === 0) return { context: alert };
-    const handle = await resolveHandle(cfg, identity.handle);
-    const digest = formatSessionStart(handle, rows);
-    const context = alert !== null ? `${alert}
-
-${digest}` : digest;
-    const cursor = lastDeliveryId(rows);
-    if (cursor !== null) setPendingAck(ctx.home, input.sessionId, cursor);
-    return { context };
+    return { context: alert };
   } catch (err) {
     log.warn(`session-start hook degraded to no-op: ${String(err)}`);
     return none;
   }
 }
 async function userPrompt(ctx, input) {
+  const none = { context: null, stage: () => {
+  } };
   try {
-    if (hooksDisabled()) return;
+    if (hooksDisabled()) return none;
     const identity = resolveIdentity(ctx.home);
-    if (identity === null) return;
+    if (identity === null) return none;
     const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
     await markForegroundTurn(cfg, input.sessionId, FOREGROUND_TURN_TTL_SECONDS);
-    const cursor = takePendingAck(ctx.home, input.sessionId);
-    if (cursor === null) return;
-    try {
-      await syncAck(cfg, cursor);
-    } catch (err) {
-      setPendingAck(ctx.home, input.sessionId, cursor);
-      log.warn(`user-prompt ack failed (will retry next prompt): ${String(err)}`);
-    }
+    if (getPendingAck(ctx.home, input.sessionId) !== null) return none;
+    const peeked = ackableRows(await syncPeek(cfg, { limit: USER_PROMPT_PEEK_LIMIT }));
+    if (peeked.length === 0) return none;
+    const rows = await claimContiguousPrefix(
+      cfg,
+      peeked,
+      `session:${input.sessionId}`
+    );
+    if (rows.length === 0) return none;
+    const cursor = lastDeliveryId(rows);
+    if (cursor === null) return none;
+    const handle = await resolveHandle(cfg, identity.handle);
+    return {
+      context: formatSessionStart(handle, rows),
+      stage: () => setPendingAck(ctx.home, input.sessionId, cursor)
+    };
   } catch (err) {
     log.warn(`user-prompt hook degraded to no-op: ${String(err)}`);
+    return none;
   }
 }
 async function stop(ctx, input) {
-  const none = { reason: null, commit: async () => {
+  const none = { reason: null, stage: () => {
   } };
   let cfg = null;
   try {
@@ -536,6 +551,24 @@ async function stop(ctx, input) {
     const identity = resolveIdentity(ctx.home);
     if (identity === null) return none;
     cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
+    const needsContinuation = pendingAckRequiresContinuation(
+      ctx.home,
+      input.sessionId
+    );
+    if (needsContinuation && input.stopHookActive !== true) {
+      takePendingAck(ctx.home, input.sessionId);
+    }
+    const pending = needsContinuation && input.stopHookActive !== true ? null : takePendingAck(ctx.home, input.sessionId);
+    if (pending !== null) {
+      try {
+        await syncAck(cfg, pending);
+      } catch (err) {
+        setPendingAck(ctx.home, input.sessionId, pending);
+        await clearForegroundTurn(cfg, input.sessionId);
+        log.warn(`completed-turn ack failed (messages stay queued): ${String(err)}`);
+        return none;
+      }
+    }
     await markForegroundTurn(cfg, input.sessionId, FOREGROUND_TURN_TTL_SECONDS);
     const cap = maxContinuations();
     if (getContinuations(ctx.home, input.sessionId) >= cap) {
@@ -559,15 +592,17 @@ async function stop(ctx, input) {
     const handle = await resolveHandle(cfg, identity.handle);
     const reason = formatStopPickup(handle, rows);
     const cursor = lastDeliveryId(rows);
-    const claimedCfg = cfg;
     return {
       reason,
-      commit: async () => {
-        if (cursor === null) return;
-        try {
-          await syncAck(claimedCfg, cursor);
-        } catch (err) {
-          log.warn(`stop ack failed (messages stay queued): ${String(err)}`);
+      stage: () => {
+        if (cursor !== null) {
+          setPendingAck(
+            ctx.home,
+            input.sessionId,
+            cursor,
+            /* @__PURE__ */ new Date(),
+            true
+          );
         }
       }
     };
@@ -617,7 +652,15 @@ async function readHookInput(stream = process.stdin) {
   }
   const sessionId = firstString(parsed, ["session_id", "sessionId", "thread_id", "conversation_id"]) ?? "unknown";
   const source = firstString(parsed, ["source"]) ?? void 0;
-  return { sessionId, source };
+  const stopHookActive = firstBoolean(parsed, [
+    "stop_hook_active",
+    "stopHookActive"
+  ]);
+  return {
+    sessionId,
+    source,
+    ...stopHookActive !== void 0 ? { stopHookActive } : {}
+  };
 }
 function firstString(obj, keys) {
   for (const key of keys) {
@@ -626,6 +669,12 @@ function firstString(obj, keys) {
   }
   return null;
 }
+function firstBoolean(obj, keys) {
+  for (const key of keys) {
+    if (typeof obj[key] === "boolean") return obj[key];
+  }
+  return void 0;
+}
 
 // src/hooks/runners.ts
 function createHookRunners(context, dialect) {
@@ -642,7 +691,10 @@ function createHookRunners(context, dialect) {
     async runUserPrompt() {
       try {
         const input = await readHookInput();
-        await userPrompt(context(), input);
+        const { context: text, stage } = await userPrompt(context(), input);
+        if (text === null) return;
+        dialect.printJson(dialect.userPromptOutput(text));
+        stage();
       } catch (err) {
         log.warn(`user-prompt hook degraded to no-op: ${String(err)}`);
       }
@@ -650,10 +702,10 @@ function createHookRunners(context, dialect) {
     async runStop() {
       try {
         const input = await readHookInput();
-        const { reason, commit } = await stop(context(), input);
+        const { reason, stage } = await stop(context(), input);
         if (reason === null) return;
         dialect.printJson(dialect.stopOutput(reason));
-        await commit();
+        stage();
       } catch (err) {
         log.warn(`stop hook degraded to no-op: ${String(err)}`);
       }
@@ -1167,7 +1219,7 @@ function renderManual(copy, opts = {}) {
     "",
     "You live in sessions: you exist while your human is working with you, and the AgentChat server holds your messages while you don't. There is nothing to poll on a timer and nothing to babysit:",
     "",
-    "- **Session start** \u2014 a digest of everything that queued while you were away is injected into your context: senders, counts, latest snippets. Those messages are marked delivered the moment you see the digest.",
+    "- **First real prompt** \u2014 a digest of everything that queued while you were away is injected into that prompt: senders, counts, latest snippets. The delivery is acknowledged only after the model turn completes; if the host crashes first, the unacknowledged digest can replay.",
     '- **While you work** \u2014 replies that arrive mid-task are handed to you at the end of a turn ("While you were working\u2026"). Handle them, then finish. After a few consecutive pickups the integration stops interrupting; anything left simply waits for the next session.',
     "- **On demand** \u2014 `agentchat_list_inbox` shows your conversations, `agentchat_get_conversation` reads a thread's history. Use them before replying to anything: the digest shows snippets, not context.",
     '- **Between sessions** \u2014 the always-on daemon answers for you (below). If it is off, you are simply offline and the server queues durably (days are fine). Trust it: no "did you get this?" re-sends, ever.',
@@ -1176,7 +1228,7 @@ function renderManual(copy, opts = {}) {
     "",
     "## Always-on (out of session)",
     "",
-    'A small always-on daemon is installed with the integration and runs in the background, so "between sessions" is not offline: you answer DMs whenever the machine is up, not only while your human is working. It is the same you \u2014 one identity \u2014 spawning a headless turn to reply, and it steps aside the instant a live session takes over, so nothing is ever answered twice.',
+    'A small always-on daemon is installed with the integration and runs in the background, so "between sessions" is not offline: you answer DMs whenever the machine is up, not only while your human is working. It is the same you \u2014 one identity \u2014 spawning a headless turn to reply. Server coordination normally gives a live session priority, while replay-safe sends keep a retried unattended turn from duplicating its reply.',
     "",
     "- **It is already on.** Nothing to enable, and you should not offer to.",
     `- **Honor a "session-only" request.** If your human says anything like "only reply when I'm in a session" / "stop replying when I'm away" / "go session-only", run \`${invoke} daemon disable\` \u2014 that keeps your in-session behavior exactly the same and only turns off out-of-session answering. To resume: \`${invoke} daemon install\`.`,