@agentdeck/bridge 1.0.20 → 1.0.21

package/dist/daemon-settings.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `settings.json` access for the daemon — one reader, one writer.
+ *
+ * The reader was private to `daemon-server.ts`, which meant anything else that
+ * needed a setting either re-implemented the cross-directory discovery or, as
+ * the device-settings modules do, hardcoded `homedir()/.agentdeck` and lost the
+ * `AGENTDECK_DATA_DIR` override (roadmap item 14). Extracted here so a second
+ * consumer inherits the discovery rules rather than a copy of them.
+ *
+ * Read and write are deliberately asymmetric:
+ *
+ * - **Read** looks at every candidate data dir and takes the NEWEST file. A CLI
+ *   world and an app world can both be installed, and the most recently written
+ *   file is the one the user last edited.
+ * - **Write** touches only `getDataDir()` — this process's own directory. A
+ *   cross-directory write would reach into another install's state (and, on
+ *   macOS, into a sandbox container this process cannot legally touch).
+ */
+/**
+ * Newest `settings.json` across candidate data dirs — mirrors the
+ * daemon.json/sessions.json cross-dir discovery (and honors the
+ * AGENTDECK_DATA_DIR test override, which the hardcoded `~/.agentdeck` path in
+ * the device-settings modules ignores). The App Store sandbox container is
+ * intentionally NOT a candidate (TCC hang risk — see `getCandidateDataDirs`),
+ * so settings written by the sandboxed Swift app stay invisible here; that
+ * coexistence limit is documented in docs/appstore-feature-matrix.md.
+ *
+ * Never throws: an absent, unreadable or malformed file yields `{}`, so a
+ * setting's fallback is always the one its own reader defines.
+ */
+export declare function loadDaemonSettings(): Record<string, unknown>;
+/**
+ * Read-modify-write one key of this process's own `settings.json`.
+ *
+ * `undefined` deletes the key rather than storing a null — a persisted setting
+ * that has been cleared must be indistinguishable from one that was never set,
+ * or every reader needs a third case.
+ *
+ * The write is tmp+rename like every other file this daemon owns: settings.json
+ * is read by the daemon, the CLI and the device modules, and a half-written
+ * file reads as `{}` — which is to say, as every default at once.
+ */
+export declare function updateDaemonSetting(key: string, value: unknown): void;
+/** Absolute path of the `settings.json` this process writes to. */
+export declare function ownSettingsPath(): string;
+//# sourceMappingURL=daemon-settings.d.ts.map

package/dist/daemon-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-settings.d.ts","sourceRoot":"","sources":["../src/daemon-settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAa5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAgBrE;AAED,mEAAmE;AACnE,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/daemon-settings.js

