@gethmy/mcp 3.4.1 → 3.5.0

package/dist/cli.js

@@ -5693,7 +5693,7 @@ var TOOLS = {
     }
   },
   harmony_update_agent_progress: {
-    description: "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live.",
+    description: "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live. `sessionStale: true` means it opened one IN PLACE OF a session the inactivity sweep had closed (card #1067): nobody stopped you and the new row keeps the old one's steering channel and driver, so carry on — but the id changed, so poll harmony_get_pending_messages with the new `session.id` from this reply, not the one you were holding. `liveSessionIdChanged: true` is the weaker cousin: the live session is simply not the one you started, so use the new id, but do NOT assume steering survived — read `instruction`.",
     inputSchema: {
       type: "object",
       properties: {
@@ -7654,6 +7654,32 @@ ${options}
       if (result.session === null) {
         untrack(cardId, deps.getScopeId?.());
       }
+      const scopeId = deps.getScopeId?.();
+      const ownSession = memSession && memSession.scopeId === scopeId ? memSession : undefined;
+      const knownSessionId = ownSession?.agentSessionId;
+      const liveSessionId = result.session?.id;
+      const idChangedUnderUs = knownSessionId !== undefined && liveSessionId !== undefined && liveSessionId !== knownSessionId;
+      if (idChangedUnderUs && ownSession && liveSessionId) {
+        ownSession.agentSessionId = liveSessionId;
+      }
+      const newSessionId = liveSessionId ? ` (${liveSessionId})` : "";
+      if (result.sessionStale) {
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          instruction: "Your previous session had gone stale, so this report opened a new one in its place — nobody stopped you, and it kept the steering channel and driver of the run it replaced. Do NOT abandon the work. Poll harmony_get_pending_messages with the NEW session id" + newSessionId + ", not the one you were holding."
+        };
+      }
+      if (idChangedUnderUs) {
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          liveSessionIdChanged: true,
+          instruction: "The live session on this card is no longer the one you started — it may have been reopened, or deliberately ended and replaced. Nobody stopped you, so carry on, but poll harmony_get_pending_messages with the session id from this reply" + newSessionId + ". If steering matters to this run, do not assume it survived: start a session deliberately with harmony_start_agent_session and steerable: true."
+        };
+      }
       return { success: true, midSessionLearnings: 0, ...result };
     }
     case "harmony_end_agent_session": {

package/dist/index.js

@@ -5476,7 +5476,7 @@ var TOOLS = {
     }
   },
   harmony_update_agent_progress: {
-    description: "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live.",
+    description: "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live. `sessionStale: true` means it opened one IN PLACE OF a session the inactivity sweep had closed (card #1067): nobody stopped you and the new row keeps the old one's steering channel and driver, so carry on — but the id changed, so poll harmony_get_pending_messages with the new `session.id` from this reply, not the one you were holding. `liveSessionIdChanged: true` is the weaker cousin: the live session is simply not the one you started, so use the new id, but do NOT assume steering survived — read `instruction`.",
     inputSchema: {
       type: "object",
       properties: {
@@ -7437,6 +7437,32 @@ ${options}
       if (result.session === null) {
         untrack(cardId, deps.getScopeId?.());
       }
+      const scopeId = deps.getScopeId?.();
+      const ownSession = memSession && memSession.scopeId === scopeId ? memSession : undefined;
+      const knownSessionId = ownSession?.agentSessionId;
+      const liveSessionId = result.session?.id;
+      const idChangedUnderUs = knownSessionId !== undefined && liveSessionId !== undefined && liveSessionId !== knownSessionId;
+      if (idChangedUnderUs && ownSession && liveSessionId) {
+        ownSession.agentSessionId = liveSessionId;
+      }
+      const newSessionId = liveSessionId ? ` (${liveSessionId})` : "";
+      if (result.sessionStale) {
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          instruction: "Your previous session had gone stale, so this report opened a new one in its place — nobody stopped you, and it kept the steering channel and driver of the run it replaced. Do NOT abandon the work. Poll harmony_get_pending_messages with the NEW session id" + newSessionId + ", not the one you were holding."
+        };
+      }
+      if (idChangedUnderUs) {
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          liveSessionIdChanged: true,
+          instruction: "The live session on this card is no longer the one you started — it may have been reopened, or deliberately ended and replaced. Nobody stopped you, so carry on, but poll harmony_get_pending_messages with the session id from this reply" + newSessionId + ". If steering matters to this run, do not assume it survived: start a session deliberately with harmony_start_agent_session and steerable: true."
+        };
+      }
       return { success: true, midSessionLearnings: 0, ...result };
     }
     case "harmony_end_agent_session": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "MCP server for Harmony, the shared surface for human–agent teams — agents claim cards, report progress, and move work on your board.",
   "publishConfig": {
     "access": "public"

package/src/api-client.ts

@@ -1335,6 +1335,23 @@ export class HarmonyApiClient {
     stopReason?: "human_stopped";
     /** How to legitimately work this card again (an explicit start). */
     recovery?: string;
+    /**
+     * This write REPLACED a session the silence sweep had closed (#1067): the
+     * returned session is a new row under a new id, carrying forward the
+     * `steerable`/`driver` of the one it replaced. Not a stop — the run
+     * continues — but every later poll must use the NEW `session.id`.
+     *
+     * Same word `getPendingMessages` answers with, deliberately: one flag name
+     * for one fact across both calls. Absent on an ordinary update, on a
+     * deliberate start, and from a pre-#1067 server.
+     */
+    sessionStale?: boolean;
+    /**
+     * The swept session that was replaced — never the new one's id. Present
+     * exactly when `sessionStale` is, so it is also the discriminator between
+     * the server's own verdict and the MCP tool's weaker `liveSessionIdChanged`.
+     */
+    replacedSessionId?: string;
   }> {
     return this.request("POST", `/cards/${cardId}/agent-context`, data);
   }

package/src/server.ts

@@ -1610,7 +1610,7 @@ export const TOOLS = {
   },
   harmony_update_agent_progress: {
     description:
-      "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live.",
+      "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes. Check the reply: `session: null` with `stopped: true` means a human stopped this card's run, so reporting progress will no longer open a session here (card #770) — stop work if you were mid-run, and read `recovery` for the one legitimate way back. Otherwise a session is always returned: this call opens one if none is live. `sessionStale: true` means it opened one IN PLACE OF a session the inactivity sweep had closed (card #1067): nobody stopped you and the new row keeps the old one's steering channel and driver, so carry on — but the id changed, so poll harmony_get_pending_messages with the new `session.id` from this reply, not the one you were holding. `liveSessionIdChanged: true` is the weaker cousin: the live session is simply not the one you started, so use the new id, but do NOT assume steering survived — read `instruction`.",
     inputSchema: {
       type: "object",
       properties: {
@@ -4379,6 +4379,77 @@ export async function handleToolCall(
         untrack(cardId, deps.getScopeId?.());
       }
 
+      // Two DIFFERENT facts, and the earlier cut of #1067 merged them into one
+      // sentence that was false in three reachable cases.
+      //
+      // `result.sessionStale` is the server's own verdict: it replaced a
+      // recently-swept session AND carried its `steerable`/`driver` forward. Only
+      // that verdict licenses saying the steering channel survived.
+      //
+      // The id comparison establishes strictly less — that the live session is
+      // not the one this run recorded at start. It catches the case the flag
+      // cannot: `flushMemoryActions` is fire-and-forget, sends
+      // `implicitCreate: true` and discards its result, so when the sweep has
+      // closed the row that bookkeeping write is what mints the replacement and
+      // consumes the server's one `sessionStale`; this checkpoint then lands on a
+      // live row under a new id with `created: false`. But an id change alone is
+      // ALSO what `harmony_move_card` leaves behind — it ends the session and
+      // untracks the card without calling `cleanupMemorySession`, so the recorded
+      // id outlives a deliberate `completed` end — and what a lapsed recency
+      // window leaves behind, where the new row genuinely is NOT steerable.
+      // Claiming inheritance there tells a run its steering survived when it
+      // did not, which suppresses the one recovery that works (an explicit
+      // `harmony_start_agent_session` with `steerable: true`). Worse than
+      // silence, so the two paths say different things.
+      //
+      // The RESYNC is unconditional and is a fix in its own right: this field
+      // scopes working-memory writes (`sessionScopeFor`) and feeds comment
+      // attribution, so a stale id there is wrong regardless of what is reported.
+      const scopeId = deps.getScopeId?.();
+      // `memorySessions` is keyed by card id ALONE at module scope, so on the
+      // hosted transport a lookup can hand back another user's session for the
+      // same card. Anything that CLAIMS the tracked session compares the scope
+      // first — `chooseCommentSession` does, and #1035 is why.
+      const ownSession =
+        memSession && memSession.scopeId === scopeId ? memSession : undefined;
+      const knownSessionId = ownSession?.agentSessionId;
+      const liveSessionId = (result.session as { id?: string } | null)?.id;
+      const idChangedUnderUs =
+        knownSessionId !== undefined &&
+        liveSessionId !== undefined &&
+        liveSessionId !== knownSessionId;
+      // Report once: the run now knows this id, so a later checkpoint on the
+      // same session is silent again rather than crying change forever.
+      if (idChangedUnderUs && ownSession && liveSessionId) {
+        ownSession.agentSessionId = liveSessionId;
+      }
+      const newSessionId = liveSessionId ? ` (${liveSessionId})` : "";
+      if (result.sessionStale) {
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          instruction:
+            "Your previous session had gone stale, so this report opened a new one in its place — nobody stopped you, and it kept the steering channel and driver of the run it replaced. Do NOT abandon the work. Poll harmony_get_pending_messages with the NEW session id" +
+            newSessionId +
+            ", not the one you were holding.",
+        };
+      }
+      if (idChangedUnderUs) {
+        // Everything this branch knows, and nothing it does not: no claim that
+        // anything went stale, and none that any capability was preserved.
+        return {
+          success: true,
+          midSessionLearnings: 0,
+          ...result,
+          liveSessionIdChanged: true,
+          instruction:
+            "The live session on this card is no longer the one you started — it may have been reopened, or deliberately ended and replaced. Nobody stopped you, so carry on, but poll harmony_get_pending_messages with the session id from this reply" +
+            newSessionId +
+            ". If steering matters to this run, do not assume it survived: start a session deliberately with harmony_start_agent_session and steerable: true.",
+        };
+      }
+
       // Phase 0 (memory architecture v2): mid-session learning extraction removed.
       return { success: true, midSessionLearnings: 0, ...result };
     }