feat(daemon): log startup, socket, driver, and connection lifecycle

daemon.log has been an empty crash dump since the daemon's only write to
either stream was a fatal console.error(). There was no startup line, no
shutdown line, and no record of socket claim/recovery or driver discovery, so
a misbehaving long-lived daemon left no trace to read back.

Adds a Logger port (JsonLinesLogger over an injected LogSink, with
module-scoped child()) alongside the existing Filesystem/Clock/DaemonLauncher
ports. Production logging goes through NodeFileLogSink, which owns an append
handle on ~/.pitlane/daemon.log, tracks bytes written, and rotates to
daemon.log.1 (replacing any previous generation) once config.log.rotateBytes
is exceeded -- keeping exactly one rotated generation so growth is bounded.
Tests use MemoryLogSink and assert parsed records, not string fragments.

startDaemon builds the logger from config.log.level right after config loads
and hands scoped children to DaemonEndpointHost, DaemonServer, and driver
discovery, covering: daemon start (version, protocol version, socket path,
effective config), socket claim and stale-endpoint recovery, driver discovery
results including the Android SDK-missing skip, connection open/close with
declared capabilities, clean shutdown, and unexpected vs. handled request
errors (INTERNAL logs at error level, everything else at debug).

The fatal top-level handler in main.ts can't depend on config.log -- config
loading is exactly what may have failed -- so it builds its own logger
straight from the default log path at a fixed level, falling back to
console.error only if that itself throws.

Because NodeDaemonLauncher hands the child an inherited append fd on the same
path for uncaught fatal output, a crash stack can still land in the rotated
file. pitlane daemon logs now reads daemon.log.1 followed by daemon.log so a
crash right before rotation is never silently lost.

Config gained a log section (level, default "info"; rotateBytes, default
5 MiB), validated like its neighbors and readable via `pitlane config get
log`.

Author: V3RON

docs/ARCHITECTURE.md

@@ -252,6 +252,7 @@ Clock        — now(), timers (no direct Date/setTimeout in logic)
 SystemStats  — cpu count, total/free RAM, disk free
 IpcConnector / IpcListenerFactory — connect to and host daemon IPC endpoints
 DaemonLauncher — detached daemon startup with append-only combined logs
