@thehammer/danx-dashboard-mcp 0.1.204 → 0.1.206

package/dist/index.js

@@ -463,7 +463,7 @@ strictTool("attach_file", "Attach a LOCAL file to a card: `card_id` + `path` (an
 // no existing plan for an id to name yet.
 strictTool("plan_connect", 
 // DX-2735: trimmed with the problem tools to stay inside the work-profile budget.
-"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth, missedEvents}` — `missedEvents` is `{events, omitted}`: the operator events on this plan that no session had been told about before you connected, oldest first, newest 50 at most (`omitted` counts older ones) — read them before anything else. `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the plan read + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated plan-write tool) acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape the plan list/get routes report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. An action the operator DECLINES arrives as `... rejected the action \"<title>\" for \"<statement>\" — reason: \"<note>\". Do not perform it; re-plan from the reason` (a decision with `outcome: \"rejected\"` — never treat it as work done). Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself. The response's `reminders[]` (when present) carries the mantra — read and follow it.", {
+"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth, missedEvents}` — `missedEvents` is `{events, omitted}`: the operator events on this plan that no session had been told about before you connected, oldest first, capped to the newest few (`omitted` counts the older ones left out) — read them before anything else. `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the plan read + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated plan-write tool) acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape the plan list/get routes report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. An action the operator DECLINES arrives as `... rejected the action \"<title>\" for \"<statement>\" — reason: \"<note>\". Do not perform it; re-plan from the reason` (a decision with `outcome: \"rejected\"` — never treat it as work done). Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself. The response's `reminders[]` (when present) carries the mantra — read and follow it.", {
     plan_id: z.number().int().positive().describe("The plan id, from the plans list (`danxbot_api` `GET /api/plans`)."),
     title: z
         .string()

package/dist/restart-notice.js

@@ -9,7 +9,7 @@
  * working was unattended: six operator answers sat unread for an hour on
  * 2026-10-01. The session's own connection record cannot help (it is the new
  * session's, and does not exist yet); the PREVIOUS session's record can, found by
- * the project key `plan_connect` wrote into it (`findPredecessorConnection`).
+ * the project key `plan_connect` wrote into it (`findPredecessorCandidates`).
  *
  * THE CONTRACT, which `event-hook.sh` reads by exit code:
  *   - exit 0, text on stdout: say this to the agent (the registry's
@@ -26,9 +26,15 @@
  * connected it. READ-ONLY: it advances no cursor on the server.
  */
 import { SESSION_ID_HEADER, resolveBridgeOptions } from "./bridge.js";
-import { findPredecessorConnection, projectKeyOf } from "./session-connection.js";
+import { findPredecessorCandidates, projectKeyOf } from "./session-connection.js";
 export const RESTART_NOTICE_SUBCOMMAND = "restart-notice";
 export const RESTART_NOTICE_REQUEST_TIMEOUT_MS = 5_000;
+/**
+ * How many earlier sessions of the project one run asks about, newest first. Many
+ * sessions share one checkout and the dashboard answers "nothing" for a LIVE sibling
+ * (it is not a predecessor), so the newest candidate is often not the one.
+ */
+export const RESTART_NOTICE_MAX_CANDIDATES = 10;
 /** The registry row whose text is the notice (`src/issues/reminders/seed.yaml`). */
 export const RESTART_NOTICE_REMINDER_KEY = "plan_restart.waiting_events";
 const USAGE = `usage: CLAUDE_CODE_SESSION_ID=<session-id> danx-dashboard-mcp ${RESTART_NOTICE_SUBCOMMAND} [--cwd <project directory>]`;
@@ -105,36 +111,31 @@ resolveFrom = {}) {
         process.stderr.write(`no_session_id: CLAUDE_CODE_SESSION_ID is not set\n${USAGE}\n`);
         return 1;
     }
-    let predecessor;
-    try {
-        predecessor = findPredecessorConnection(projectKeyOf(cwd), sessionId, resolveFrom);
-    }
-    catch (err) {
-        process.stderr.write(`unreadable_records: ${err.message}\n`);
-        return 1;
-    }
-    if (predecessor === null)
-        return 0;
-    let options;
-    try {
-        options = resolveBridgeOptions({ sessionId: predecessor.sessionId, resumeIds: [] }, env, resolveFrom);
-    }
-    catch (err) {
-        const start = err;
-        process.stderr.write(`${start.reason}: ${start.message}. Fix: ${start.fix}.\n`);
-        return 1;
-    }
-    const output = await fetchRestartNotice({
-        dashboardUrl: options.dashboardUrl,
-        token: options.token,
-        predecessorId: predecessor.sessionId,
-        askingSessionId: sessionId,
-    }, { fetch: (input, init) => fetch(input, init), requestTimeoutMs: RESTART_NOTICE_REQUEST_TIMEOUT_MS });
-    if (!output.ok) {
-        process.stderr.write(`${output.reason}: could not ask the dashboard what the previous session of this project was working\n`);
-        return 1;
+    const candidates = findPredecessorCandidates(projectKeyOf(cwd), sessionId, resolveFrom).slice(0, RESTART_NOTICE_MAX_CANDIDATES);
+    for (const predecessor of candidates) {
+        let options;
+        try {
+            options = resolveBridgeOptions({ sessionId: predecessor.sessionId, resumeIds: [] }, env, resolveFrom);
+        }
+        catch (err) {
+            const start = err;
+            process.stderr.write(`${start.reason}: ${start.message}. Fix: ${start.fix}.\n`);
+            return 1;
+        }
+        const output = await fetchRestartNotice({
+            dashboardUrl: options.dashboardUrl,
+            token: options.token,
+            predecessorId: predecessor.sessionId,
+            askingSessionId: sessionId,
+        }, { fetch: (input, init) => fetch(input, init), requestTimeoutMs: RESTART_NOTICE_REQUEST_TIMEOUT_MS });
+        if (!output.ok) {
+            process.stderr.write(`${output.reason}: could not ask the dashboard what the previous session of this project was working\n`);
+            return 1;
+        }
+        if (output.text !== null) {
+            process.stdout.write(output.text);
+            return 0;
+        }
     }
-    if (output.text !== null)
-        process.stdout.write(output.text);
     return 0;
 }

package/dist/session-connection.js

@@ -31,16 +31,25 @@
  */
 import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, win32 } from "node:path";
 /** One canonical shape (CLAUDE.md Core Principle 1) — a record of any other version is refused, never adapted. */
 // DX-3928 — v2 adds `projectKey`, the directory the connecting session ran in, so a
 // restarted session (a NEW session id, no record of its own) can find which plan the
-// previous session of the same project was on (`findPredecessorConnection`).
+// previous session of the same project was on (`findPredecessorCandidates`).
 export const SESSION_CONNECTION_SCHEMA_VERSION = 2;
 export const STALE_RECORD_MS = 7 * 24 * 60 * 60 * 1000;
-/** DX-3928 — the one definition of "the same project": the resolved working directory. */
+/**
+ * DX-3928 — the one definition of "the same project": the resolved working
+ * directory, normalised so the SAME directory reached two ways compares equal.
+ * A Windows path is written with forward slashes and a lower-case drive letter
+ * (`C:\Work\p` and `c:/Work/p` are one key), because the MCP server and the
+ * plugin's hook can each report the cwd in either spelling.
+ */
 export function projectKeyOf(cwd) {
-    return resolve(cwd);
+    if (!/^[A-Za-z]:[\\/]/.test(cwd))
+        return resolve(cwd);
+    const resolved = win32.resolve(cwd).replace(/\\/g, "/");
+    return resolved[0].toLowerCase() + resolved.slice(1);
 }
 export function sessionConnectionDir(home = homedir()) {
     return join(home, ".config", "danxbot", "plan-sessions");
@@ -184,16 +193,18 @@ export function invalidRecordReason(value) {
     return `source.kind is ${JSON.stringify(source.kind)}, which this version does not know`;
 }
 /**
- * DX-3928 — the record of the session that ran in `projectKey` before
- * `currentSessionId`: the newest record for that project, written by another
- * session, within `STALE_RECORD_MS`. `null` when there is none.
+ * DX-3928 — the records of the sessions that ran in `projectKey` before
+ * `currentSessionId`, NEWEST FIRST: other sessions' records for that project,
+ * within `STALE_RECORD_MS`. Which of them is a real predecessor (not a live
+ * sibling in the same checkout) is the dashboard's call, not this reader's, so
+ * all candidates are returned; the caller asks about them in order.
  *
  * A record that cannot be understood (another schema version, not JSON) is
  * SKIPPED here and nowhere else: this answers "was a plan being worked in this
  * project", and a record from an older server cannot say. Every consumer of a
  * session's OWN record (`readSessionConnection`) still fails loud.
  */
-export function findPredecessorConnection(projectKey, currentSessionId, options = {}) {
+export function findPredecessorCandidates(projectKey, currentSessionId, options = {}) {
     const dir = sessionConnectionDir(options.home ?? homedir());
     const now = options.now ?? Date.now();
     let names;
@@ -201,9 +212,9 @@ export function findPredecessorConnection(projectKey, currentSessionId, options
         names = readdirSync(dir);
     }
     catch {
-        return null; // nothing written yet
+        return []; // nothing written yet
     }
-    let newest = null;
+    const found = [];
     for (const name of names) {
         if (!name.endsWith(".json"))
             continue;
@@ -222,8 +233,7 @@ export function findPredecessorConnection(projectKey, currentSessionId, options
         const connectedAt = Date.parse(record.connectedAt);
         if (!Number.isFinite(connectedAt) || now - connectedAt > STALE_RECORD_MS)
             continue;
-        if (newest === null || connectedAt > Date.parse(newest.connectedAt))
-            newest = record;
+        found.push({ record, connectedAt });
     }
-    return newest;
+    return found.sort((x, y) => y.connectedAt - x.connectedAt).map((f) => f.record);
 }

package/dist/session-stats.js

@@ -143,7 +143,7 @@ export class OperatorSessionStats {
         // Replays are credited (the ledger is idempotent) and marked so the
         // collector's own estimate never counts them twice; the bridge has no
         // side-effecting transcript subscriber to skip them for.
-        watcher.onEntry((entry, meta) => this.usage.observeEntry(entry, meta.replay));
+        watcher.onUsageLine((raw, meta) => this.usage.observeRawLine(raw, meta));
         watcher.onEntry(activities.onEntry);
         this.watcher = watcher;
         void watcher

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.204",
+  "version": "0.1.206",
   "description": "Stdio MCP server fronting danxbot's dashboard API for agents (operator sessions and dispatched workers alike): the generic danxbot_api/danxbot_api_list/danxbot_api_spec tools reach any route the caller's credential may call, plus dedicated agent-specific tools (plan_connect, danxbot_complete, and other per-dispatch lifecycle callbacks) (DX-3465, PLN-11 R-25).",
   "license": "MIT",
   "type": "module",
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@thehammer/danx-session-telemetry": "0.1.22",
+    "@thehammer/danx-session-telemetry": "0.1.23",
     "zod": "^3.25.76"
   },
   "devDependencies": {