@agentchatme/agent-core 0.0.1313 → 0.0.1313111

package/dist/index.js

@@ -20,6 +20,7 @@ import {
   clearAlwaysOnOptOut,
   clearAlwaysOnWanted,
   clearCredentials,
+  clearForegroundTurn,
   clearPending,
   clearSessionActive,
   contextOf,
@@ -33,6 +34,7 @@ import {
   markAlwaysOnInstalledVersion,
   markAlwaysOnOptOut,
   markAlwaysOnWanted,
+  markForegroundTurn,
   markSessionActive,
   pendingPath,
   readAlwaysOnInstalledVersion,
@@ -47,20 +49,21 @@ import {
   syncPeek,
   writeCredentials,
   writePending
-} from "./chunk-27XDHOL3.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({}),
@@ -100,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;
 }
@@ -112,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;
@@ -348,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;
@@ -428,9 +445,10 @@ 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;
 function hooksDisabled() {
   return process.env["AGENTCHAT_HOOKS_ENABLED"] === "0";
 }
@@ -486,84 +504,125 @@ async function sessionStart(ctx, input) {
       }
       return none;
     }
-    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
-    await markSessionActive(cfg);
     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;
-    const cursor = takePendingAck(ctx.home, input.sessionId);
-    if (cursor === null) return;
+    if (identity === null) return none;
     const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
-    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)}`);
-    }
+    await markForegroundTurn(cfg, input.sessionId, FOREGROUND_TURN_TTL_SECONDS);
+    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 {
     if (hooksDisabled()) return none;
     const identity = resolveIdentity(ctx.home);
     if (identity === null) return none;
-    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
-    await markSessionActive(cfg);
+    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) {
       log.info(
         `stop hook: continuation cap (${cap}) reached for ${input.sessionId}; leaving inbox queued`
       );
+      await clearForegroundTurn(cfg, input.sessionId);
       return none;
     }
     const peeked = ackableRows(await syncPeek(cfg, { limit: STOP_PEEK_LIMIT }));
-    if (peeked.length === 0) return none;
+    if (peeked.length === 0) {
+      await clearForegroundTurn(cfg, input.sessionId);
+      return none;
+    }
     const rows = await claimContiguousPrefix(cfg, peeked, `session:${input.sessionId}`);
-    if (rows.length === 0) return none;
+    if (rows.length === 0) {
+      await clearForegroundTurn(cfg, input.sessionId);
+      return none;
+    }
     recordContinuation(ctx.home, input.sessionId);
     const handle = await resolveHandle(cfg, identity.handle);
     const reason = formatStopPickup(handle, rows);
     const cursor = lastDeliveryId(rows);
     return {
       reason,
-      commit: async () => {
-        if (cursor === null) return;
-        try {
-          await syncAck(cfg, 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
+          );
         }
       }
     };
   } catch (err) {
+    if (cfg !== null) await clearForegroundTurn(cfg, input.sessionId);
     log.warn(`stop hook degraded to no-op: ${String(err)}`);
     return none;
   }
 }
+async function sessionEnd(ctx, input) {
+  try {
+    if (hooksDisabled()) return;
+    const identity = resolveIdentity(ctx.home);
+    if (identity === null) return;
+    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
+    await clearForegroundTurn(cfg, input.sessionId);
+  } catch (err) {
+    log.warn(`session-end hook degraded to no-op: ${String(err)}`);
+  }
+}
 
 // src/hooks/hook-input.ts
 async function readHookInput(stream = process.stdin) {
@@ -593,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) {
@@ -602,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) {
@@ -618,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)}`);
       }
@@ -626,13 +702,21 @@ 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)}`);
       }
+    },
+    async runSessionEnd() {
+      try {
+        const input = await readHookInput();
+        await sessionEnd(context(), input);
+      } catch (err) {
+        log.warn(`session-end hook degraded to no-op: ${String(err)}`);
+      }
     }
   };
 }
@@ -1135,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.',
@@ -1144,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\`.`,
@@ -1681,6 +1765,7 @@ export {
   clearAlwaysOnOptOut,
   clearAlwaysOnWanted,
   clearCredentials,
+  clearForegroundTurn,
   clearOfferDeclined,
   clearPending,
   clearSessionActive,
@@ -1705,6 +1790,7 @@ export {
   markAlwaysOnInstalledVersion,
   markAlwaysOnOptOut,
   markAlwaysOnWanted,
+  markForegroundTurn,
   markSessionActive,
   offerDeclined,
   pendingPath,
@@ -1732,6 +1818,7 @@ export {
   serviceDefinitionCurrent,
   serviceInstalled,
   serviceStatus,
+  sessionEnd,
   sessionStart,
   setPendingAck,
   shouldOfferRegistration,