omni-notify-mcp 1.3.307 → 1.3.308

package/dist/gateway/sessionDriver.js

@@ -101,9 +101,13 @@ function sameBoard(a, b) {
 function heldByWords(claim) {
     return `#${claim.storyId} is held by ${claim.name} (${String(claim.sessionId).replace(/^hold:/, "")}) — heartbeat ${claim.at}${claim.why === undefined ? "" : ` — why: ${claim.why}`}`;
 }
-/** The hold a conversation writes for a story: a `hold` in the conversation's own name, addressed by this machine and this process exactly as the board's engine writes one (#2838). */
-function holdOf(name, storyId, board, now) {
-    return { storyId, name, sessionId: `hold:${hostname()}:${process.pid}`, at: boardStamp(now), kind: "hold", board };
+/** The address every hold of this daemon is written under and released by (#2838). */
+function holdAddress() {
+    return `hold:${hostname()}:${process.pid}`;
+}
+/** The hold a conversation writes for a story: a `hold` in the conversation's own name, addressed by this machine and this process exactly as the board's engine writes one (#2838). `drives` names the agent session this conversation runs, so a door can tell this hold from the work of the very session it holds for (#3850). */
+function holdOf(name, storyId, board, now, drives) {
+    return { storyId, name, sessionId: holdAddress(), at: boardStamp(now), kind: "hold", board, drives };
 }
 /** The claims the file still holds at `now`, lapsed ones dropped exactly as every reader of the file drops them; a file that is not there is a machine that has claimed nothing. */
 function readClaims(file, now) {
@@ -207,12 +211,14 @@ function writeClaims(file, claims) {
     }
 }
 /** BN's conversation takes the story's hold: the holder's name IS the conversation's id, so every refusal and every door name this conversation. Another session's standing hold, or its fresh `taken` claim, refuses in the file's own words (#2838/#2040). */
-function holdStory(file, name, storyId, board, now) {
-    const claim = holdOf(name, storyId, board, now);
+function holdStory(file, name, storyId, board, now, drives) {
+    const claim = holdOf(name, storyId, board, now, drives);
     underClaimsLock(file, () => {
         const before = readClaims(file, now);
         const on = (c) => c.storyId === claim.storyId && sameBoard(c.board, board);
         const prior = before.find(on);
+        if (prior !== undefined && prior.sessionId === drives)
+            return;
         // The derived sessionId is the same for every conversation of one daemon, so a DIFFERENT conversation in this process is another holder too — its own name is what tells two of them apart, and neither may overwrite the other.
         const mine = prior !== undefined && prior.sessionId === claim.sessionId && prior.name === claim.name;
         if (prior !== undefined && !mine && (prior.kind === "hold" || claim.kind === "hold"))
@@ -222,7 +228,7 @@ function holdStory(file, name, storyId, board, now) {
 }
 /** BN drops the hold it wrote when the work on the story ends: only the claim under its own address AND its own name goes — a different conversation of this daemon shares the address and must keep its own claim (#2838). */
 function releaseStory(file, name, storyId, board, now) {
-    const mine = holdOf(name, storyId, board, now).sessionId;
+    const mine = holdAddress();
     underClaimsLock(file, () => {
         const before = readClaims(file, now);
         const isMine = (c) => c.storyId === storyId && sameBoard(c.board, board) && c.sessionId === mine && c.name === name;
@@ -679,6 +685,7 @@ export class SessionDriver {
                 let beat;
                 if (hold !== undefined) {
                     const held = hold;
+                    this.refreshHold(c.id, held);
                     beat = setInterval(() => this.refreshHold(c.id, held), HOLD_BEAT_MS);
                     beat.unref();
                 }
@@ -705,13 +712,13 @@ export class SessionDriver {
         // NULL-OK: field storyId is OPTIONAL and therefore it is ok to check for NULL
         if (storyId === undefined)
             return undefined;
-        holdStory(claimsFile(), conversationId, storyId, project, Date.now());
+        holdStory(claimsFile(), conversationId, storyId, project, Date.now(), readConversation(conversationId).sessionId);
         return { storyId, board: project };
     }
     /** The hold is refreshed so it never lapses while the turn it belongs to runs. */
     refreshHold(conversationId, hold) {
         try {
-            holdStory(claimsFile(), conversationId, hold.storyId, hold.board, Date.now());
+            holdStory(claimsFile(), conversationId, hold.storyId, hold.board, Date.now(), readConversation(conversationId).sessionId);
         }
         catch (err) {
             if (!(err instanceof Error))

package/dist/googlehome/foyer-client.js

@@ -0,0 +1,210 @@
+// The foyer-pa RPC client: builds positional `application/json+protobuf` arrays (via foyer-codec),
+// POSTs them to Google's Home Graph foyer endpoint, mints the bearer from the master token
+// (gpsoauth), and retries once on 401/403 while advancing scope negotiation.
+// Ported from coredevices/pebble-plugins `googlehome/src/foyer-client.ts` (which names the Kotlin
+// `FoyerRpcClient`/`FoyerAuthImpl` as its origin).
+import * as codec from './foyer-codec.js';
+import { FoyerAuthError } from './gpsoauth.js';
+const BASE = 'https://googlehomefoyer-pa.clients6.google.com/$rpc/google.internal.home.foyer.v1.';
+const HOME_CONTROL_SERVICE = 'HomeControlService';
+const STRUCTURES_SERVICE = 'StructuresService';
+const AUTOMATION_SERVICE = 'AutomationService';
+const CONTENT_TYPE = 'application/json+protobuf';
+// The (app, client_sig, scope) triple that yields a bearer foyer-pa accepts.
+const APP = 'com.google.android.apps.chromecast.app';
+const CLIENT_SIG = '24bb24c05e47e0aefa68a58a766179d9b613a600';
+const SCOPE_CANDIDATES = [
+    'oauth2:https://www.googleapis.com/auth/homegraph',
+    'oauth2:https://www.google.com/accounts/OAuthLogin',
+];
+/** A refusal the calling agent should read: no structure, a routine that cannot be started, … */
+export class GoogleHomeError extends Error {
+}
+export class FoyerHttpError extends GoogleHomeError {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/** Strips a leading XSSI guard line (`)]}'`) some clients6 endpoints prepend. */
+export function stripXssiPrefix(body) {
+    const trimmed = body.replace(/^\s+/, '');
+    if (trimmed.startsWith(")]}'")) {
+        return trimmed.substring(4).replace(/^[\r\n]+/, '');
+    }
+    return body;
+}
+/** Mints + caches short-lived foyer bearers from the master token, with scope negotiation. */
+export class FoyerAuth {
+    masterToken;
+    androidId;
+    oauth;
+    scopes;
+    app;
+    clientSig;
+    fallbackTtlSeconds;
+    expirySkewSeconds;
+    nowEpochSeconds;
+    cachedToken = null;
+    expiresAtEpoch = 0;
+    scopeIndex = 0;
+    constructor(masterToken, androidId, oauth, scopes = SCOPE_CANDIDATES, app = APP, clientSig = CLIENT_SIG, fallbackTtlSeconds = 55 * 60, expirySkewSeconds = 60, nowEpochSeconds = () => Math.floor(Date.now() / 1000)) {
+        this.masterToken = masterToken;
+        this.androidId = androidId;
+        this.oauth = oauth;
+        this.scopes = scopes;
+        this.app = app;
+        this.clientSig = clientSig;
+        this.fallbackTtlSeconds = fallbackTtlSeconds;
+        this.expirySkewSeconds = expirySkewSeconds;
+        this.nowEpochSeconds = nowEpochSeconds;
+    }
+    async bearer() {
+        const now = this.nowEpochSeconds();
+        if (this.cachedToken != null && now < this.expiresAtEpoch)
+            return this.cachedToken;
+        return this.mint(now);
+    }
+    invalidate() {
+        this.cachedToken = null;
+        this.expiresAtEpoch = 0;
+        this.scopeIndex = this.scopes.length === 0 ? 0 : (this.scopeIndex + 1) % this.scopes.length;
+    }
+    async mint(now) {
+        if (this.scopes.length === 0)
+            throw new FoyerAuthError('no foyer scope candidates configured; cannot mint a bearer');
+        let lastError = null;
+        for (let offset = 0; offset < this.scopes.length; offset++) {
+            const i = (this.scopeIndex + offset) % this.scopes.length;
+            try {
+                const token = await this.oauth.getAuthToken(this.masterToken, this.androidId, this.scopes[i], this.app, this.clientSig);
+                this.scopeIndex = i;
+                this.cachedToken = token.auth;
+                this.expiresAtEpoch = this.deadlineFor(token.expiryEpochSeconds, now);
+                return token.auth;
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e : new FoyerAuthError(String(e));
+            }
+        }
+        throw lastError instanceof Error ? lastError : new FoyerAuthError('no foyer scope candidates could be minted');
+    }
+    deadlineFor(expiryEpochSeconds, now) {
+        const cap = now + this.fallbackTtlSeconds;
+        const base = expiryEpochSeconds != null && expiryEpochSeconds > now ? Math.min(expiryEpochSeconds, cap) : cap;
+        return base - this.expirySkewSeconds;
+    }
+}
+export class FoyerClient {
+    auth;
+    constructor(auth) {
+        this.auth = auth;
+    }
+    // Reads ---------------------------------------------------------------------------------------
+    async fetchHomeGraph() {
+        const resp = await this.rpc(STRUCTURES_SERVICE, 'GetHomeGraph', []);
+        return codec.parseGetHomeGraph(resp);
+    }
+    async getHomeGraph() {
+        const g = await this.fetchHomeGraph();
+        return { homes: g.homes, devices: g.devices };
+    }
+    async listRooms() {
+        return (await this.fetchHomeGraph()).rooms;
+    }
+    async getTraits(deviceIds) {
+        if (deviceIds.length === 0)
+            return [];
+        const resp = await this.rpc(HOME_CONTROL_SERVICE, 'GetTraits', codec.buildGetTraitsRequest(deviceIds));
+        return codec.parseGetTraits(resp);
+    }
+    // Control (existing devices only; no add/delete) ----------------------------------------------
+    async setOnOff(deviceId, agentId, partnerDeviceId, on) {
+        return this.update(deviceId, codec.buildOnOff(deviceId, agentId, partnerDeviceId, on), on);
+    }
+    async setBrightness(deviceId, agentId, partnerDeviceId, pct) {
+        return this.update(deviceId, codec.buildBrightness(deviceId, agentId, partnerDeviceId, clamp(pct, 0, 100)));
+    }
+    async setColorTemperature(deviceId, agentId, partnerDeviceId, kelvin) {
+        return this.update(deviceId, codec.buildColorTemperature(deviceId, agentId, partnerDeviceId, kelvin));
+    }
+    async setVolume(deviceId, agentId, partnerDeviceId, pct) {
+        return this.update(deviceId, codec.buildVolume(deviceId, agentId, partnerDeviceId, clamp(pct, 0, 100)));
+    }
+    async setMuted(deviceId, agentId, partnerDeviceId, muted) {
+        return this.update(deviceId, codec.buildMuted(deviceId, agentId, partnerDeviceId, muted));
+    }
+    async listAutomations() {
+        const structureId = (await this.fetchHomeGraph()).homes[0]?.id;
+        if (structureId == null)
+            throw new GoogleHomeError('no home/structure found; cannot list routines');
+        const resp = await this.rpc(AUTOMATION_SERVICE, 'ListAutomations', codec.buildListAutomationsRequest(structureId));
+        return codec.parseListAutomations(resp);
+    }
+    async runAutomation(automation) {
+        if (!automation.manuallyRunnable) {
+            throw new GoogleHomeError(`routine '${automation.name}' is condition/schedule-triggered and can't be started on demand`);
+        }
+        const structureId = (await this.fetchHomeGraph()).homes[0]?.id;
+        if (structureId == null)
+            throw new GoogleHomeError('no home/structure found; cannot run a routine');
+        const resp = await this.rpc(AUTOMATION_SERVICE, 'ExecuteAutomation', codec.buildExecuteAutomationRequest(structureId, automation.id));
+        return Array.isArray(resp) && resp.length > 0 && String(resp[0]) === '1';
+    }
+    // Internals -----------------------------------------------------------------------------------
+    async update(deviceId, body, fallbackOnOff) {
+        const resp = await this.rpc(HOME_CONTROL_SERVICE, 'UpdateTraits', body);
+        const echoed = codec.parseGetTraits(resp).find((s) => s.id === deviceId);
+        if (echoed)
+            return echoed;
+        const readback = (await this.getTraits([deviceId])).find((s) => s.id === deviceId);
+        if (readback)
+            return readback;
+        return {
+            id: deviceId,
+            online: true,
+            onOff: fallbackOnOff ?? null,
+            brightnessPct: null,
+            colorTemperatureK: null,
+            volumePct: null,
+            muted: null,
+            locked: null,
+            jammed: null,
+            thermostatMode: null,
+            setpointC: null,
+            setpointF: null,
+            ambientC: null,
+            temperatureUnit: null,
+        };
+    }
+    /** POSTs body to `<BASE><service>/<method>`; on 401/403 invalidates + retries once. */
+    async rpc(service, method, body) {
+        const url = `${BASE}${service}/${method}`;
+        const bodyJson = JSON.stringify(body);
+        let response = await this.post(url, bodyJson, await this.auth.bearer());
+        if (response.status === 401 || response.status === 403) {
+            this.auth.invalidate();
+            response = await this.post(url, bodyJson, await this.auth.bearer());
+        }
+        if (response.status < 200 || response.status > 299) {
+            throw new FoyerHttpError(response.status, `google home ${service}/${method} -> HTTP ${response.status}: ${response.body.substring(0, 300)}`);
+        }
+        return JSON.parse(stripXssiPrefix(response.body));
+    }
+    async post(url, bodyJson, bearer) {
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${bearer}`,
+                'X-User-Agent': 'grpc-web-javascript/0.1',
+                'Content-Type': CONTENT_TYPE,
+            },
+            body: bodyJson,
+        });
+        return { status: resp.status, body: await resp.text() };
+    }
+}
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}

package/dist/googlehome/foyer-codec.js

@@ -0,0 +1,318 @@
+// Builds and parses the foyer-pa `application/json+protobuf` wire format.
+//
+// The service does NOT use JSON objects — every request/response body is a *positional* JSON array
+// where protobuf field numbers map to array indices (1-based, with `null` holes for absent fields).
+// Ported from coredevices/pebble-plugins `googlehome/src/foyer-codec.ts` (which names the Kotlin
+// `FoyerCodec` as its origin); the field indices were derived from live captures.
+//
+// Value encoding (the scalar wrapper `[i0,i1,i2,i3,…]`): a value sits at a type-specific index:
+//   - int / float  -> index 1: [null, <num>]
+//   - string / enum-> index 2: [null, null, "<str>"]
+//   - bool         -> index 3: [null, null, null, <0|1>]
+/** The type used for matching: user-assigned type when set, else hardware type. */
+export function effectiveType(d) {
+    return d.assignedType && d.assignedType.trim() !== '' ? d.assignedType : d.type;
+}
+// -------------------------------------------------------------------------------------------------
+// Null-safe positional-array accessors (out-of-range / wrong-typed slot -> null)
+// -------------------------------------------------------------------------------------------------
+function arr(x) {
+    return Array.isArray(x) ? x : null;
+}
+function at(a, i) {
+    return a != null && i >= 0 && i < a.length ? a[i] : null;
+}
+function str(x) {
+    return typeof x === 'string' ? x : null;
+}
+function boolAt(a, i) {
+    const e = at(a, i);
+    if (typeof e === 'boolean')
+        return e;
+    return e === 1;
+}
+function numAt(a, i) {
+    const e = at(a, i);
+    return typeof e === 'number' ? e : null;
+}
+function strAt(a, i) {
+    return str(at(a, i));
+}
+function arrAt(a, i) {
+    return arr(at(a, i));
+}
+// -------------------------------------------------------------------------------------------------
+// Scalar wrappers. In JS there is no int/float distinction, so intWrapper is just [null, n].
+// -------------------------------------------------------------------------------------------------
+function intWrapper(n) {
+    return [null, n];
+}
+function boolWrapper(b) {
+    return [null, null, null, b ? 1 : 0];
+}
+/** Flattens a trait body `[[fieldName,<wrapper>],…]` into a `fieldName -> wrapper` map. */
+function fieldWrappers(body) {
+    const out = new Map();
+    if (body == null)
+        return out;
+    for (const fieldEl of body) {
+        const field = arr(fieldEl);
+        const name = strAt(field, 0);
+        if (name == null)
+            continue;
+        out.set(name, arrAt(field, 1));
+    }
+    return out;
+}
+// -------------------------------------------------------------------------------------------------
+// GetTraits
+// -------------------------------------------------------------------------------------------------
+/** Request body for `HomeControlService/GetTraits`: `[[["id1"],["id2"],…]]`. */
+export function buildGetTraitsRequest(ids) {
+    return [ids.map((id) => [id])];
+}
+export function parseGetTraits(json) {
+    const results = arrAt(arr(json), 0);
+    if (results == null)
+        return [];
+    const out = [];
+    for (const result of results) {
+        const r = arr(result);
+        const id = strAt(arrAt(r, 0), 0);
+        if (id == null)
+            continue;
+        const traits = arrAt(r, 1);
+        const s = {
+            id,
+            online: false,
+            onOff: null,
+            brightnessPct: null,
+            colorTemperatureK: null,
+            volumePct: null,
+            muted: null,
+            locked: null,
+            jammed: null,
+            thermostatMode: null,
+            setpointC: null,
+            setpointF: null,
+            ambientC: null,
+            temperatureUnit: null,
+        };
+        if (traits != null) {
+            for (const entry of traits) {
+                const e = arr(entry);
+                const fields = fieldWrappers(arrAt(e, 1));
+                switch (strAt(e, 0)) {
+                    case 'deviceStatus':
+                        if (fields.has('online'))
+                            s.online = boolAt(fields.get('online') ?? null, 3);
+                        break;
+                    case 'onOff':
+                        if (fields.has('onOff'))
+                            s.onOff = boolAt(fields.get('onOff') ?? null, 3);
+                        break;
+                    case 'brightness':
+                        s.brightnessPct = numAt(fields.get('brightness') ?? null, 1);
+                        break;
+                    case 'color':
+                        s.colorTemperatureK = numAt(fields.get('colorTemperature') ?? null, 1);
+                        break;
+                    case 'volume':
+                        s.volumePct = numAt(fields.get('currentVolume') ?? null, 1);
+                        if (fields.has('isMuted'))
+                            s.muted = boolAt(fields.get('isMuted') ?? null, 3);
+                        break;
+                    case 'lockUnlock':
+                        if (fields.has('isLocked'))
+                            s.locked = boolAt(fields.get('isLocked') ?? null, 3);
+                        if (fields.has('isJammed'))
+                            s.jammed = boolAt(fields.get('isJammed') ?? null, 3);
+                        break;
+                    case 'temperatureSetting':
+                        s.thermostatMode = strAt(fields.get('mode') ?? null, 2);
+                        s.setpointC = numAt(fields.get('thermostatTemperatureSetpointC') ?? null, 1);
+                        s.setpointF = numAt(fields.get('thermostatTemperatureSetpointF') ?? null, 1);
+                        s.ambientC = numAt(fields.get('ambientAirTemperatureC') ?? null, 1);
+                        // temperatureUnit lives in the trait's params block (index 2), one array deeper.
+                        s.temperatureUnit = strAt(fieldWrappers(arrAt(arrAt(e, 2), 0)).get('temperatureUnit') ?? null, 2);
+                        break;
+                }
+            }
+        }
+        out.push(s);
+    }
+    return out;
+}
+// -------------------------------------------------------------------------------------------------
+// UpdateTraits (control)
+// -------------------------------------------------------------------------------------------------
+export function buildUpdate(deviceId, agentId, partnerDeviceId, traitName, fieldName, wrapper) {
+    const trait = [traitName, [[fieldName, wrapper]]];
+    const deviceKey = [deviceId, [agentId, partnerDeviceId]];
+    const command = [deviceKey, [trait]];
+    return [[command]];
+}
+export function buildOnOff(deviceId, agentId, partnerDeviceId, on) {
+    return buildUpdate(deviceId, agentId, partnerDeviceId, 'onOff', 'onOff', boolWrapper(on));
+}
+export function buildBrightness(deviceId, agentId, partnerDeviceId, pct) {
+    return buildUpdate(deviceId, agentId, partnerDeviceId, 'brightness', 'brightness', intWrapper(pct));
+}
+export function buildColorTemperature(deviceId, agentId, partnerDeviceId, kelvin) {
+    return buildUpdate(deviceId, agentId, partnerDeviceId, 'color', 'colorTemperature', intWrapper(kelvin));
+}
+export function buildVolume(deviceId, agentId, partnerDeviceId, pct) {
+    return buildUpdate(deviceId, agentId, partnerDeviceId, 'volume', 'currentVolume', intWrapper(pct));
+}
+export function buildMuted(deviceId, agentId, partnerDeviceId, muted) {
+    return buildUpdate(deviceId, agentId, partnerDeviceId, 'volume', 'isMuted', boolWrapper(muted));
+}
+// -------------------------------------------------------------------------------------------------
+// AutomationService (routines)
+// -------------------------------------------------------------------------------------------------
+/** `ListAutomations` request body: `[<structureId>]`. */
+export function buildListAutomationsRequest(structureId) {
+    return [structureId];
+}
+/** `ExecuteAutomation` request body: `[<structureId>, <automationId>, null, 2]`. */
+export function buildExecuteAutomationRequest(structureId, automationId) {
+    return [structureId, automationId, null, 2];
+}
+export function parseListAutomations(json) {
+    const list = arrAt(arr(json), 0);
+    if (list == null)
+        return [];
+    const out = [];
+    for (const recEl of list) {
+        const rec = arr(recEl);
+        const id = strAt(rec, 0);
+        const name = strAt(rec, 3);
+        if (id == null || name == null)
+            continue;
+        out.push({
+            id,
+            name,
+            manuallyRunnable: numAt(rec, 2) === 1,
+            starters: strAt(rec, 4),
+            actions: strAt(rec, 5),
+            triggerInput: strAt(rec, 10),
+        });
+    }
+    return out;
+}
+// -------------------------------------------------------------------------------------------------
+// Capability derivation
+// -------------------------------------------------------------------------------------------------
+export function deriveCapabilities(traits) {
+    const caps = new Set();
+    for (const raw of traits) {
+        const suffix = raw.split('.').pop()?.toLowerCase() ?? '';
+        switch (suffix) {
+            case 'onoff':
+                caps.add('on_off');
+                break;
+            case 'brightness':
+                caps.add('brightness');
+                break;
+            case 'colorsetting':
+                caps.add('color_temperature');
+                caps.add('color');
+                break;
+            case 'volume':
+                caps.add('volume');
+                break;
+            case 'lockunlock':
+                caps.add('lock');
+                break;
+            case 'temperaturesetting':
+            case 'temperaturecontrol':
+                caps.add('thermostat');
+                break;
+            case 'transportcontrol':
+            case 'mediastate':
+                caps.add('media_transport');
+                break;
+        }
+    }
+    return caps;
+}
+// -------------------------------------------------------------------------------------------------
+// GetHomeGraph (enumeration)
+// -------------------------------------------------------------------------------------------------
+export function parseGetHomeGraph(json) {
+    const homesArr = arrAt(arr(json), 1);
+    if (homesArr == null)
+        return { homes: [], devices: [], rooms: [] };
+    const homes = [];
+    const rooms = [];
+    const devices = [];
+    const deviceRoom = new Map();
+    for (const homeEl of homesArr) {
+        const home = arr(homeEl);
+        const homeId = strAt(home, 0);
+        if (homeId == null)
+            continue;
+        homes.push({ id: homeId, name: strAt(home, 1) ?? '' });
+        // Rooms: [5]
+        const roomsArr = arrAt(home, 5);
+        if (roomsArr != null) {
+            for (const roomEl of roomsArr) {
+                const room = arr(roomEl);
+                const roomId = strAt(room, 0);
+                if (roomId == null)
+                    continue;
+                const roomName = strAt(room, 2) ?? '';
+                const roomType = strAt(arrAt(room, 3), 0) ?? '';
+                const memberIds = [];
+                const members = arrAt(room, 4);
+                if (members != null) {
+                    for (const memberEl of members) {
+                        // member = [[deviceId,[agentId,partnerId]]]
+                        const devId = strAt(arrAt(arr(memberEl), 0), 0);
+                        if (devId == null)
+                            continue;
+                        memberIds.push(devId);
+                        deviceRoom.set(devId, roomName);
+                    }
+                }
+                rooms.push({ id: roomId, name: roomName, type: roomType, deviceIds: memberIds });
+            }
+        }
+        // Devices: [6]
+        const devsArr = arrAt(home, 6);
+        if (devsArr != null) {
+            for (const devEl of devsArr) {
+                const rec = arr(devEl);
+                const key = arrAt(rec, 0); // [deviceId,[agentId,partnerId]]
+                if (key == null)
+                    continue;
+                const devId = strAt(key, 0);
+                if (devId == null)
+                    continue;
+                const agentPair = arrAt(key, 1);
+                const agentId = strAt(agentPair, 0);
+                const partnerDeviceId = strAt(agentPair, 1);
+                const name = strAt(rec, 3) ?? '';
+                const type = strAt(rec, 5) ?? '';
+                // Field [20] is the USER-ASSIGNED device type; it overrides hardware type [5] for intent.
+                const assignedType = strAt(arrAt(rec, 20), 0);
+                const traitsArr = arrAt(rec, 6);
+                const traits = traitsArr == null ? [] : traitsArr.map((t) => str(t)).filter((t) => t != null);
+                devices.push({
+                    id: devId,
+                    name,
+                    type,
+                    assignedType,
+                    traits,
+                    roomName: deviceRoom.get(devId) ?? null,
+                    agentId,
+                    partnerDeviceId,
+                    capabilities: deriveCapabilities(traits),
+                });
+            }
+        }
+    }
+    // Room membership can appear after a device record within the same home; stamp again.
+    const stamped = devices.map((d) => d.roomName == null ? { ...d, roomName: deviceRoom.get(d.id) ?? null } : d);
+    return { homes, devices: stamped, rooms };
+}