+Logger       — debug/info/warn/error(message, fields) plus child(module) scoping
 ```
 
 Real implementations are thin adapters wired up once at daemon startup;
@@ -275,6 +276,23 @@ request multiplexing, `IpcDaemonConnector` performs the hello handshake, and
 or refused daemon. This keeps transport, detached-process logging, and startup
 policies replaceable without introducing an ambient dependency container.
 
+Operational logging is a separate concern from the event bus: `pitlane events`
+carries business facts (lease granted, device cleaned up, …) in an in-memory
+ring buffer that resets on restart, while the `Logger` port writes durable,
+structured JSON lines — one per record — for startup, socket claim/recovery,
+driver discovery, connection lifecycle, shutdown, and unexpected/handled
+errors. `startDaemon` builds the production `Logger` (`JsonLinesLogger` over a
+`NodeFileLogSink`) from `config.log` right after config loads, then hands
+module-scoped children (`logger.child("server")`, `.child("connection-host")`,
+`.child("driver-discovery")`) to each component so every line is attributable.
+The sink tracks bytes written and rotates `daemon.log` to `daemon.log.1`
+(replacing any previous generation) once `config.log.rotateBytes` is exceeded,
+so growth is bounded and `pitlane daemon logs` reads the rotated generation
+before the current file. The one exception is the fatal top-level handler: it
+cannot depend on `config.log` having loaded successfully, so it builds its own
+logger straight from the default log path at a fixed level, falling back to
+`console.error` only if that itself fails.
+
 ## Device requests
 
 Required to identify a device: **platform + device model + OS version**.

docs/CLI.md

@@ -214,10 +214,19 @@ lines. `--follow` keeps streaming; `--since 1h` replays recent history.
 Manage the daemon explicitly. Other commands auto-start it on demand;
 `daemon` exists for operators and debugging. `logs` tails daemon logs.
 
+The daemon writes one structured JSON line per record to `~/.pitlane/daemon.log`
+(timestamp, level, module, message, and any fields) covering startup (version,
+protocol version, socket path, effective config), socket claim/stale-endpoint
+recovery, driver discovery, connection open/close, shutdown, and unexpected or
+handled errors. Growth is bounded: once the file passes `log.rotateBytes` it is
+rotated to `daemon.log.1` (replacing any previous generation), so `logs` always
+shows the current file with the immediately preceding one prepended.
+
 ## `pitlane config [get <key>|set <key> <value>]`
 
 Show the effective configuration (defaults + config file + overrides):
 managed and running capacity limits, idle tiers T1/T2/T3, TTLs, disk-pressure
-threshold. With no args, prints everything. Running capacity
+threshold, and the daemon's log level/rotation cap (`log.level`,
+`log.rotateBytes`). With no args, prints everything. Running capacity
 uses `limits.maxRunning` globally and `limits.<platform>.maxRunning` for each
 driver; both must have room before provisioning or booting a shutdown device.

src/cli/index.test.ts

@@ -22,6 +22,7 @@ import {
   errorExitCode,
   fallbackRequesterId,
   parseDuration,
+  readLogFile,
   runCli,
   type CliEnvironment,
   type DaemonConnection,
@@ -38,6 +39,33 @@ afterEach(async () => {
   );
 });
 
+describe("readLogFile", () => {
+  it("returns just the current log when there is no rotated generation", async () => {
+    const filesystem = new MemoryFilesystem();
+    await filesystem.mkdirp("/pitlane");
+    await filesystem.writeFileAtomic("/pitlane/daemon.log", "current\n");
+
+    await expect(readLogFile(filesystem, "/pitlane/daemon.log")).resolves.toBe("current\n");
+  });
+
+  it("prepends the rotated generation so a pre-rotation crash is not lost", async () => {
+    const filesystem = new MemoryFilesystem();
+    await filesystem.mkdirp("/pitlane");
+    await filesystem.writeFileAtomic("/pitlane/daemon.log.1", "rotated\n");
+    await filesystem.writeFileAtomic("/pitlane/daemon.log", "current\n");
+
+    await expect(readLogFile(filesystem, "/pitlane/daemon.log")).resolves.toBe(
+      "rotated\ncurrent\n",
+    );
+  });
+
+  it("propagates the read failure when neither file exists", async () => {
+    const filesystem = new MemoryFilesystem();
+
+    await expect(readLogFile(filesystem, "/pitlane/daemon.log")).rejects.toThrow();
+  });
+});
+
 describe("CLI boundary", () => {
   it.each([
     ["QUEUE_TIMEOUT", 10],
@@ -759,6 +787,7 @@ function testConfig(): Config {
       ios: { maxDevices: 1, maxRunning: 1 },
       maxRunning: 1 + 1,
     },
+    log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
     ramBudget: { androidBytesPerDevice: 4 * gibibyte, iosBytesPerDevice: gibibyte },
   };
 }

src/cli/index.ts

@@ -8,6 +8,7 @@ import {
   NodeFilesystem,
   NodeIpcTransport,
   SystemClock,
+  type Filesystem,
 } from "../ports/index.js";
 import { connectDaemon, connectExistingDaemon } from "../daemon-client/client.js";
 import { parseRawLeaseGrant } from "../daemon-client/contracts.js";
@@ -118,7 +119,7 @@ function defaultCliEnvironment(env: NodeJS.ProcessEnv = process.env): CliEnviron
       if (!(await filesystem.exists(configPath))) return {};
       return requireObject(JSON.parse(await filesystem.readFile(configPath)) as unknown);
     },
-    readLogFile: async () => filesystem.readFile(logPath),
+    readLogFile: async () => readLogFile(filesystem, logPath),
     signals: process,
     stderr: process.stderr,
     stdout: process.stdout,
@@ -731,6 +732,21 @@ function parseConfigValue(value: string): unknown {
     return value;
   }
 }
+/**
+ * Reads the rotated generation (if present) followed by the current log, so a fatal
+ * crash written just before rotation is never silently lost. `NodeFileLogSink` keeps
+ * at most one rotated generation at `<logPath>.1`.
+ */
+export async function readLogFile(filesystem: Filesystem, logPath: string): Promise<string> {
+  const rotatedPath = `${logPath}.1`;
+  const segments: string[] = [];
+  if (await filesystem.exists(rotatedPath)) {
+    segments.push(await filesystem.readFile(rotatedPath));
+  }
+  segments.push(await filesystem.readFile(logPath));
+  return segments.join("");
+}
+
 function requireObject(value: unknown): Record<string, unknown> {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new Error("Daemon returned an invalid response");

src/core/acquisition-planner.test.ts

@@ -20,6 +20,7 @@ const config: Config = {
     maxRunning: 1,
   },
   ramBudget: { androidBytesPerDevice: 4 * gibibyte, iosBytesPerDevice: gibibyte },
+  log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
 };
 
 function device(

src/core/capacity-coordinator.test.ts

@@ -20,6 +20,7 @@ const config: Config = {
     maxRunning: 2,
   },
   ramBudget: { androidBytesPerDevice: 4 * gibibyte, iosBytesPerDevice: 1.5 * gibibyte },
+  log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
 };
 
 function coordinator(): CapacityCoordinator {

src/core/capacity.test.ts

@@ -26,6 +26,7 @@ const config: Config = {
     maxRunning: 2,
   },
   ramBudget: { androidBytesPerDevice: 4 * gibibyte, iosBytesPerDevice: 1.5 * gibibyte },
+  log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
 };
 
 function withStats(totalRamBytes: number): FakeSystemStats {

src/core/cleanup/idle-destroy.test.ts

@@ -14,6 +14,7 @@ const config: Config = {
     maxRunning: 1 + 1,
   },
   ramBudget: { androidBytesPerDevice: 1, iosBytesPerDevice: 1 },
+  log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
 };
 
 function view(now: number): RegistryView {

src/core/cleanup/idle-shutdown.test.ts

@@ -14,6 +14,7 @@ const config: Config = {
     maxRunning: 1 + 1,
   },
   ramBudget: { androidBytesPerDevice: 1, iosBytesPerDevice: 1 },
+  log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
 };
 
 function view(now: number): RegistryView {

src/core/config.test.ts

@@ -50,11 +50,44 @@ describe("loadConfig", () => {
         heartbeatIntervalMs: 5 * 60_000,
       },
       ramBudget: { androidBytesPerDevice: 4 * gibibyte, iosBytesPerDevice: 1.5 * gibibyte },
+      log: { level: "info", rotateBytes: 5 * 1024 * 1024 },
     });
     expect(Object.isFrozen(config)).toBe(true);
     expect(Object.isFrozen(config.limits)).toBe(true);
   });
 
+  it("applies a file-level log override", async () => {
+    const filesystem = new MemoryFilesystem();
+    await filesystem.mkdirp("/home/agent/.pitlane");
+    await filesystem.writeFileAtomic(
+      configPath,
+      JSON.stringify({ log: { level: "debug", rotateBytes: 1024 } }),
+    );
+
+    const config = await loadConfig({ configPath, filesystem, systemStats: createStats() });
+    expect(config.log).toEqual({ level: "debug", rotateBytes: 1024 });
+  });
+
+  it("rejects a log level outside the known set", async () => {
+    const filesystem = new MemoryFilesystem();
+    await filesystem.mkdirp("/home/agent/.pitlane");
+    await filesystem.writeFileAtomic(configPath, JSON.stringify({ log: { level: "verbose" } }));
+
+    await expect(
+      loadConfig({ configPath, filesystem, systemStats: createStats() }),
+    ).rejects.toThrow("log.level");
+  });
+
+  it("rejects a non-positive-integer log rotation cap", async () => {
+    const filesystem = new MemoryFilesystem();
+    await filesystem.mkdirp("/home/agent/.pitlane");
+    await filesystem.writeFileAtomic(configPath, JSON.stringify({ log: { rotateBytes: 0 } }));
+
+    await expect(
+      loadConfig({ configPath, filesystem, systemStats: createStats() }),
+    ).rejects.toThrow("log.rotateBytes");
+  });
+
   it("applies file values over defaults and explicit overrides over file values", async () => {
     const filesystem = new MemoryFilesystem();
     await filesystem.mkdirp("/home/agent/.pitlane");