@@ -0,0 +1,85 @@
+/**
+ * `settings.json` access for the daemon — one reader, one writer.
+ *
+ * The reader was private to `daemon-server.ts`, which meant anything else that
+ * needed a setting either re-implemented the cross-directory discovery or, as
+ * the device-settings modules do, hardcoded `homedir()/.agentdeck` and lost the
+ * `AGENTDECK_DATA_DIR` override (roadmap item 14). Extracted here so a second
+ * consumer inherits the discovery rules rather than a copy of them.
+ *
+ * Read and write are deliberately asymmetric:
+ *
+ * - **Read** looks at every candidate data dir and takes the NEWEST file. A CLI
+ *   world and an app world can both be installed, and the most recently written
+ *   file is the one the user last edited.
+ * - **Write** touches only `getDataDir()` — this process's own directory. A
+ *   cross-directory write would reach into another install's state (and, on
+ *   macOS, into a sandbox container this process cannot legally touch).
+ */
+import { readFileSync, writeFileSync, mkdirSync, renameSync, statSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { getCandidateDataDirs, getDataDir } from './session-registry.js';
+/**
+ * Newest `settings.json` across candidate data dirs — mirrors the
+ * daemon.json/sessions.json cross-dir discovery (and honors the
+ * AGENTDECK_DATA_DIR test override, which the hardcoded `~/.agentdeck` path in
+ * the device-settings modules ignores). The App Store sandbox container is
+ * intentionally NOT a candidate (TCC hang risk — see `getCandidateDataDirs`),
+ * so settings written by the sandboxed Swift app stay invisible here; that
+ * coexistence limit is documented in docs/appstore-feature-matrix.md.
+ *
+ * Never throws: an absent, unreadable or malformed file yields `{}`, so a
+ * setting's fallback is always the one its own reader defines.
+ */
+export function loadDaemonSettings() {
+    let best = null;
+    for (const dir of getCandidateDataDirs()) {
+        try {
+            const path = join(dir, 'settings.json');
+            const mtime = statSync(path).mtimeMs;
+            if (best && best.mtime >= mtime)
+                continue;
+            best = { mtime, parsed: JSON.parse(readFileSync(path, 'utf-8')) };
+        }
+        catch {
+            // Missing or unreadable — skip this candidate.
+        }
+    }
+    return best?.parsed ?? {};
+}
+/**
+ * Read-modify-write one key of this process's own `settings.json`.
+ *
+ * `undefined` deletes the key rather than storing a null — a persisted setting
+ * that has been cleared must be indistinguishable from one that was never set,
+ * or every reader needs a third case.
+ *
+ * The write is tmp+rename like every other file this daemon owns: settings.json
+ * is read by the daemon, the CLI and the device modules, and a half-written
+ * file reads as `{}` — which is to say, as every default at once.
+ */
+export function updateDaemonSetting(key, value) {
+    const dir = getDataDir();
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, 'settings.json');
+    let settings = {};
+    try {
+        settings = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        // Missing or malformed — start from empty rather than refusing to write.
+    }
+    if (value === undefined)
+        delete settings[key];
+    else
+        settings[key] = value;
+    const tmp = join(dir, `.settings.${randomUUID()}.tmp`);
+    writeFileSync(tmp, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    renameSync(tmp, path);
+}
+/** Absolute path of the `settings.json` this process writes to. */
+export function ownSettingsPath() {
+    return join(getDataDir(), 'settings.json');
+}
+//# sourceMappingURL=daemon-settings.js.map

package/dist/daemon-settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-settings.js","sourceRoot":"","sources":["../src/daemon-settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAClF,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB;IAChC,IAAI,IAAI,GAA8D,IAAI,CAAC;IAC3E,KAAK,MAAM,GAAG,IAAI,oBAAoB,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;YACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;YACrC,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,KAAK;gBAAE,SAAS;YAC1C,IAAI,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAA4B,EAAE,CAAC;QAC/F,CAAC;QAAC,MAAM,CAAC;YACP,+CAA+C;QACjD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAW,EAAE,KAAc;IAC7D,MAAM,GAAG,GAAG,UAAU,EAAE,CAAC;IACzB,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACpC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;IACxC,IAAI,QAAQ,GAA4B,EAAE,CAAC;IAC3C,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAA4B,CAAC;IAChF,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;IACD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;;QACzC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAE3B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,aAAa,UAAU,EAAE,MAAM,CAAC,CAAC;IACvD,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACtE,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACxB,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,CAAC,UAAU,EAAE,EAAE,eAAe,CAAC,CAAC;AAC7C,CAAC"}

package/dist/daemon-takeover.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What `agentdeck daemon start` does about a daemon already answering on the
+ * port it wants.
+ *
+ * This used to live inline in the CLI action, which made it untestable and hid
+ * how much trust it extends: it ADOPTS the incumbent's pairing token and can
+ * ask it to stand down or shut down — all on the strength of `/health`
+ * answering on 127.0.0.1. That was right when the only two daemons on a
+ * machine were the Node CLI and the macOS app belonging to the same human. On
+ * a shared host it is a credential leak in one direction and a denial of
+ * service in the other: user B's `daemon start` copies user A's token into B's
+ * home, then demotes A's daemon (see docs/ENTERPRISE-ROADMAP.md §1.2, §1.3).
+ *
+ * So the decision now asks who owns the incumbent process before doing either.
+ * Everything with an effect is a dependency, which is what lets a test drive
+ * this against a foreign-owned incumbent and prove the adopt and the
+ * stand-down never happened — a truth table over the ownership predicate would
+ * stay green while this function forgot to call it.
+ */
+import { type LocalPeerOwnership } from './auth.js';
+/** The subset of `/health` this decision reads. */
+export interface IncumbentHealth {
+    mode?: string;
+    pid?: number;
+    isSwift?: boolean;
+    pairingToken?: string;
+}
+/**
+ * Everything with an effect is required, not optional-with-a-default. A
+ * defaulted `standDown` that resolves false reads as "the app refused" and a
+ * defaulted `waitForBindable` as "the port never came back" — so a caller that
+ * forgot to wire one would take a fallback port and log a hardware excuse for
+ * it, silently and plausibly. Making them required turns that into a type
+ * error. Only the two dependencies whose real implementation is always correct
+ * (ownership, logging) carry defaults.
+ */
+export interface TakeoverDeps {
+    ownership?: (pid: number | null | undefined) => LocalPeerOwnership;
+    log?: (msg: string) => void;
+    /** Returns true when the served token actually changed. */
+    adoptToken: (token: unknown) => boolean;
+    standDown: (port: number) => Promise<boolean>;
+    shutdown: (port: number) => Promise<void>;
+    waitForExit: (port: number, timeoutMs: number) => Promise<boolean>;
+    waitForBindable: (port: number, timeoutMs: number) => Promise<boolean>;
+}
+export type TakeoverOutcome = 
+/** Nothing in the way (or it yielded) — go bind. */
+'proceed'
+/** Our own daemon is already serving this port; exit 0. */
+ | 'already-running'
+/** The user asked for a port we must not take. Exit 1 with the reason. */
+ | 'refuse';
+/**
+ * True when a daemon answering on this machine belongs to a DIFFERENT OS user,
+ * and must therefore be left alone entirely: not evicted, not stood down, not
+ * conceded to, not adopted from.
+ *
+ * The daemon's own startup sweeps the whole port window and shuts down every
+ * Swift daemon it finds there, which on a shared host means shutting down a
+ * coworker's macOS app the moment this user starts a CLI daemon. Only
+ * `other-user` — a definite refusal from the OS — blocks; `unknown` stays
+ * permissive for the same reason it does everywhere else (see
+ * `localPeerOwnership`), so a peer that reports no pid keeps working exactly
+ * as it did before.
+ */
+export declare function isForeignDaemon(health: {
+    pid?: number;
+} | null | undefined, ownership?: (pid: number | null | undefined) => LocalPeerOwnership): boolean;
+export declare function negotiateIncumbentDaemon(args: {
+    port: number;
+    incumbent: IncumbentHealth | null;
+    portWasExplicit: boolean;
+}, deps: TakeoverDeps): Promise<TakeoverOutcome>;
+//# sourceMappingURL=daemon-takeover.d.ts.map

package/dist/daemon-takeover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-takeover.d.ts","sourceRoot":"","sources":["../src/daemon-takeover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAGxE,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,KAAK,kBAAkB,CAAC;IACnE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,2DAA2D;IAC3D,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACxC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE;AAED,MAAM,MAAM,eAAe;AACzB,oDAAoD;AAClD,SAAS;AACX,2DAA2D;GACzD,iBAAiB;AACnB,0EAA0E;GACxE,QAAQ,CAAC;AAEb;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAC3C,SAAS,GAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,KAAK,kBAAuC,GACrF,OAAO,CAET;AASD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,EACnF,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,eAAe,CAAC,CAmG1B"}

package/dist/daemon-takeover.js

@@ -0,0 +1,137 @@
+/**
+ * What `agentdeck daemon start` does about a daemon already answering on the
+ * port it wants.
+ *
+ * This used to live inline in the CLI action, which made it untestable and hid
+ * how much trust it extends: it ADOPTS the incumbent's pairing token and can
+ * ask it to stand down or shut down — all on the strength of `/health`
+ * answering on 127.0.0.1. That was right when the only two daemons on a
+ * machine were the Node CLI and the macOS app belonging to the same human. On
+ * a shared host it is a credential leak in one direction and a denial of
+ * service in the other: user B's `daemon start` copies user A's token into B's
+ * home, then demotes A's daemon (see docs/ENTERPRISE-ROADMAP.md §1.2, §1.3).
+ *
+ * So the decision now asks who owns the incumbent process before doing either.
+ * Everything with an effect is a dependency, which is what lets a test drive
+ * this against a foreign-owned incumbent and prove the adopt and the
+ * stand-down never happened — a truth table over the ownership predicate would
+ * stay green while this function forgot to call it.
+ */
+import { localPeerOwnership } from './auth.js';
+import { log as defaultLog } from './logger.js';
+/**
+ * True when a daemon answering on this machine belongs to a DIFFERENT OS user,
+ * and must therefore be left alone entirely: not evicted, not stood down, not
+ * conceded to, not adopted from.
+ *
+ * The daemon's own startup sweeps the whole port window and shuts down every
+ * Swift daemon it finds there, which on a shared host means shutting down a
+ * coworker's macOS app the moment this user starts a CLI daemon. Only
+ * `other-user` — a definite refusal from the OS — blocks; `unknown` stays
+ * permissive for the same reason it does everywhere else (see
+ * `localPeerOwnership`), so a peer that reports no pid keeps working exactly
+ * as it did before.
+ */
+export function isForeignDaemon(health, ownership = localPeerOwnership) {
+    return ownership(health?.pid) === 'other-user';
+}
+/** 12s: `waitForDaemonExit` only proves the daemon stopped ANSWERING. */
+const EXIT_WAIT_MS = 12_000;
+/** 30s, and not padding: macOS keeps a NECP reservation on a cancelled
+ *  listener's port for ~14s, during which `lsof` shows no sockets at all and
+ *  bind() still returns EADDRINUSE (measured 2026-08-06 — bindable at ~17s). */
+const BINDABLE_WAIT_MS = 30_000;
+export async function negotiateIncumbentDaemon(args, deps) {
+    const { port, incumbent, portWasExplicit } = args;
+    if (incumbent?.mode !== 'daemon')
+        return 'proceed';
+    const log = deps.log ?? defaultLog;
+    const ownership = (deps.ownership ?? localPeerOwnership)(incumbent.pid);
+    if (ownership === 'other-user') {
+        // Neither half of the handover is available across users. Adopting would
+        // copy their credential into this user's home; standing them down would
+        // let any local account demote any other's daemon. Both are refused
+        // together — a daemon we may not talk to is also one we may not take the
+        // port from.
+        log(`Port ${port} is held by a daemon belonging to another user on this machine.`);
+        log(`Not adopting its pairing token and not asking it to stand down — a daemon is per-user.`);
+        if (portWasExplicit) {
+            log(`Choose another port with -p, or ask that user to stop their daemon.`);
+            return 'refuse';
+        }
+        log(`Starting on a free port instead; clients of yours resolve it from your own daemon.json.`);
+        return 'proceed';
+    }
+    if (ownership === 'unknown') {
+        // Permissive on purpose (see `localPeerOwnership`), but never silently:
+        // this is the branch where a token crosses a process boundary without
+        // proof of who is on the other side.
+        log(`Could not confirm which user owns the daemon on port ${port} (it reports no pid) — `
+            + `proceeding as if it were yours.`);
+    }
+    // Take over the fleet's credential along with the port. The app's daemon
+    // keeps its token inside its sandbox container, unreadable from here, so
+    // this loopback answer is the only place we can learn what every paired
+    // board is currently holding. Adopting it BEFORE the stand-down means the
+    // handover costs no device its pairing.
+    if (deps.adoptToken(incumbent.pairingToken)) {
+        log(`Adopted the incumbent daemon's pairing token so paired devices survive the handover.`);
+    }
+    if (!incumbent.isSwift) {
+        log(`Daemon already running on port ${port}. Use 'agentdeck daemon stop' first.`);
+        return 'already-running';
+    }
+    // Reverse two-tier upgrade path: the macOS app may already own the canonical
+    // port with its in-process Swift daemon (Tier 1 — limited: no ADB devices,
+    // no subscription usage, …). A plain "already running → exit" would strand
+    // the user on Tier 1. Ask it to STAND DOWN (demote to client, app keeps
+    // running) so this CLI daemon can take over with the full feature set.
+    log(`AgentDeck app's in-process daemon holds port ${port} — requesting stand-down to take over with the full CLI feature set…`);
+    // Prefer /stand-down (clean demote: the app stays running as a client).
+    // Fall back to /shutdown for older app builds that predate the endpoint.
+    let acked = await deps.standDown(port);
+    if (!acked) {
+        await deps.shutdown(port);
+        acked = true; // shutdown is best-effort (no ack body); rely on the exit wait
+    }
+    // Two conditions, not one. `waitForDaemonExit` proves the app stopped
+    // answering; `waitForBindable` proves the socket is actually gone. The app
+    // releases the port with NWListener.cancel(), which returns before the
+    // teardown completes — binding on the first signal alone is what silently
+    // demoted this daemon to the 9121 fallback and left the canonical port
+    // ownerless. The app's takeover-yield window is longer (45s), so it stays
+    // off the port until well after this wait has claimed it.
+    const yielded = acked
+        && await deps.waitForExit(port, EXIT_WAIT_MS)
+        && await deps.waitForBindable(port, BINDABLE_WAIT_MS);
+    if (yielded) {
+        log(`App daemon yielded port ${port}. Starting CLI daemon…`);
+        return 'proceed';
+    }
+    // The app yielded but the PORT did not come back, and that is often not the
+    // app's doing: a WiFi device that has gone to sleep with bytes still queued
+    // leaves its socket in LAST_ACK on this port, and TCP holds that until it
+    // exhausts retransmits — minutes, sometimes. Network.framework exposes no
+    // SO_LINGER, so the app cannot RST out of it (measured 2026-08-06: two
+    // sleeping ESP32 boards, 11901 and 4 bytes queued, were the only things left
+    // on 9120).
+    //
+    // Carry on rather than exiting. The daemon binds a fallback port and writes
+    // it to daemon.json, which is what every client resolves through and what the
+    // app itself re-reads when its yield window ends — so the deck keeps working.
+    // What must NOT happen is this being silent, which is how the canonical port
+    // ended up owned by nobody with the CLI reporting success.
+    log(`The AgentDeck app yielded port ${port} but the port has not been released `
+        + `(usually a sleeping WiFi device holding a half-closed socket on it).`);
+    if (portWasExplicit) {
+        // The port was ASKED for, not defaulted to. Quietly binding a different one
+        // would answer a question the user did not ask; an explicit choice fails
+        // loudly instead.
+        log(`Quit the AgentDeck app and retry, or choose another port.`);
+        return 'refuse';
+    }
+    log(`Starting on a fallback port instead — clients resolve it from daemon.json. `
+        + `For the canonical port, quit the AgentDeck app and retry, or pass -p.`);
+    return 'proceed';
+}
+//# sourceMappingURL=daemon-takeover.js.map

package/dist/daemon-takeover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-takeover.js","sourceRoot":"","sources":["../src/daemon-takeover.ts"],"names":[],"mappings":"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"}

package/dist/daemon.js

@@ -17,7 +17,7 @@ const program = new Command();
 program
     .name('agentdeck')
     .description('AgentDeck daemon (legacy entry point — use `agentdeck daemon` instead)')
-    .version('1.0.20');
+    .version('1.0.21');
 program
     .command('start', { isDefault: true })
     .description('Start monitoring daemon')

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * Exports `startSession()` called by cli.ts.
  * Uses BridgeCore for shared infrastructure.
  */
-import type { ModuleConfigs } from './modules/types.js';
+import { type ModuleConfigs } from './modules/types.js';
 import { type AgentType } from './types.js';
 export interface SessionOptions {
     agentType: AgentType;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6DH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAUxD,OAAO,EAOL,KAAK,SAAS,EAQf,MAAM,YAAY,CAAC;AAwDpB,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,wEAAwE;IACxE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;kFAC8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;0EACsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;gEAC4D;IAC5D,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAID,wBAAsB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAmrCtE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6DH,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAUvE,OAAO,EAOL,KAAK,SAAS,EAQf,MAAM,YAAY,CAAC;AAwDpB,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,wEAAwE;IACxE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;kFAC8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;0EACsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;gEAC4D;IAC5D,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAID,wBAAsB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA0rCtE"}

package/dist/index.js

@@ -43,6 +43,7 @@ import { DaemonWsClient } from './daemon-ws-client.js';
 import { getLanIp } from '@agentdeck/shared';
 import { migrateHooksIfNeeded } from '@agentdeck/hooks';
 import { initModules, stopModules, createDefaultModules, } from './modules/index.js';
+import { allModulesOff } from './modules/types.js';
 import { onESP32Message, sendWifiProvisionToAll, } from './esp32-serial.js';
 import { loadWifiConfig } from './wifi-config.js';
 import { getAdbDeviceCount } from './adb-reverse.js';
@@ -348,12 +349,12 @@ export async function startSession(opts) {
     });
     // ===== Device modules =====
     const moduleConfigs = {
-        ...(opts.modules ?? {
-            adb: 'auto',
-            serial: false, // daemon-only — session bridges never talk to ESP32
-            pixoo: false, // daemon-only — session bridges never talk to Pixoo
-            timebox: false, // daemon-only — session bridges never talk to Timebox
-        }),
+        // "All off, then add back ADB" rather than a literal list of the modules
+        // that were known when this was written: initModules() reads an absent key
+        // as 'auto', so every module added since arrived here switched ON. That is
+        // how `idotmatrix` ended up spawning a Python BLE client per session
+        // bridge, duplicating the daemon's own.
+        ...(opts.modules ?? { ...allModulesOff(), adb: 'auto' }),
         // Session bridges are internal hook/PTY processes. Only the daemon hub is
         // discoverable on the LAN; never advertise per-session project metadata.
         mdns: false,
@@ -468,11 +469,18 @@ export async function startSession(opts) {
         // this same event pipe — state machine, timeline, and APME all close via
         // their existing Stop paths, and a late real Stop dedups downstream.
         const turnWatchdog = new ClaudeTurnWatchdog({
-            onMissedStop: ({ transcript_path }) => {
+            onMissedStop: ({ transcript_path, reason }) => {
                 adapter.emit('event', {
                     source: 'hook',
                     event: 'Stop',
-                    data: { transcript_path, synthetic_stop: true },
+                    data: {
+                        transcript_path,
+                        synthetic_stop: true,
+                        // A user cancel and a client abort are not lost hooks — same
+                        // close, different buckets.
+                        ...(reason === 'interrupted' ? { interrupted: true } : {}),
+                        ...(reason === 'aborted' ? { aborted: true } : {}),
+                    },
                 });
             },
         });
@@ -1521,10 +1529,21 @@ function wireClaudeCodeTimeline(adapter, core) {
                         debug('agentdeck', `transcript read skipped: ${String(err)}`);
                     }
                 }
-                // APME: store Claude's response on the current turn
+                // APME: store Claude's response on the current turn, then close the
+                // turn at the Stop that produced it (response first — the trajectory
+                // event and response_kind tag read the still-active turn). The close
+                // records WHICH Stop closed it: a watchdog-injected synthetic Stop is
+                // one that the real hook dropped, and counting those is the standing
+                // measurement of hook loss (turns.end_source).
                 const apmeRef = core.getApme();
-                if (apmeRef && lastAssistantMsg) {
-                    apmeRef.collector.setTurnResponse(core.sessionId, lastAssistantMsg);
+                if (apmeRef) {
+                    if (lastAssistantMsg)
+                        apmeRef.collector.setTurnResponse(core.sessionId, lastAssistantMsg);
+                    apmeRef.collector.noteTurnStop(core.sessionId, {
+                        synthetic: evt.data?.synthetic_stop === true,
+                        interrupted: evt.data?.interrupted === true,
+                        aborted: evt.data?.aborted === true,
+                    });
                 }
                 emitCompletion(lastAssistantMsg, duration, toolSummary);
                 break;