@khalido/home 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to home.ts (`@khalido/home` on npm), in [Keep a Changelog](h
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-11-09
+
+Fixes from chota-bot's first live reads, on a Raspberry Pi and a Mac. No breaking changes.
+
+### Added
+
+- **`discover`:** a `stopOn` option, for an error no later pass could get past.
+
+### Changed
+
+- **cast:** `tlsConnect` gives up after 3 s, down from 10 s, so one offline device holds up a one-shot read for less. A device whose cached address fails and that discovery can't find no longer gets a second try before it shows as disconnected. `home cast` with one device down: 13.3 s to 2.3 s (Bun 1.4.4, macOS, 2026-11-09).
+
+### Fixed
+
+- **spotify:** `maxVolume`'s first-play window now opens on a start through `buffering` too: idle → buffering → playing escaped it.
+- **weather:** the text's chance of rain for today is the highest of the hours still to come, once that's lower than the day's figure and from the same source, and it says "the rest of the day". `forecast.today.rainChance` stays as the source gave it.
+- **`home discover`:** without `avahi-browse` or `dns-sd` it fails at once, naming the package, instead of after both passes.
+- **spotify:** a frame or open event from a socket that had already ended (dropped, or closed after 10 s with no message) no longer changes the state or the next socket's status.
+- **cast:** `@khalido/home/cast/serve`'s types no longer name `NodeJS.Dict`, so they compile without `@types/node`.
+- **Docs:** corrected the config parser, the printers exception to one device per connector, Daikin's `home status` address, and the weather user agent. `skills/draw-home` no longer points at private paths.
+
 ## [0.1.0] - 2026-11-08
 
 First release. Nine connectors: Hue, Daikin, Enphase, Google Cast, AirPrint printers and a Spotify Soloist speaker on the local network; Amber prices, Up Bank spending and the weather from the cloud. Each connector's README says what has run against a real device.
@@ -21,5 +42,6 @@ First release. Nine connectors: Hue, Daikin, Enphase, Google Cast, AirPrint prin
 - **Agent skills** in `skills/`: `use-home` (reading safely, connecting, the rules for writes) and `draw-home` (an SVG plan of a home and its rooms). `llms.txt` points agents at the docs.
 - **Node.** Hue and Enphase take the fetches in `@khalido/home/node`. The library runs on Bun 1.4+ and Node 24+; the `home` command needs Bun.
 
-[Unreleased]: https://github.com/khalido/home.ts/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/khalido/home.ts/compare/v0.1.1...HEAD
+[0.1.1]: https://github.com/khalido/home.ts/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/khalido/home.ts/releases/tag/v0.1.0

package/dist/connectors/cast/index.js

@@ -297,7 +297,9 @@ export function cast(config) {
                     // A cached address that fails is only stale: discover now and try where it answers, still "connecting".
                     cached = false;
                     await discover();
-                    continue;
+                    // Unless discovery can't find it: then the address is the one that just failed, and a second try only waits out the timeout. The backoff still retries.
+                    if (!lastFound || lastFound.has(id))
+                        continue;
                 }
                 const why = errorText(error);
                 // A cached address the last discovery did not find says so, as a polling connector's does.

package/dist/connectors/cast/serve.d.ts

@@ -1,11 +1,18 @@
 import type { ServeClip } from "./writes.ts";
 /** How long a clip stays served when nothing fetches it. */
 export declare const SERVE_MS = 60000;
+type NetworkAddress = {
+    family: string;
+    address: string;
+    netmask: string;
+    internal: boolean;
+};
 /** This machine's IPv4 on the subnet that holds `host`, or with no host, its first non-internal IPv4. */
-export declare function lanAddress(host?: string, interfaces?: NodeJS.Dict<import("node:os").NetworkInterfaceInfo[]>): string;
+export declare function lanAddress(host?: string, interfaces?: Record<string, NetworkAddress[] | undefined>): string;
 /**
  * Serve `bytes`: a random port, an unguessable path, the given `Content-Type` and its `Content-Length`, the whole body
  * to every GET (a player may probe before it fetches). It closes on `close()` (`announce` calls it when the clip has
  * played), when `signal` aborts, or after `SERVE_MS`. `host` is the device that will fetch it, so the address is on its network.
  */
 export declare const serveClip: ServeClip;
+export {};

package/dist/connectors/cast/tls.js

@@ -6,7 +6,7 @@ import { encode, framer, } from "./codec.js";
 // Verification is off: every Cast device presents a self-signed certificate that rotates every 48 hours, so there is
 // nothing to pin. The integration instead checks the certificate's name (`peer`, the device's id) against discovery.
 /** Open a Cast socket: TLS to host:port within `timeoutMs`, framed CastMessages in and out. */
-export const tlsConnect = ({ host, port, signal, timeoutMs = 10_000, }) => new Promise((resolve, reject) => {
+export const tlsConnect = ({ host, port, signal, timeoutMs = 3000, }) => new Promise((resolve, reject) => {
     const socket = connect({ host, port, rejectUnauthorized: false });
     let timer;
     const fail = (error) => (clearTimeout(timer),

package/dist/connectors/spotify/index.js

@@ -87,6 +87,7 @@ export function spotify(config = {}) {
     let signedIn = false; // signed out → in on this socket: the first status after it counts as a start if it is playing
     let capUntil = -Infinity;
     let capped = false; // the cap has been sent in this window
+    let startBuffering = false; // a start from idle is still buffering
     let capNote; // the last first-play lowering, in `anomaly` until the speaker goes idle
     let frameNote; // a frame the schema rejected, or an error nothing was waiting for
     let note; // a write the integration made itself that failed (the cap, interrupt's resume), in `detail`
@@ -206,7 +207,7 @@ export function spotify(config = {}) {
         frameNote = `${name} failed: ${errorText(error)}`;
         publish();
     });
-    /** Within the window after idle → playing, a volume above the cap is lowered to it, once (issue #23). */
+    /** Within the window after a start from idle, a volume above the cap is lowered to it, once (issue #23). */
     const applyCap = () => {
         if (cap === undefined ||
             capped ||
@@ -274,10 +275,14 @@ export function spotify(config = {}) {
             pending.finish();
         if ((f.type === "playback_state" || f.type === "playback_changed") &&
             f.status !== undefined) {
-            // A start is idle → playing, or a sign-in whose first status is playing: a phone picked the speaker and played (issue #23).
-            const started = f.status === "playing" && (statusKnown ? before === "idle" : signedIn);
+            // A start is idle → playing or buffering, or a sign-in whose first status is either: a phone picked the speaker and played (issue #23).
+            // Soloist's jump to 100 comes about 100 ms after `playing` (issue #23), so a start through buffering opens the window again then.
+            const started = ((f.status === "playing" || f.status === "buffering") &&
+                (statusKnown ? before === "idle" : signedIn)) ||
+                (f.status === "playing" && startBuffering);
             if (started)
                 ((capUntil = clock.now() + CAP_WINDOW_MS), (capped = false));
+            startBuffering = f.status === "buffering" && (started || startBuffering);
             signedIn = false;
             if (f.status === "idle")
                 capNote = undefined;
@@ -321,6 +326,7 @@ export function spotify(config = {}) {
             queueAsked = false;
             statusKnown = false;
             signedIn = false;
+            startBuffering = false;
             pending?.finish(offline());
             for (const w of [...waiters])
                 w(); // a write waiting to confirm stops waiting
@@ -329,7 +335,10 @@ export function spotify(config = {}) {
         };
         const stop = () => (end("stopped"), s.close());
         signal.addEventListener("abort", stop, { once: true });
+        // An ended socket's late events belong to no session: they must not touch the next socket's state.
         s.onopen = () => {
+            if (ended)
+                return;
             open = true;
             down = undefined;
             note = undefined; // a new socket: what failed on the last one is history
@@ -343,7 +352,7 @@ export function spotify(config = {}) {
                     ((whole = true), publish()); // signed in, no playback_state: connected with what there is
             });
         };
-        s.onmessage = (ev) => handle(ev.data);
+        s.onmessage = (ev) => void (ended || handle(ev.data));
         s.onerror = () => { }; // onclose follows and says it
         s.onclose = () => end("Soloist closed the socket");
     });

package/dist/connectors/weather/index.js

@@ -151,17 +151,30 @@ export function weather(config) {
 }
 /** "20:20" in the home's time zone (the runtime's when unset), or "?". */
 const hhmmIn = (iso, timeZone) => iso ? localTime(Date.parse(iso), timeZone) : "?";
-const day = (d) => d
+const day = (d, rainLeft) => d
     ? [
         d.minC === undefined && d.maxC === undefined
             ? ""
             : `${d.minC ?? "?"}–${d.maxC ?? "?"} °C`,
         d.text?.replace(/\.$/, "").toLowerCase() ?? "",
-        d.rainChance === undefined ? "" : `${d.rainChance}% chance of rain`,
+        d.rainChance === undefined
+            ? ""
+            : rainLeft !== undefined && rainLeft < d.rainChance
+                ? `${rainLeft}% chance of rain the rest of the day`
+                : `${d.rainChance}% chance of rain`,
     ]
         .filter(Boolean)
         .join(" ")
     : "?";
+/** The highest hourly chance left today, all 24 hours of it, when the hourly forecast is the same source and day as the forecast: sources are never mixed. */
+const rainLeftToday = (w, at) => {
+    if (!w.hourly || w.hourly.source !== w.forecast?.source)
+        return undefined;
+    const rest = dayBlocks(w.hourly, at, w.timeZone, [
+        { name: "rest", from: 0, to: 24 },
+    ])?.today[0];
+    return rest?.date === w.forecast.today?.date ? rest?.rainChance : undefined;
+};
 /** "rain in 30 min, ends in 55 min, 70%, 0.8 mm, moderate (google)", "raining, ends in 25 min", or "no rain for 2 h"; nothing when the forecast covers none of the window. */
 export function rainText(rain, r) {
     if (!r || !rain)
@@ -206,7 +219,7 @@ export function weatherText(w, sun) {
         : "";
     const f = w.forecast;
     const forecast = f
-        ? `today ${day(f.today)}, tomorrow ${day(f.tomorrow)} (${f.source}${f.modelled ? " modelled" : ""})`
+        ? `today ${day(f.today, rainLeftToday(w, Date.parse(sun.at)))}, tomorrow ${day(f.tomorrow)} (${f.source}${f.modelled ? " modelled" : ""})`
         : "";
     const k = w.sky;
     const skyParts = k

package/dist/discover.d.ts

@@ -119,7 +119,8 @@ export declare function addressBook(cache: AddressCache | undefined, options?: {
 /**
  * Run one discovery `passes` times, `gapMs` apart, and return the union (first answer wins). `onPass` sees each pass's
  * additions as they come; `done` ends it early once what was looked for has answered. A pass that throws adds nothing;
- * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found.
+ * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found. An error
+ * `stopOn` accepts is thrown at once: no later pass could do better.
  */
 export declare function discover<T = Found>(pass: () => Promise<T[]>, options: {
     clock: Clock;
@@ -127,6 +128,7 @@ export declare function discover<T = Found>(pass: () => Promise<T[]>, options: {
     gapMs?: number;
     key?: (t: T) => string;
     done?: (all: T[]) => boolean;
+    stopOn?: (error: unknown) => boolean;
     onPass?: (n: number, added: T[]) => void;
     signal?: AbortSignal;
 }): Promise<T[]>;

package/dist/discover.js

@@ -258,7 +258,8 @@ export function addressBook(cache, options = {}) {
 /**
  * Run one discovery `passes` times, `gapMs` apart, and return the union (first answer wins). `onPass` sees each pass's
  * additions as they come; `done` ends it early once what was looked for has answered. A pass that throws adds nothing;
- * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found.
+ * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found. An error
+ * `stopOn` accepts is thrown at once: no later pass could do better.
  */
 export async function discover(pass, options) {
     const key = options.key ?? foundKey;
@@ -272,7 +273,12 @@ export async function discover(pass, options) {
         if (options.signal?.aborted)
             break;
         ran++;
-        const answers = await pass().catch((error) => (errors.push(error), []));
+        const answers = await pass().catch((error) => {
+            if (options.stopOn?.(error))
+                throw error;
+            errors.push(error);
+            return [];
+        });
         const added = answers.filter((t) => !all.has(key(t)) && all.set(key(t), t));
         options.onPass?.(n, added);
         if (options.done?.([...all.values()]))

package/dist/energy.js

@@ -1,3 +1,4 @@
+import { kw } from "./manifest.js";
 /**
  * Within this many watts either way the grid flow reads as "balanced": a display rule for the word and the animation,
  * so a meter wobbling around zero does not flip between importing and exporting. `gridW` and `surplusW` stay as read.
@@ -77,7 +78,6 @@ export function solarLevel(now, capacityW) {
  * "balanced (-10 W)", or "" with no grid reading. Rounded for reading only; the numbers above stay as read.
  */
 export function gridText(now) {
-    const kw = (w) => `${(w / 1000).toFixed(1)} kW`;
     const rate = (c, positive, negative) => c === undefined
         ? ""
         : `, ${c >= 0 ? positive : negative} ${Math.round(Math.abs(c))} c/h`;

package/dist/finders.d.ts

@@ -1,4 +1,7 @@
 import { type AddressCache, type Connector, type Finder, type Found } from "./discover.ts";
+/** The system's mDNS tool is not installed: discovery can't run until it is. */
+export declare class MissingTool extends Error {
+}
 /**
  * Run a long-lived `dns-sd` query (or `avahi-browse`, by `command`) and return what it printed. It never exits by itself, so it is stopped once `done`
  * says the answer is in, or `quietMs` after the last output, or at `maxMs`. The system's mDNS cache usually answers in

package/dist/finders.js

@@ -12,6 +12,9 @@ import { parseAvahi, parseAvahiBrowse, parseBrowse, parseResolve, } from "./disc
 // nothing here binds UDP 5353 beside it; a slow device (the Enphase gateway took 4 s to answer a fresh query; Bun 1.4.3, 2026-10-16)
 // does not slow a scan. Without the tool the mDNS finders throw, naming it, rather than "nothing answered".
 // `fileCache` keeps the addresses discovery found in a file between runs, so the next run connects straight away.
+/** The system's mDNS tool is not installed: discovery can't run until it is. */
+export class MissingTool extends Error {
+}
 /**
  * Run a long-lived `dns-sd` query (or `avahi-browse`, by `command`) and return what it printed. It never exits by itself, so it is stopped once `done`
  * says the answer is in, or `quietMs` after the last output, or at `maxMs`. The system's mDNS cache usually answers in
@@ -38,9 +41,9 @@ export function dnsSd(argv, options = {}) {
             resolve(out));
         proc.on("error", (error) => {
             (clearTimeout(timer), clearTimeout(quiet));
-            reject(new Error(error.code === "ENOENT"
-                ? `${command} not found; mDNS discovery needs it${install ? ` (${install})` : ""}`
-                : `${command}: ${error.message}`));
+            reject(error.code === "ENOENT"
+                ? new MissingTool(`${command} not found; mDNS discovery needs it${install ? ` (${install})` : ""}`)
+                : new Error(`${command}: ${error.message}`));
         });
         proc.on("close", finish);
     });

package/docs/cli.md

@@ -3,6 +3,7 @@
 ```sh
 home <connector> [--json]     # one connector's lines: amber, cast, daikin, enphase, hue, printers, spotify, up, weather
 home [status|doctor] [--json] # each integration: connected or not, which env names it still needs, rooms
+home up transactions | categories | uncategorised | spend | categorise | tag | webhooks  # Up Bank's lists and reports; categorise and tag write
 home lights off               # one write to the whole-home group
 home room <name> on|off|<1-100>
 home scene <name>
@@ -12,7 +13,7 @@ home discover [--json] [--passes n]  # which smart-home devices answer here (mDN
 home cache [clear]            # the addresses kept between runs, or delete them so the next run discovers afresh
 home config check [path]      # validate a home config: what it would set up, secrets as set or unset by name, every problem
 home discover --write [path]  # with a config (the path, else --config or HOME_CONFIG): match what answers by identity, add new devices, update moved hosts and renamed Cast names in place
-home probe                    # read-only, no keys: Hue's public config, Daikin by UDP broadcast, the IQ Gateway's /info, each weather source, each Cast device's status
+home probe                    # read-only, no keys: Hue's public config, Daikin by UDP broadcast, the IQ Gateway's /info, each weather source, each Cast device's and printer's status
 home locate "<street address>" [--write [path]]  # latitude and longitude from OpenStreetMap's Nominatim; --write sets them in the config's location (and timezone, when absent, to this machine's)
 home cast announce --to <name> (--say "<text>" | --file <path>) [--volume 0-100]  # play a clip, then put back what was playing and the volume
 home cast volume <name> <0-100>
@@ -24,6 +25,7 @@ home spotify pause | play [link] | next | volume <0-100>  # the Soloist speaker
 ## Output
 
 - **stdout is data, stderr everything else.** Notes such as "nothing to categorise" or "no webhooks" go to stderr, so `home … | jq` never sees them.
+- **Bun on PATH.** The command starts with `#!/usr/bin/env bun`. A non-login SSH shell may not have `~/.bun/bin` on its PATH: run `PATH="$HOME/.bun/bin:$PATH" home`.
 - **`--json` shapes.** `home --json` is one object keyed by connector, with `now` (`energyNow`) first. `home <connector> --json` is that connector's object: `status`, `needs`, `access`, `detail`, `anomaly`, then its state (the weather adds `line`, its text). Lists (`home up transactions`, `uncategorised`, `spend --by merchant`) are arrays, `[]` when empty.
 - **Errors under `--json`** are one object on stderr: `{"error": "…", "code": "usage" | "auth" | "network" | "error", "fix": "home enphase login"}`; `fix` is there only when one command resolves it. In text: `home: <error> (run \`<fix>\`)`.
 - **Exit codes.** 0 success, empty results included. 1 a failure, and `home <connector>` when that connector is not `connected`, so a script can test one. 2 a wrong command, verb or argument. `home` alone lists every connector and exits 0 whatever their state.

package/docs/config.md

@@ -24,11 +24,11 @@ const home = createHome(
 - **A device entry is only how to reach it and where it is**: its identity (the Hue `bridgeId`, a Daikin's `mac`, the Enphase `serial`, a Cast `castId`), its last known `host`, a key's env name, a file's path, its `room`. What a device reports about itself (model, firmware) comes live; a note about it is a comment.
 - **Secrets are env variable names** (`"key": "AMBER_KEY"`), resolved against the `env` the caller passes; a pasted key fails the schema. Files (`ca`, `token`) are paths the caller reads, relative to the config; the library reads nothing.
 - **Problems name the field**: an unknown connector, a missing env name or a device in a missing room is an error, never a skip. `checkHome` returns them all; `loadHome` throws them all. Unknown keys pass through for a consumer's own settings.
-- **One device per connector** for now (each integration is named by its connector), except Cast: one entry per device and speaker group (`name`, the Google Home name, and `castId`, the mDNS id), all read by one `cast` integration that finds every address by discovery, since a group's moves with its leader. A `spotify` entry is only its Soloist `url` (and `maxVolume`): a socket on the same machine, with nothing to discover.
+- **One device per connector** for now (each integration is named by its connector), except printers (one entry each, by `uuid`) and Cast: one entry per device and speaker group (`name`, the Google Home name, and `castId`, the mDNS id), all read by one `cast` integration that finds every address by discovery, since a group's moves with its leader. A `spotify` entry is only its Soloist `url` (and `maxVolume`): a socket on the same machine, with nothing to discover.
 - **Identity, not address.** A device is recognised by the id its own discovery reports; `host` is a cache. `home discover` lists what answers (mDNS, Daikin's UDP broadcast), in two passes 5 s apart since both drop answers now and then: the first pass prints at once, the second only what it adds (`--passes 1` for a quick look; `--json` waits for both); with a config (`--config` or `HOME_CONFIG`) it then matches those against it by identity and prints new devices, moved addresses and conflicts (a different device at an entry's host). `home discover --write <file>` adds the new ones (each with an id no entry has), updates moved hosts and refreshes the `name` of a Cast entry renamed in the Google Home app through `jsonc-parser`'s edits, every comment and other line left as it was, and writes only a result that passes `checkPlan`. Nothing else writes the file; the library never does. Two devices with one id are a config problem.
 - **A device that moves is found again, without periodic scans**, when the caller passes `finders` to `loadHome` (`FINDERS` from `@khalido/home/finders`, Node-side like `weather/ftp`; the CLI does, and jaldi and chota-bot can). After three failed reads in a row (Hue: three failed reconnects of its event stream), Hue, Daikin and Enphase run their discovery (two passes, the second skipped when the first finds the device), switch to the address their identity now answers at and say "moved from a to b" in `detail` (persist it with `home discover --write`); otherwise they look again at 1, 5 and 15 minutes, then hourly for as long as reads fail, so a device back from the wall socket reads again without a restart. The detail says what discovery found ("not found by discovery", or "discovery finds it at its address but reads fail", or "discovery failed: …" when it could not run), and "no answer for a day" once a day has passed; the part stays `disconnected`, since `unavailable` is for a rejected key. `refresh()` resets the wait. Amber and the weather have no discovery and do not take part. Cast always needs `finders.cast`: discovery is how it finds every address.
 - **Discovery is rare: addresses are cached between runs.** `loadHome(config, { cache, configAt })` takes an `AddressCache` (`read()` and `write(entries)`, keyed by connector and identity, each entry `{ host, port?, name?, seenAt }`). A cached address newer than the config (`configAt`, the file's modified time) is tried first, a failure there scans at once rather than after three, and each address that answers is written back when it changed or predates the config, so a config edit is re-trusted at the first good read. Nothing evicts an entry but `home cache clear`: a device gone for good keeps its entry, and `home status` without a config, which reads every Cast entry from the cache, shows it as not found until then. The consumer persists it: the CLI keeps `$XDG_CACHE_HOME/home/addresses.json` (default `~/.cache/home/addresses.json`, 0600) through `fileCache` from `@khalido/home/finders`, written at the end of `status`, `probe` and `discover`; jaldi's sidecar and chota-bot pass `FINDERS` and their own cache the same way. The config's `host` stays the human-set fallback and `home discover --write` the way to change the config. `home status` from a Cast config: 0.33–0.44 s cold, 0.13 s with a warm cache, 1.4 s once when a cached address has gone stale (Bun 1.4.2, measured 2026-10-13).
-- **Parsing** is the caller's: the CLI uses Bun's built-in `Bun.JSONC.parse` (comments and trailing commas, no dependency); `jsonc-parser` (already a dependency, for `home discover --write`) parses it anywhere else. `bun run schema` rewrites `home.schema.json` from the zod schema, and a test fails if they drift.
+- **Parsing** is through `jsonc-parser` (comments and trailing commas), on Bun and Node alike; a syntax error throws. `bun run schema` rewrites `home.schema.json` from the zod schema, and a test fails if they drift.
 - `createHome` stays for code-first use.
 
 ## Drawing the home

package/docs/google.md

@@ -61,7 +61,7 @@ chota's morning print needs an hourly slice (rain chance, mm, condition) for lin
 
 **Auth.** The caller passes `getToken(): Promise<string>`. The library stores no token. chota passes its better-auth token. A `home calendar login` in the CLI (loopback OAuth, token file in `~/.config/home/`, 0600, like `home enphase login`) comes later and needs an OAuth client in Google Cloud.
 
-**State.** The next 14 days per calendar, trimmed to id, title, start, end, all-day, location. Not kept by default: description, attendees, links. All-day events are dates, not instants; they use the home's `timeZone` from the config, never the machine's. Weather has this bug today (`hhmm` in `weather/index.ts`). Calendar must not copy it.
+**State.** The next 14 days per calendar, trimmed to id, title, start, end, all-day, location. Not kept by default: description, attendees, links. All-day events are dates, not instants; they use the home's `timeZone` from the config, never the machine's. Weather's `hhmmIn` does the same.
 
 **Helpers**, pure: `eventsOn(day)`, `next()`, `search(text)`. One owner for "what is today".
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khalido/home",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "home.ts: small, typed home automation for TypeScript: Hue, Daikin, Enphase, Google Cast, AirPrint printers and a Spotify Soloist speaker on the local network; Amber prices, Up Bank spending and the weather from the cloud.",
   "license": "MIT",
   "author": "Khalid Omar",
@@ -98,7 +98,7 @@
     }
   },
   "bin": {
-    "home": "./src/cli/main.ts"
+    "home": "src/cli/main.ts"
   },
   "files": [
     "CHANGELOG.md",

package/skills/draw-home/README.md

@@ -1,15 +1,14 @@
 # draw-home: references
 
-Good drawing references to read before drawing a home, newest idea first. All are skills or kits for coding agents; read for craft, keep this skill's contract (`SKILL.md` section 3) where they disagree. Local clones live in `~/code/refs/`.
+Good drawing references to read before drawing a home, newest idea first. All are skills or kits for coding agents; read for craft, keep this skill's contract (`SKILL.md` section 3) where they disagree.
 
 | Reference                                                                                                                                                     | What it is                                                                                                                                                                                                                                                                                                                                         | Use it for                                                                                                                                                                          | Licence                                                          |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
-| [iso-glow](https://isoglow.dev/) (April Zhu; local `~/code/refs/iso-glow/iso-glow/`)                                                                          | A skill that turns a description of an object, device or building into one HTML file: a fine-line isometric drawing where active parts glow and interactive parts respond, with optional orbitable 3D                                                                                                                                              | A live home view: devices that glow when on, pulses when a reading lands; "Glow kit" and "Lessons" sections                                                                         | MIT                                                              |
-| [Anatomy](https://skills.wheresryan.sh/anatomy) ([wheresryan22/anatomy](https://github.com/wheresryan22/anatomy); local `~/code/refs/anatomy/`)               | Solid-figure isometric explanatory drawings, with an iso kit and six worked examples                                                                                                                                                                                                                                                               | An isometric cutaway of the house: craft rules, `kit/iso-kit.mjs` (in the Anatomy repo), `examples/desk-computer/` (in the Anatomy repo)                                            | MIT                                                              |
-| [Hairline](https://github.com/lucasmarkes/hairline) (local `~/code/refs/hairline/`)                                                                           | Line-sketch drawings with a small kernel and a validator                                                                                                                                                                                                                                                                                           | A light, hand-drawn plan style                                                                                                                                                      | MIT                                                              |
-| [ai-iso-skill](https://github.com/MrBongoC/ai-iso-skill) `iso-figure` (local `~/code/refs/ai-iso-skill/`)                                                     | Flat-faced isometric figures on a box, ~10 KB pages                                                                                                                                                                                                                                                                                                | The lightest isometric option                                                                                                                                                       | MIT                                                              |
+| [iso-glow](https://isoglow.dev/) (April Zhu)                                                                                                                  | A skill that turns a description of an object, device or building into one HTML file: a fine-line isometric drawing where active parts glow and interactive parts respond, with optional orbitable 3D                                                                                                                                              | A live home view: devices that glow when on, pulses when a reading lands; "Glow kit" and "Lessons" sections                                                                         | MIT                                                              |
+| [Anatomy](https://skills.wheresryan.sh/anatomy) ([wheresryan22/anatomy](https://github.com/wheresryan22/anatomy))                                             | Solid-figure isometric explanatory drawings, with an iso kit and six worked examples                                                                                                                                                                                                                                                               | An isometric cutaway of the house: craft rules, `kit/iso-kit.mjs` (in the Anatomy repo), `examples/desk-computer/` (in the Anatomy repo)                                            | MIT                                                              |
+| [Hairline](https://github.com/lucasmarkes/hairline)                                                                                                           | Line-sketch drawings with a small kernel and a validator                                                                                                                                                                                                                                                                                           | A light, hand-drawn plan style                                                                                                                                                      | MIT                                                              |
+| [ai-iso-skill](https://github.com/MrBongoC/ai-iso-skill) `iso-figure`                                                                                         | Flat-faced isometric figures on a box, ~10 KB pages                                                                                                                                                                                                                                                                                                | The lightest isometric option                                                                                                                                                       | MIT                                                              |
 | [casa-serra](https://github.com/Sam1983Aing/casa-serra) (Sam1983Aing; live demo linked from the README, three.js + GSAP ScrollTrigger + Lenis, no build step) | "A flat floor plan that becomes a house as you scroll": the plan "is not a picture. It is the real 3D model, cut at 1.2 m and seen from straight above through a very long lens"; scrolling raises the cut so the walls rise, rooms stay a line drawing until the camera reaches them, geometry built in code, a still and a clip for weak devices | The strongest version of the "SVG with a camera" option (`SKILL.md`): one model in metres, the flat plan as the top view of it, zoom and orbit as a redraw. Added by KO 2026-10-13. | No licence file (checked 2026-10-13): approach only, never paste |
-| sfl-mes `device-drawing` (`~/code/sfl-mes/.claude/skills/device-drawing/`, private)                                                                           | KO's skill for drawing one machine that moves with its live reading                                                                                                                                                                                                                                                                                | Sources-first discipline, the live contract (no data, never clamp, fit the host), the review step                                                                                   | KO's                                                             |
 
 Default stays a flat plan (`examples/home.svg`): it is the fastest to draw, reads at card size, and is easy for an app to draw state on. Pick iso-glow or Anatomy when the home view is the point rather than a panel beside it.
 

package/skills/draw-home/SKILL.md

@@ -12,8 +12,6 @@ The library does not draw. This guide is for the coding agent that does: turn wh
 
 Start from `examples/home.svg` and `examples/home.jsonc`. Never start from a blank file. If the person already has a `home.jsonc`, edit its `rooms` and `plan` in place, keeping its comments, and leave every other field alone.
 
-This is the home-sized version of the sfl-mes `device-drawing` skill (`~/code/sfl-mes/.claude/skills/device-drawing/`), which draws single machines; read it when a rule here seems thin.
-
 ## 1. Sources, before any geometry
 
 Make a **room table** first, in the SVG's header comment: each room, its floor, its name as the person says it, and the source (plan sheet and page, or photo). Nothing is drawn that has no row.
@@ -27,7 +25,7 @@ Make a **room table** first, in the SVG's header comment: each room, its floor,
 
 - Rooms as rectangles, or simple paths for L-shapes; walls, the front door, stairs. Front of the house in the same place on every floor; one floor per band of the canvas, labelled, ground below.
 - **Style: a flat plan by default.** `README.md` beside this file lists the drawing references (iso-glow, Anatomy, Hairline, iso-figure) with what each is good for.
-- **Isometric options.** A glowing fine-line drawing in the [iso-glow](https://isoglow.dev/) style suits a live view; an isometric cutaway in the **Anatomy** style (solid figures, MIT, `~/code/refs/anatomy/`, [skills.wheresryan.sh/anatomy](https://skills.wheresryan.sh/anatomy)) is an option when the person asks for it: read its `SKILL.md` craft rules and `examples/desk-computer/` (in the Anatomy repo), keep this contract, and draw rooms as low boxes with the markers on their floors.
+- **Isometric options.** A glowing fine-line drawing in the [iso-glow](https://isoglow.dev/) style suits a live view; an isometric cutaway in the **Anatomy** style (solid figures, MIT, [skills.wheresryan.sh/anatomy](https://skills.wheresryan.sh/anatomy)) is an option when the person asks for it: read its `SKILL.md` craft rules and `examples/desk-computer/` (in the Anatomy repo), keep this contract, and draw rooms as low boxes with the markers on their floors.
 
 ## 3. The contract (an app draws on this; keep it exact)
 
@@ -38,7 +36,7 @@ Make a **room table** first, in the SVG's header comment: each room, its floor,
 5. The SVG fills its host (`width: 100%; height: 100%`; the viewBox holds everything).
 6. **Zoomable**: one root `<g id="plan">` holding every floor, no fixed pixel sizes, labels sized so they still read when a single room fills the screen. Each room group's `getBBox()` is its zoom target, so keep a room's label and marker inside its shape.
 
-**What an app does with it** (from sfl-mes's live contract): it draws each device's state into its room's marker from `home.snapshot()`. A missing part is "no data": grey marker, no value, never a stale number shown as live. Values are shown as read, never clamped; odd ones (`Part.anomaly`) get a flag. Hover names the device. Controls live in the app's side panel, not in the SVG.
+**What an app does with it:** it draws each device's state into its room's marker from `home.snapshot()`. A missing part is "no data": grey marker, no value, never a stale number shown as live. Values are shown as read, never clamped; odd ones (`Part.anomaly`) get a flag. Hover names the device. Controls live in the app's side panel, not in the SVG.
 
 **Energy on the plan** (the numbers are the library's, the drawing and animation are the app's):
 
@@ -48,7 +46,7 @@ Make a **room table** first, in the SVG's header comment: each room, its floor,
 
 **Interactive, in the app**: wheel or pinch zooms and drag pans (animate the `viewBox`, or a transform on `#plan`); clicking a room zooms to its bounding box and opens that room's devices in the side panel; Escape or double-click returns to the whole house; arrow keys move between rooms. Respect reduced motion (jump, do not animate). A flat plan only zooms and pans.
 
-**SVG with a camera** (the interactive option, Anatomy's approach and sfl-mes's "spin"): build the house once as a model in metres (each room a box: x, y, width, depth, floor height; walls and doors on it), and render it to SVG through a camera `{ azimuth, elevation, target, zoom }` with Anatomy's `fitProjection` (`~/code/refs/anatomy/kit/iso-kit.mjs`). The scene is a pure function of the camera, so zooming, orbiting and "fly to this room" are a redraw with a new camera, eased; drag orbits, wheel zooms, click a room sets the target to its centre. The rendered SVG still meets the contract above: one `<g class="room">` per room and a marker projected to the room's top corner on every redraw. Keep the model in its own file named by `plan.json` in the config (sizes are data, not hard-coded in the drawing), and spring back to the default camera on Escape.
+**SVG with a camera** (the interactive option, Anatomy's approach): build the house once as a model in metres (each room a box: x, y, width, depth, floor height; walls and doors on it), and render it to SVG through a camera `{ azimuth, elevation, target, zoom }` with Anatomy's `fitProjection` (`kit/iso-kit.mjs` in the Anatomy repo). The scene is a pure function of the camera, so zooming, orbiting and "fly to this room" are a redraw with a new camera, eased; drag orbits, wheel zooms, click a room sets the target to its centre. The rendered SVG still meets the contract above: one `<g class="room">` per room and a marker projected to the room's top corner on every redraw. Keep the model in its own file named by `plan.json` in the config (sizes are data, not hard-coded in the drawing), and spring back to the default camera on Escape.
 
 ## 4. home.jsonc
 

package/src/cli/discover.ts

@@ -14,7 +14,13 @@ import {
   KNOWN_SERVICES,
   matchFound,
 } from "../discover.ts";
-import { browse, daikinFound, FINDERS, findDaikins } from "../finders.ts";
+import {
+  browse,
+  daikinFound,
+  FINDERS,
+  findDaikins,
+  MissingTool,
+} from "../finders.ts";
 import {
   addresses,
   configPathOf,
@@ -83,6 +89,7 @@ export async function discover(o: Options): Promise<void> {
     clock: realClock,
     passes,
     key: (x) => (x.found ? foundKey(x.found) : `${x.what}:${x.name}`),
+    stopOn: (error) => error instanceof MissingTool,
     onPass: (n, added) => {
       if (o.json) return;
       const tty = process.stderr.isTTY;

package/src/connectors/cast/README.md

@@ -4,7 +4,7 @@ Nest speakers, Nest Hubs, Chromecasts, Google TV and speaker groups, read over C
 
 ## Built
 
-- `cast({ resolve, connect })` keeps every Cast device and group current as one integration. `resolve()` returns what mDNS `_googlecast._tcp` found (`id`, `name` from TXT `fn`, `model` from `md`, host, port, `group`); the CLI runs `dns-sd`. `connect` is `tlsConnect` from `@khalido/home/cast/tls`. `expect` lists the config's entries, so one discovery misses shows as disconnected rather than vanishing. From a config, `resolve` is the shared two-pass discovery, done after the first pass once every entry has answered. An entry with a cached address (the address cache, `loadHome`'s `cache`) connects at once with a 1 s timeout; discovery runs only when an entry has none or a cached address fails, so a stale one still reads as `connecting` until discovery has had its say. A cached port other than 8009 marks a group, since devices always listen on 8009.
+- `cast({ resolve, connect })` keeps every Cast device and group current as one integration. `resolve()` returns what mDNS `_googlecast._tcp` found (`id`, `name` from TXT `fn`, `model` from `md`, host, port, `group`); the CLI runs `dns-sd`. `connect` is `tlsConnect` from `@khalido/home/cast/tls`. `expect` lists the config's entries, so one discovery misses shows as disconnected rather than vanishing. From a config, `resolve` is the shared two-pass discovery, done after the first pass once every entry has answered. An entry with a cached address (the address cache, `loadHome`'s `cache`) connects at once with a 1 s timeout; discovery runs only when an entry has none or a cached address fails, so a stale one still reads as `connecting` until discovery has had its say. If discovery can't find the device either, it shows as disconnected at once rather than waiting on the same address again; the backoff still retries. A cached port other than 8009 marks a group, since devices always listen on 8009.
 - Per socket: `CONNECT` to `receiver-0`, receiver `GET_STATUS`, multizone `GET_STATUS` (a group's members; on a device's own port, the device alone, by its current name), then whatever the device pushes. A running app with the media namespace gets a `CONNECT` and media `GET_STATUS` on its `transportId`, as Home Assistant does. A device's `PING` is answered with `PONG`; a socket silent for three heartbeats (15 s), or without a receiver status 10 s after connecting, is closed and the detail says which.
 - A dropped socket reconnects with backoff (1 s doubling to 60 s) at whatever address discovery last gave. The drop starts one shared `resolve()` at once (a group's address changes with its leader); while anything stays down or missing, that one discovery repeats at 1, 5 and 15 minutes, then hourly, as the relocator does, never once per socket. `refresh()` re-asks every open socket and nudges the discovery, which also finds devices when nothing was found at start.
 - The part is `connecting` until every device has answered or failed, then `connected` while any is up; `detail` names the ones down. A payload of a known type the schema rejects is an `anomaly`, never thrown.
@@ -26,7 +26,8 @@ CastV2 is TLS to port 8009 (a group: its own port), carrying length-prefixed pro
 - **Groups.** A group is its own mDNS entry, at its leader's address on a high port, and presents **its leader's certificate**. Multizone status on the group's port lists the members (by `deviceId`, the same dashed id) with their volumes; on a device's own port it lists only that device, so membership is read from group sockets only. TXT `rm` does not mark membership. `GET_CASTING_GROUPS` is refused.
 - **Receiver status**: hubs and the Chromecast Ultra run Backdrop (`E8C28D3C`) with `isIdleScreen: true`; the speakers report no application; the TV Streamer reports `isStandBy: true`, `isActiveInput: false` and a `fixed` volume; the Ultra's volume is `attenuation`.
 - No device sent a `PING` in 12 s of listening, so our 5 s ping is what keeps the socket's silence check honest.
-- Not seen yet: media status (nothing was playing), a group playing, a leader change, member changes, and Node's `tls` (no Node caller yet).
+- Media status first seen live 2026-11-09 (Bun 1.4.4): a paused title and artist on a TV.
+- Not seen yet: a group playing, a leader change, member changes, and Node's `tls` (no Node caller yet).
 
 ## TLS: verification off, the name checked
 

package/src/connectors/cast/index.ts

@@ -401,7 +401,8 @@ export function cast(
           // A cached address that fails is only stale: discover now and try where it answers, still "connecting".
           cached = false;
           await discover();
-          continue;
+          // Unless discovery can't find it: then the address is the one that just failed, and a second try only waits out the timeout. The backoff still retries.
+          if (!lastFound || lastFound.has(id)) continue;
         }
         const why = errorText(error);
         // A cached address the last discovery did not find says so, as a polling connector's does.

package/src/connectors/cast/serve.ts

@@ -15,10 +15,20 @@ const ipv4 = (a: string) =>
 const network = (address: string, netmask: string) =>
   ipv4(address) - (ipv4(address) % (2 ** 32 - ipv4(netmask)));
 
+type NetworkAddress = {
+  family: string;
+  address: string;
+  netmask: string;
+  internal: boolean;
+};
+
 /** This machine's IPv4 on the subnet that holds `host`, or with no host, its first non-internal IPv4. */
 export function lanAddress(
   host?: string,
-  interfaces = networkInterfaces(),
+  interfaces: Record<
+    string,
+    NetworkAddress[] | undefined
+  > = networkInterfaces(),
 ): string {
   const all = Object.values(interfaces)
     .flatMap((list) => list ?? [])

package/src/connectors/cast/tls.ts

@@ -18,7 +18,7 @@ export const tlsConnect: CastConnect = ({
   host,
   port,
   signal,
-  timeoutMs = 10_000,
+  timeoutMs = 3000,
 }) =>
   new Promise<CastChannel>((resolve, reject) => {
     const socket = connect({ host, port, rejectUnauthorized: false });

package/src/connectors/daikin/README.md

@@ -4,7 +4,7 @@ Reads one Daikin AC over its local JSON `dsiot` API. `iot_class`: **local_pollin
 
 - `client.ts`: `daikinClient({ host, fetch }).read()` returns `DaikinState` (power, mode, the selected mode's setpoint and fan speed, room °C, humidity, outside °C, `anomaly`). `setPower`, `setMode`, `setTarget`, `setFan` build write requests; `client.write(request)` sends one, through a write lane: 1 s apart and at most 20 a minute (guesses), a waiting write merging the next one field by field (`mergeWrites`). Every request times out at 10 s.
 - `index.ts`: `daikin({ host, fetch, clock })` reads now, then every **120 s** (Home Assistant's `update_interval`). A failed poll is `disconnected` and keeps the last reading with `asOf`; a 404 on `/dsiot/multireq` is a failed read too, saying "not a dsiot Daikin": the address may now be another device's, so discovery looks for the unit. There is no key, so nothing is terminal. Writes go through `daikin().client.write(…)`: one client for the integration's life, at the unit's current address.
-- `home status` reads `DAIKIN_HOST`, else the first unit that answers the UDP broadcast. There is no CLI command that writes.
+- `home status` reads `DAIKIN_HOST`, or a home config's address, with discovery by `mac` if the unit moves. There is no CLI command that writes.
 
 ## The protocol
 

package/src/connectors/spotify/README.md

@@ -1,6 +1,6 @@
 # Spotify (Soloist)
 
-What a [Spotify Soloist](https://developer.spotify.com/documentation/soloist) speaker is playing (start with its [basic integration](https://developer.spotify.com/documentation/soloist/howtos/basic-integration)), and control over it, over Soloist's local WebSocket. `iot_class`: **local_push**. Tested against a fake socket only: no real Soloist has answered this connector yet.
+What a [Spotify Soloist](https://developer.spotify.com/documentation/soloist) speaker is playing (start with its [basic integration](https://developer.spotify.com/documentation/soloist/howtos/basic-integration)), and control over it, over Soloist's local WebSocket. `iot_class`: **local_push**. Reads seen live on a real Soloist (2026-11-09); writes tested against a fake socket only.
 
 Soloist is Spotify's own headless Spotify Connect client (Linux arm64, armv7, x86_64, Apple Silicon, Windows x86_64). The machine running it is a speaker in every Spotify app on the network; this connector is how a program on the same machine sees and steers it. It doesn't search Spotify or read a library: Soloist plays URIs and reports its own session. Search belongs to the consumer (KO, 2026-11-08; `docs/ideas.md`).
 
@@ -22,7 +22,7 @@ Soloist is Spotify's own headless Spotify Connect client (Linux arm64, armv7, x8
 - `setRepeat` is two commands in the docs' order (clear the other mode, then set this one); if the second is refused, repeat may be left off.
 - A failed write the library made itself stays in `detail` until a write works or the socket reconnects.
 
-**`maxVolume`** holds requests (rounded to a whole percent). Within 10 s of idle → playing, a reported volume above it is lowered once and `anomaly` says so until the speaker goes idle: [#23](https://github.com/spotify/soloist/issues/23), the first play on PipeWire starts at 100%. `--initial-volume` is ignored there. Not on resuming from pause, not on connecting to a song already playing, and a person turning it up again keeps it.
+**`maxVolume`** holds requests (rounded to a whole percent). Within 10 s of a start from idle (to playing or buffering, or the first such status after a sign-in; a start through buffering opens the window again at `playing`), a reported volume above it is lowered once and `anomaly` says so until the speaker goes idle: [#23](https://github.com/spotify/soloist/issues/23), the first play on PipeWire starts at 100%. `--initial-volume` is ignored there. Not on resuming from pause, not on connecting to a song already playing, and a person turning it up again keeps it.
 
 **`duck(fn, { to })` and `interrupt(fn)`** turn the music down, or pause it, around `fn`, then put it back. Both resolve `{ value, music, why? }`, `music` one of:
 
@@ -33,7 +33,7 @@ Soloist is Spotify's own headless Spotify Connect client (Linux arm64, armv7, x8
 
 The restore runs even if `fn` throws: the error is `fn`'s, and a failed restore goes to `detail`. `duck` restores the earlier volume even above `maxVolume`. One aside at a time: never call one inside another's `fn` (it waits forever), and put two announcements in one `fn`. With Cast: `speaker.duck(() => cast.announce("Kitchen", clip), { to: 20 })`. Cast's own `announce` restores what a Cast device was playing; these are for Soloist's output.
 
-**Reading it.** `speakerState(part)`: `offline`, `connecting`, `waiting`, then Soloist's status (`idle`, `playing`, `paused`, `buffering`, or its own string); signed in with no status yet is `idle`. `spotifyChanges(before, after)`, for `onChange`, gives events in this order: `offline`, `online`, `waiting`, `picked`, `started` (from idle), `resumed` (from paused), `paused`, `stopped`, `track`, `stalled`, `recovered`. Buffering counts as playing. Nothing on the first report, so a restart announces nothing; no volume or queue events. Playback events during an aside carry `own: true`; connection, sign-in and stall events never do.
+**Reading it.** `speakerState` takes the Part; `spotifyText` and `positionMs` take its `state`. `speakerState(part)`: `offline`, `connecting`, `waiting`, then Soloist's status (`idle`, `playing`, `paused`, `buffering`, or its own string); signed in with no status yet is `idle`. `spotifyChanges(before, after)`, for `onChange`, gives events in this order: `offline`, `online`, `waiting`, `picked`, `started` (from idle), `resumed` (from paused), `paused`, `stopped`, `track`, `stalled`, `recovered`. Buffering counts as playing. Nothing on the first report, so a restart announces nothing; no volume or queue events. Playback events during an aside carry `own: true`; connection, sign-in and stall events never do.
 
 **Stalls** ([#5](https://github.com/spotify/soloist/issues/5): playback stops mid-track, often the first after idle, while Soloist still says `playing`). While playing, one `get_state` every 20 s (`stallCheckMs`, code only; 0 turns it off).
 
@@ -56,14 +56,17 @@ Not built: `activate`/`deactivate`, `available_actions`. An ad (`entity_type: "a
 
 ## Unverified
 
-Everything through this connector; only `soloist ctl` has talked to a real Soloist. In particular:
+Writes through this connector, and what a live read hasn't shown. In particular:
 
 - **Stalls:** whether the reported position freezes in one (if not, only an overrun is caught), whether `get_state` re-anchors the position, and whether a seek or a pause and play restarts it.
 - **Writes:** that each confirming event arrives within 2 s; which events a `play` of an album or playlist sends; `play` of a new URI with no phone around; seek on playback a phone started.
+- **The cap:** the order of statuses at a start. Soloist's docs list `buffering` but not when it comes; #23 reports the 100% about 100 ms after `playing`, on the first play after the process starts.
 - **The rest:** `get_queue` answered by `queue_changed`; `play` with nothing loaded; whole-number volumes; the order of `auth_state` and `playback_state`; the 100% first play and its lowering; Family-plan members picking the speaker; whether the session survives a Soloist restart; a USB speaker's standby dropping it mid-play.
 
 ## Live findings
 
+**2026-11-09, Raspberry Pi 5, Bun 1.4.4, through this connector** (chota-bot's session, reads only). `home spotify` took 140 ms. In code: connected at 11 ms, second report at 55 ms, 51 MB RSS, a clean exit after abort. Track, volume and `paused` read correctly, with no anomaly. `spotifyChanges` gave nothing on the first report.
+
 **2026-11-08, Raspberry Pi 5, Pi OS Lite Trixie arm64, via `soloist ctl`** (chota-bot's session). `soloist 1.3.10.51 build 1793988108 (20261106)` as a systemd user unit with `-w 127.0.0.1:9091`. It logs the days left on the build (88), the WebSocket listening, then "waiting for login". Builds expire 90 days after they're made (exit code 10); chota-bot's units refresh weekly.
 
 - Not logged in until a phone picked the speaker: the normal waiting state. After: logged in, active device.

package/src/connectors/spotify/index.ts

@@ -199,6 +199,7 @@ export function spotify(
   let signedIn = false; // signed out → in on this socket: the first status after it counts as a start if it is playing
   let capUntil = -Infinity;
   let capped = false; // the cap has been sent in this window
+  let startBuffering = false; // a start from idle is still buffering
   let capNote: string | undefined; // the last first-play lowering, in `anomaly` until the speaker goes idle
   let frameNote: string | undefined; // a frame the schema rejected, or an error nothing was waiting for
   let note: string | undefined; // a write the integration made itself that failed (the cap, interrupt's resume), in `detail`
@@ -352,7 +353,7 @@ export function spotify(
       publish();
     });
 
-  /** Within the window after idle → playing, a volume above the cap is lowered to it, once (issue #23). */
+  /** Within the window after a start from idle, a volume above the cap is lowered to it, once (issue #23). */
   const applyCap = () => {
     if (
       cap === undefined ||
@@ -429,10 +430,14 @@ export function spotify(
       (f.type === "playback_state" || f.type === "playback_changed") &&
       f.status !== undefined
     ) {
-      // A start is idle → playing, or a sign-in whose first status is playing: a phone picked the speaker and played (issue #23).
+      // A start is idle → playing or buffering, or a sign-in whose first status is either: a phone picked the speaker and played (issue #23).
+      // Soloist's jump to 100 comes about 100 ms after `playing` (issue #23), so a start through buffering opens the window again then.
       const started =
-        f.status === "playing" && (statusKnown ? before === "idle" : signedIn);
+        ((f.status === "playing" || f.status === "buffering") &&
+          (statusKnown ? before === "idle" : signedIn)) ||
+        (f.status === "playing" && startBuffering);
       if (started) ((capUntil = clock.now() + CAP_WINDOW_MS), (capped = false));
+      startBuffering = f.status === "buffering" && (started || startBuffering);
       signedIn = false;
       if (f.status === "idle") capNote = undefined;
       statusKnown = true;
@@ -472,6 +477,7 @@ export function spotify(
         queueAsked = false;
         statusKnown = false;
         signedIn = false;
+        startBuffering = false;
         pending?.finish(offline());
         for (const w of [...waiters]) w(); // a write waiting to confirm stops waiting
         seen = undefined;
@@ -479,7 +485,9 @@ export function spotify(
       };
       const stop = () => (end("stopped"), s.close());
       signal.addEventListener("abort", stop, { once: true });
+      // An ended socket's late events belong to no session: they must not touch the next socket's state.
       s.onopen = () => {
+        if (ended) return;
         open = true;
         down = undefined;
         note = undefined; // a new socket: what failed on the last one is history
@@ -493,7 +501,7 @@ export function spotify(
           if (!whole) ((whole = true), publish()); // signed in, no playback_state: connected with what there is
         });
       };
-      s.onmessage = (ev) => handle(ev.data);
+      s.onmessage = (ev) => void (ended || handle(ev.data));
       s.onerror = () => {}; // onclose follows and says it
       s.onclose = () => end("Soloist closed the socket");
     });

package/src/connectors/weather/README.md

@@ -68,7 +68,7 @@ Plain `fetch` cannot read `ftp://` (Bun 1.4.2: "protocol must be http:, https: o
 
 **Sun** (`sun.ts`). `sunNow` with [suncalc](https://github.com/mourner/suncalc) 2.1.1, which bundles its own types (degrees, azimuth clockwise from north; `@types/suncalc` describes v1 and is wrong for it). Times are for the local solar day containing `at`. On 2026-10-13 it matched BOM's own Sydney sunrise and sunset to the second. Dawn and dusk are civil (6° below the horizon), `nightEnd` and `night` astronomical (18°), `goldenHour` starts the evening's and `goldenHourEnd` ends the morning's (6° above). `rising` is before solar noon, which in suncalc's solar day means from solar midnight; `daylight` is altitude above 0°. **`sunNow(latitude, longitude, now)` is the owner**: the snapshot's `sun` is recomputed every 5 minutes, so a consumer showing `rising`, `daylight`, `next` or the position calls `sunNow` with its own clock, as `home status` does. `next` holds each of dawn, sunrise, sunset and dusk at its next occurrence after `at` (today's while still ahead, else tomorrow's), missing on a day that has none. The computed sun is the owner: Google's daily `sunEvents` are parsed only to check it, and a sunrise or sunset more than 2 minutes from the computed one (`sunDisagrees`, comparing within the solar day containing Google's time) goes into Google's `anomaly`, never into the sun.
 
-Every request has a 10 s timeout and the user agent `home (+https://github.com/khalido/home)`: BOM's app API gives Bun's default `Bun/1.4.2` no answer at all, so nothing here relies on the default.
+Every request has a 10 s timeout and the user agent `home (+https://github.com/khalido/home.ts)`: BOM's app API gives Bun's default `Bun/1.4.2` no answer at all, so nothing here relies on the default.
 
 ## Not built, on purpose
 

package/src/connectors/weather/index.ts

@@ -246,19 +246,35 @@ export function weather(
 /** "20:20" in the home's time zone (the runtime's when unset), or "?". */
 const hhmmIn = (iso: string | undefined, timeZone?: string) =>
   iso ? localTime(Date.parse(iso), timeZone) : "?";
-const day = (d?: ForecastDay) =>
+const day = (d?: ForecastDay, rainLeft?: number) =>
   d
     ? [
         d.minC === undefined && d.maxC === undefined
           ? ""
           : `${d.minC ?? "?"}–${d.maxC ?? "?"} °C`,
         d.text?.replace(/\.$/, "").toLowerCase() ?? "",
-        d.rainChance === undefined ? "" : `${d.rainChance}% chance of rain`,
+        d.rainChance === undefined
+          ? ""
+          : rainLeft !== undefined && rainLeft < d.rainChance
+            ? `${rainLeft}% chance of rain the rest of the day`
+            : `${d.rainChance}% chance of rain`,
       ]
         .filter(Boolean)
         .join(" ")
     : "?";
 
+/** The highest hourly chance left today, all 24 hours of it, when the hourly forecast is the same source and day as the forecast: sources are never mixed. */
+const rainLeftToday = (
+  w: Pick<Slices, "forecast" | "hourly"> & { timeZone?: string },
+  at: number,
+) => {
+  if (!w.hourly || w.hourly.source !== w.forecast?.source) return undefined;
+  const rest = dayBlocks(w.hourly, at, w.timeZone, [
+    { name: "rest", from: 0, to: 24 },
+  ])?.today[0];
+  return rest?.date === w.forecast.today?.date ? rest?.rainChance : undefined;
+};
+
 /** "rain in 30 min, ends in 55 min, 70%, 0.8 mm, moderate (google)", "raining, ends in 25 min", or "no rain for 2 h"; nothing when the forecast covers none of the window. */
 export function rainText(
   rain: Slices["rain"],
@@ -310,7 +326,7 @@ export function weatherText(
     : "";
   const f = w.forecast;
   const forecast = f
-    ? `today ${day(f.today)}, tomorrow ${day(f.tomorrow)} (${f.source}${f.modelled ? " modelled" : ""})`
+    ? `today ${day(f.today, rainLeftToday(w, Date.parse(sun.at)))}, tomorrow ${day(f.tomorrow)} (${f.source}${f.modelled ? " modelled" : ""})`
     : "";
   const k = w.sky;
   const skyParts = k

package/src/discover.ts

@@ -374,7 +374,8 @@ export function addressBook(
 /**
  * Run one discovery `passes` times, `gapMs` apart, and return the union (first answer wins). `onPass` sees each pass's
  * additions as they come; `done` ends it early once what was looked for has answered. A pass that throws adds nothing;
- * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found.
+ * when every pass threw, discovery never ran, so it throws the last error rather than reporting nothing found. An error
+ * `stopOn` accepts is thrown at once: no later pass could do better.
  */
 export async function discover<T = Found>(
   pass: () => Promise<T[]>,
@@ -384,6 +385,7 @@ export async function discover<T = Found>(
     gapMs?: number;
     key?: (t: T) => string;
     done?: (all: T[]) => boolean;
+    stopOn?: (error: unknown) => boolean;
     onPass?: (n: number, added: T[]) => void;
     signal?: AbortSignal;
   },
@@ -401,9 +403,11 @@ export async function discover<T = Found>(
       );
     if (options.signal?.aborted) break;
     ran++;
-    const answers = await pass().catch(
-      (error) => (errors.push(error), [] as T[]),
-    );
+    const answers = await pass().catch((error) => {
+      if (options.stopOn?.(error)) throw error;
+      errors.push(error);
+      return [] as T[];
+    });
     const added = answers.filter((t) => !all.has(key(t)) && all.set(key(t), t));
     options.onPass?.(n, added);
     if (options.done?.([...all.values()])) break;

package/src/energy.ts

@@ -1,6 +1,7 @@
 import type { AmberState, PriceInterval } from "./connectors/amber/client.ts";
 import type { EnphaseState } from "./connectors/enphase/client.ts";
 import type { EnphaseSnapshot } from "./connectors/enphase/index.ts";
+import { kw } from "./manifest.ts";
 
 /** The home's energy right now: power from Enphase, prices from Amber, and what the grid flow costs per hour. */
 export type EnergyNow = {
@@ -112,7 +113,6 @@ export function solarLevel(
  * "balanced (-10 W)", or "" with no grid reading. Rounded for reading only; the numbers above stay as read.
  */
 export function gridText(now: EnergyNow): string {
-  const kw = (w: number) => `${(w / 1000).toFixed(1)} kW`;
   const rate = (c: number | undefined, positive: string, negative: string) =>
     c === undefined
       ? ""

package/src/finders.ts

@@ -31,6 +31,9 @@ import {
 // does not slow a scan. Without the tool the mDNS finders throw, naming it, rather than "nothing answered".
 // `fileCache` keeps the addresses discovery found in a file between runs, so the next run connects straight away.
 
+/** The system's mDNS tool is not installed: discovery can't run until it is. */
+export class MissingTool extends Error {}
+
 /**
  * Run a long-lived `dns-sd` query (or `avahi-browse`, by `command`) and return what it printed. It never exits by itself, so it is stopped once `done`
  * says the answer is in, or `quietMs` after the last output, or at `maxMs`. The system's mDNS cache usually answers in
@@ -68,11 +71,11 @@ export function dnsSd(
     proc.on("error", (error: NodeJS.ErrnoException) => {
       (clearTimeout(timer), clearTimeout(quiet));
       reject(
-        new Error(
-          error.code === "ENOENT"
-            ? `${command} not found; mDNS discovery needs it${install ? ` (${install})` : ""}`
-            : `${command}: ${error.message}`,
-        ),
+        error.code === "ENOENT"
+          ? new MissingTool(
+              `${command} not found; mDNS discovery needs it${install ? ` (${install})` : ""}`,
+            )
+          : new Error(`${command}: ${error.message}`),
       );
     });
     proc.on("close", finish);