@primitive.ai/prim 0.1.0-alpha.41 → 0.1.0-alpha.43

package/dist/daemon/server.js

@@ -1,16 +1,673 @@
 #!/usr/bin/env node
-import {
-  getClient,
-  getSiteUrl,
-  getTokenExpiresAt,
-  refreshToken
-} from "../chunk-26VA3ADF.js";
 
 // src/daemon/server.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "fs";
 import { createServer } from "net";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+import { fileURLToPath } from "url";
+
+// src/client.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
+function loadEnvFile() {
+  const envVars = {};
+  const candidates = [".env.local", ".env"];
+  for (const file of candidates) {
+    const filePath = resolve(process.cwd(), file);
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        envVars[key] = value;
+      }
+    }
+  }
+  return envVars;
+}
+var TOKEN_FILE_PATH = join(homedir(), ".config", "prim", "token");
+var REFRESH_TOKEN_PATH = TOKEN_FILE_PATH.replace("/token", "/refresh_token");
+var TOKEN_EXPIRES_PATH = join(homedir(), ".config", "prim", "token_expires_at");
+var REFRESH_THRESHOLD_MS = 6e4;
+function isTokenExpiringSoon() {
+  if (!existsSync(TOKEN_EXPIRES_PATH)) return false;
+  const expiresAt = Number(readFileSync(TOKEN_EXPIRES_PATH, "utf-8").trim());
+  return !Number.isNaN(expiresAt) && Date.now() >= expiresAt - REFRESH_THRESHOLD_MS;
+}
+function getJwtExpiry(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    return payload.exp ? payload.exp * 1e3 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function saveTokenExpiry(token, expiresIn) {
+  const expiresAt = expiresIn ? Date.now() + expiresIn * 1e3 : getJwtExpiry(token);
+  if (expiresAt) {
+    writeFileSync(TOKEN_EXPIRES_PATH, String(expiresAt), { mode: 384 });
+  }
+}
+function getTokenExpiresAt() {
+  if (!existsSync(TOKEN_EXPIRES_PATH)) return void 0;
+  const val = Number(readFileSync(TOKEN_EXPIRES_PATH, "utf-8").trim());
+  return Number.isNaN(val) ? void 0 : val;
+}
+function getAuthToken() {
+  if (process.env.PRIM_TOKEN) {
+    return process.env.PRIM_TOKEN;
+  }
+  if (existsSync(TOKEN_FILE_PATH)) {
+    const token = readFileSync(TOKEN_FILE_PATH, "utf-8").trim();
+    if (token) {
+      return token;
+    }
+  }
+  const envVars = loadEnvFile();
+  if (envVars.PRIM_TOKEN) {
+    return envVars.PRIM_TOKEN;
+  }
+  return void 0;
+}
+var DEFAULT_API_URL = "https://api.getprimitive.ai";
+function getSiteUrl() {
+  if (process.env.PRIM_API_URL) {
+    return process.env.PRIM_API_URL;
+  }
+  const envVars = loadEnvFile();
+  if (envVars.PRIM_API_URL) {
+    return envVars.PRIM_API_URL;
+  }
+  return DEFAULT_API_URL;
+}
+async function performTokenRefresh(options = {}) {
+  if (!existsSync(REFRESH_TOKEN_PATH)) {
+    return void 0;
+  }
+  const refreshTokenValue = readFileSync(REFRESH_TOKEN_PATH, "utf-8").trim();
+  if (!refreshTokenValue) {
+    return void 0;
+  }
+  const siteUrl = getSiteUrl();
+  const response = await fetch(`${siteUrl}/mcp/broker/refresh`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ refresh_token: refreshTokenValue }),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    if (options.quiet) return void 0;
+    const detail = (await response.text().catch(() => "")).slice(0, 200);
+    process.stderr.write(
+      `[prim] token refresh rejected by broker: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}
+`
+    );
+    return void 0;
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    return void 0;
+  }
+  writeFileSync(TOKEN_FILE_PATH, data.access_token, { mode: 384 });
+  if (data.refresh_token) {
+    writeFileSync(REFRESH_TOKEN_PATH, data.refresh_token, { mode: 384 });
+  }
+  saveTokenExpiry(data.access_token, data.expires_in);
+  return data.access_token;
+}
+var _refreshInFlight;
+function refreshToken(options = {}) {
+  if (_refreshInFlight) {
+    return _refreshInFlight;
+  }
+  const attempt = performTokenRefresh(options).then((token) => {
+    if (token) {
+      _cachedToken = token;
+    }
+    return token;
+  }).finally(() => {
+    if (_refreshInFlight === attempt) {
+      _refreshInFlight = void 0;
+    }
+  });
+  _refreshInFlight = attempt;
+  return attempt;
+}
+var HttpError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+  }
+};
+var _cachedToken;
+async function request(method, path, body, options) {
+  const siteUrl = getSiteUrl();
+  const url = `${siteUrl}${path}`;
+  if (!_cachedToken) {
+    _cachedToken = getAuthToken();
+  }
+  if (_cachedToken && isTokenExpiringSoon()) {
+    const newToken = await refreshToken({
+      signal: options?.signal,
+      quiet: options?.quietRefresh
+    });
+    if (newToken) {
+      _cachedToken = newToken;
+    }
+  }
+  const doFetch = async (token) => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: options?.signal
+    });
+  };
+  const tokenUsed = _cachedToken;
+  let res = await doFetch(tokenUsed);
+  if (res.status === 401) {
+    const newToken = _cachedToken && _cachedToken !== tokenUsed ? _cachedToken : await refreshToken({
+      signal: options?.signal,
+      quiet: options?.quietRefresh
+    });
+    if (newToken) {
+      _cachedToken = newToken;
+      res = await doFetch(newToken);
+    }
+  }
+  if (!res.ok) {
+    if (res.status === 401) {
+      throw new HttpError(401, "Authentication expired. Run `prim auth login` to re-authenticate.");
+    }
+    const errorBody = await res.json().catch(() => null);
+    throw new HttpError(res.status, errorBody?.error ?? `HTTP ${res.status}`);
+  }
+  return res.json();
+}
+function getClient() {
+  return {
+    get: (path, options) => request("GET", path, void 0, options),
+    post: (path, body, options) => request("POST", path, body, options)
+  };
+}
+
+// src/flusher.ts
+import { createReadStream, renameSync, unlinkSync } from "fs";
+import { createInterface } from "readline";
+
+// src/ingest-response.ts
+var IngestAcknowledgementError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IngestAcknowledgementError";
+  }
+};
+function requireDurableIngestAcknowledgement(value, expected) {
+  if (typeof value !== "object" || value === null) {
+    throw new IngestAcknowledgementError("ingest response was not an object");
+  }
+  const response = value;
+  if (response.disposition !== "persisted") {
+    throw new IngestAcknowledgementError("ingest response did not confirm persistence");
+  }
+  if (response.acknowledged !== expected) {
+    throw new IngestAcknowledgementError(
+      `ingest acknowledged ${String(response.acknowledged)} of ${String(expected)} moves`
+    );
+  }
+  return value;
+}
+
+// src/journal.ts
+import {
+  appendFileSync,
+  closeSync,
+  existsSync as existsSync2,
+  fstatSync,
+  mkdirSync,
+  openSync,
+  opendirSync,
+  readFileSync as readFileSync2,
+  readSync,
+  readdirSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var JOURNAL_DIR = join2(homedir2(), ".config", "prim", "moves");
+var JOURNAL_BASENAME = "journal.ndjson";
+var JOURNAL_STATS_SAMPLE_BYTES = 64 * 1024;
+var PENDING_STATS_MAX_FILES = 128;
+function envSlug(apiUrl) {
+  const slug = apiUrl.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  if (slug.length === 0 || slug === "." || slug === "..") {
+    return "default";
+  }
+  return slug;
+}
+function currentEnvDir() {
+  return join2(JOURNAL_DIR, envSlug(getSiteUrl()));
+}
+function parseMoves(content) {
+  const moves = [];
+  for (const line of content.split("\n")) {
+    if (line.length === 0) {
+      continue;
+    }
+    try {
+      moves.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return moves;
+}
+function listBuckets() {
+  const out = [];
+  const envDir = currentEnvDir();
+  if (!existsSync2(envDir)) {
+    return out;
+  }
+  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const path = join2(envDir, entry.name, JOURNAL_BASENAME);
+    if (existsSync2(path)) {
+      out.push({ bucket: entry.name, path });
+    }
+  }
+  return out;
+}
+var FLUSHING_PREFIX = `${JOURNAL_BASENAME}.flushing.`;
+function oldestCapturedAt(moves) {
+  let oldest;
+  for (const move of moves) {
+    if (!Number.isFinite(move.capturedAt)) {
+      continue;
+    }
+    oldest = oldest === void 0 ? move.capturedAt : Math.min(oldest, move.capturedAt);
+  }
+  return oldest;
+}
+function sampleJournalFile(path, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
+  const fd = openSync(path, "r");
+  try {
+    const initial = fstatSync(fd);
+    const target = Math.min(initial.size, Math.max(0, maxBytes));
+    const buffer = Buffer.allocUnsafe(target);
+    let sampledBytes = 0;
+    while (sampledBytes < target) {
+      const count = readSync(fd, buffer, sampledBytes, target - sampledBytes, sampledBytes);
+      if (count === 0) {
+        break;
+      }
+      sampledBytes += count;
+    }
+    const stat = fstatSync(fd);
+    const sampled = stat.size > sampledBytes;
+    let content = buffer.subarray(0, sampledBytes).toString("utf-8");
+    if (sampled) {
+      const lastNewline = content.lastIndexOf("\n");
+      content = lastNewline === -1 ? "" : content.slice(0, lastNewline + 1);
+    }
+    const lines = content.split("\n").filter((line) => line.length > 0);
+    const moves = parseMoves(content);
+    return {
+      sizeBytes: stat.size,
+      mtimeMs: stat.mtimeMs,
+      lineCount: sampled && stat.size > 0 ? Math.max(1, lines.length) : lines.length,
+      oldestCapturedAt: oldestCapturedAt(moves),
+      sampled,
+      sampledBytes
+    };
+  } finally {
+    closeSync(fd);
+  }
+}
+function parseFlushingPid(name) {
+  const segments = name.slice(FLUSHING_PREFIX.length).split(".");
+  const last = segments.length >= 2 ? segments[segments.length - 1] : void 0;
+  return last !== void 0 && /^[0-9]+$/.test(last) ? Number(last) : void 0;
+}
+function listFlushingInDir(dir, bucket, options = {}) {
+  if (!existsSync2(dir)) {
+    return [];
+  }
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  const entries = opendirSync(dir);
+  try {
+    let entry = entries.readSync();
+    while (entry && out.length < maxFiles) {
+      if (!entry.isFile() || !entry.name.startsWith(FLUSHING_PREFIX)) {
+        entry = entries.readSync();
+        continue;
+      }
+      const path = join2(dir, entry.name);
+      let sample;
+      try {
+        sample = sampleJournalFile(path, remainingBytes);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          entry = entries.readSync();
+          continue;
+        }
+        throw err;
+      }
+      remainingBytes = Math.max(0, remainingBytes - sample.sampledBytes);
+      out.push({
+        bucket,
+        path,
+        pid: parseFlushingPid(entry.name),
+        ...sample
+      });
+      entry = entries.readSync();
+    }
+  } finally {
+    entries.closeSync();
+  }
+  return out;
+}
+function listFlushing(options = {}) {
+  const envDir = currentEnvDir();
+  if (!existsSync2(envDir)) {
+    return [];
+  }
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+    if (out.length >= maxFiles) {
+      break;
+    }
+    if (entry.isDirectory()) {
+      const found = listFlushingInDir(join2(envDir, entry.name), entry.name, {
+        sampleBytes: remainingBytes,
+        maxFiles: maxFiles - out.length
+      });
+      out.push(...found);
+      remainingBytes = Math.max(
+        0,
+        remainingBytes - found.reduce((count, file) => count + file.sampledBytes, 0)
+      );
+    }
+  }
+  return out;
+}
+function bucketStats(options = {}) {
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  for (const { bucket, path } of listBuckets()) {
+    if (out.length >= maxFiles) {
+      break;
+    }
+    let sample;
+    try {
+      sample = sampleJournalFile(path, remainingBytes);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    remainingBytes = Math.max(0, remainingBytes - sample.sampledBytes);
+    out.push({
+      bucket,
+      path,
+      ...sample
+    });
+  }
+  return out;
+}
+function pendingJournalStats() {
+  const perKindBytes = Math.floor(JOURNAL_STATS_SAMPLE_BYTES / 2);
+  const perKindFiles = Math.floor(PENDING_STATS_MAX_FILES / 2);
+  const live = bucketStats({ sampleBytes: perKindBytes, maxFiles: perKindFiles });
+  const stranded = listFlushing({ sampleBytes: perKindBytes, maxFiles: perKindFiles });
+  const timestamps = [...live, ...stranded].map((entry) => entry.oldestCapturedAt).filter((value) => value !== void 0);
+  const liveSampled = live.some((entry) => entry.sampled) || live.length >= perKindFiles;
+  const strandedSampled = stranded.some((entry) => entry.sampled) || stranded.length >= perKindFiles;
+  return {
+    pendingCount: live.reduce((count, entry) => count + entry.lineCount, 0) + stranded.reduce((count, entry) => count + entry.lineCount, 0),
+    oldestPendingAt: timestamps.length > 0 ? Math.min(...timestamps) : void 0,
+    strandedCount: stranded.reduce((count, entry) => count + entry.lineCount, 0),
+    strandedFileCount: stranded.length,
+    sampled: liveSampled || strandedSampled,
+    strandedSampled
+  };
+}
+
+// src/flusher.ts
+var BATCH_SIZE = 500;
+var HTTP_TIMEOUT_MS = 1e4;
+var ORPHAN_QUARANTINE_MS = 6e4;
+async function drainFlushingPath(flushingPath, client2 = getClient()) {
+  const postBatch = async (batch2) => {
+    const response = await client2.post(
+      "/api/cli/moves/ingest",
+      { batch: batch2 },
+      { signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) }
+    );
+    requireDurableIngestAcknowledgement(response, batch2.length);
+  };
+  const input = createReadStream(flushingPath, { encoding: "utf-8" });
+  const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+  let batch = [];
+  let total = 0;
+  try {
+    for await (const line of lines) {
+      if (line.length === 0) {
+        continue;
+      }
+      try {
+        batch.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+      if (batch.length === BATCH_SIZE) {
+        await postBatch(batch);
+        total += batch.length;
+        batch = [];
+      }
+    }
+    if (batch.length > 0) {
+      await postBatch(batch);
+      total += batch.length;
+    }
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  unlinkSync(flushingPath);
+  return total;
+}
+async function drainPath(path) {
+  const tmpPath = `${path}.flushing.${String(Date.now())}.${String(process.pid)}`;
+  try {
+    renameSync(path, tmpPath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return 0;
+    }
+    throw err;
+  }
+  return drainFlushingPath(tmpPath);
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function selectRecoverable(files, now, opts = {}) {
+  const quarantineMs = opts.quarantineMs ?? ORPHAN_QUARANTINE_MS;
+  const isAlive = opts.isAlive ?? processIsAlive;
+  return files.filter((f) => {
+    if (f.pid === void 0) {
+      return now - f.mtimeMs > quarantineMs;
+    }
+    return f.pid === opts.ownerPid || !isAlive(f.pid);
+  });
+}
+async function recoverOrphans(candidates = listFlushing({ sampleBytes: 0 }), options = {}) {
+  const summary = { flushed: 0, errors: [], failedBuckets: /* @__PURE__ */ new Set() };
+  const recoverable = selectRecoverable(candidates, options.now ?? Date.now(), {
+    ownerPid: options.ownerPid ?? process.pid,
+    isAlive: options.isAlive
+  }).sort((a, b) => a.mtimeMs - b.mtimeMs || a.path.localeCompare(b.path));
+  const drain = options.drain ?? drainFlushingPath;
+  for (const file of recoverable) {
+    if (summary.failedBuckets.has(file.bucket)) {
+      continue;
+    }
+    try {
+      summary.flushed += await drain(file.path);
+    } catch (err) {
+      summary.errors.push(err);
+      summary.failedBuckets.add(file.bucket);
+    }
+  }
+  return summary;
+}
+var FlushError = class extends Error {
+  flushed;
+  constructor(cause, flushed) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "FlushError";
+    this.flushed = flushed;
+  }
+};
+async function flushOnce() {
+  const recovered = await recoverOrphans();
+  let total = recovered.flushed;
+  const errors = recovered.errors;
+  for (const { bucket, path } of listBuckets()) {
+    if (recovered.failedBuckets.has(bucket)) {
+      continue;
+    }
+    try {
+      total += await drainPath(path);
+    } catch (err) {
+      errors.push(err);
+    }
+  }
+  if (errors.length > 0) {
+    throw new FlushError(errors[0], total);
+  }
+  return { flushed: total };
+}
+var flushInFlight;
+function flush() {
+  if (flushInFlight) {
+    return flushInFlight;
+  }
+  const attempt = flushOnce().finally(() => {
+    if (flushInFlight === attempt) {
+      flushInFlight = void 0;
+    }
+  });
+  flushInFlight = attempt;
+  return attempt;
+}
+
+// src/daemon/client.ts
+import { createConnection } from "net";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var SOCK_PATH = join3(homedir3(), ".config", "prim", "sock");
+var DEFAULT_TIMEOUT_MS = 250;
+var nextRequestId = 1;
+function daemonRequest(method, params = {}, opts = {}) {
+  const id = nextRequestId++;
+  const request2 = { id, method, params };
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve2) => {
+    let settled = false;
+    let socket;
+    let buffer = "";
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (socket) {
+        try {
+          socket.destroy();
+        } catch {
+        }
+      }
+      resolve2(value);
+    };
+    const timer = setTimeout(() => settle(null), timeoutMs);
+    timer.unref();
+    try {
+      socket = createConnection(SOCK_PATH);
+    } catch {
+      clearTimeout(timer);
+      settle(null);
+      return;
+    }
+    socket.on("error", () => {
+      clearTimeout(timer);
+      settle(null);
+    });
+    socket.on("connect", () => {
+      try {
+        socket?.write(`${JSON.stringify(request2)}
+`);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf-8");
+      const newlineIdx = buffer.indexOf("\n");
+      if (newlineIdx === -1) {
+        return;
+      }
+      const line = buffer.slice(0, newlineIdx);
+      try {
+        const res = JSON.parse(line);
+        if (res.id !== id) {
+          clearTimeout(timer);
+          settle(null);
+          return;
+        }
+        clearTimeout(timer);
+        settle(res.ok && res.result !== void 0 ? res.result : null);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("end", () => {
+      if (!settled) {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+  });
+}
 
 // src/daemon/env-binding.ts
 function normalizeApiUrl(url) {
@@ -28,21 +685,242 @@ function assertCallerEnvMatches(callerEnv, boundEnv) {
   }
 }
 
+// src/daemon/health.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+var CONFIG_DIR_MODE = 448;
+var HEALTH_FILE_MODE = 384;
+var INGESTION_SLA_MS = 3e4;
+var HEARTBEAT_FRESH_MS = 9e4;
+var HEARTBEAT_RETRY_CAP_MS = 3e4;
+var INGESTION_RETRY_BASE_MS = 5e3;
+var INGESTION_RETRY_CAP_MS = 15e3;
+var DAEMON_HEALTH_PATH = join4(homedir4(), ".config", "prim", "daemon-health.json");
+function createDaemonHealthState(version, pid, startedAt2) {
+  return {
+    schemaVersion: 1,
+    version,
+    pid,
+    startedAt: startedAt2,
+    updatedAt: startedAt2,
+    healthy: false,
+    heartbeat: { healthy: false, consecutiveFailures: 0 },
+    ingestion: {
+      healthy: true,
+      consecutiveFailures: 0,
+      pendingCount: 0,
+      pendingSampled: false,
+      strandedCount: 0,
+      lastAcknowledgedCount: 0
+    }
+  };
+}
+function refreshDaemonHealth(state, now) {
+  state.heartbeat.healthy = state.heartbeat.consecutiveFailures === 0 && state.heartbeat.lastSuccessAt !== void 0 && now - state.heartbeat.lastSuccessAt < HEARTBEAT_FRESH_MS;
+  state.ingestion.healthy = state.ingestion.consecutiveFailures === 0 && !state.ingestion.pendingSampled && (state.ingestion.pendingCount === 0 || state.ingestion.oldestPendingAt !== void 0 && now - state.ingestion.oldestPendingAt <= INGESTION_SLA_MS);
+  state.healthy = state.heartbeat.healthy && state.ingestion.healthy;
+}
+function retryDelayMs(consecutiveFailures, capMs, random) {
+  const exponent = Math.max(0, consecutiveFailures - 1);
+  const base = Math.min(capMs, INGESTION_RETRY_BASE_MS * 2 ** exponent);
+  const jitter = 0.8 + Math.min(1, Math.max(0, random())) * 0.4;
+  return Math.min(capMs, Math.round(base * jitter));
+}
+function heartbeatRetryDelayMs(consecutiveFailures, random = Math.random) {
+  return retryDelayMs(consecutiveFailures, HEARTBEAT_RETRY_CAP_MS, random);
+}
+function ingestionRetryDelayMs(consecutiveFailures, random = Math.random) {
+  return retryDelayMs(consecutiveFailures, INGESTION_RETRY_CAP_MS, random);
+}
+function writeDaemonHealthState(state, path = DAEMON_HEALTH_PATH) {
+  const dir = dirname2(path);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true, mode: CONFIG_DIR_MODE });
+  }
+  const tmp = join4(dir, `.${process.pid}.daemon-health.tmp`);
+  writeFileSync2(tmp, `${JSON.stringify(state, null, 2)}
+`, { mode: HEALTH_FILE_MODE });
+  chmodSync(tmp, HEALTH_FILE_MODE);
+  renameSync2(tmp, path);
+}
+
+// src/daemon/instance-lock.ts
+import { randomUUID } from "crypto";
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  renameSync as renameSync3,
+  rmSync,
+  statSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join5 } from "path";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var DAEMON_STARTUP_GRACE_MS = 5e3;
+function readLockRecord(path) {
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf-8"));
+    if (Number.isInteger(value.pid) && typeof value.instanceId === "string" && typeof value.startedAt === "number") {
+      return value;
+    }
+  } catch {
+  }
+  return;
+}
+function numericPid(path) {
+  try {
+    const pid = Number(readFileSync3(path, "utf-8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return;
+  }
+}
+function daemonProcessIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readDaemonOwner(configDir) {
+  return readLockRecord(join5(configDir, "daemon.lock", "owner.json"));
+}
+function readDaemonPid(configDir) {
+  const path = join5(configDir, "daemon.pid");
+  const pid = numericPid(path);
+  if (pid === void 0) {
+    return;
+  }
+  try {
+    return { pid, mtimeMs: statSync(path).mtimeMs };
+  } catch {
+    return;
+  }
+}
+function acquireDaemonOwnership(configDir, opts = {}) {
+  const pid = opts.pid ?? process.pid;
+  const now = opts.now ?? Date.now();
+  const isAlive = opts.isAlive ?? daemonProcessIsAlive;
+  const lockDir = join5(configDir, "daemon.lock");
+  const ownerPath = join5(lockDir, "owner.json");
+  const pidPath = join5(configDir, "daemon.pid");
+  const instanceId = randomUUID();
+  if (!existsSync4(configDir)) {
+    mkdirSync3(configDir, { recursive: true, mode: DIR_MODE });
+  }
+  for (; ; ) {
+    try {
+      mkdirSync3(lockDir, { mode: DIR_MODE });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+      const existing = readLockRecord(ownerPath);
+      if (existing && isAlive(existing.pid)) {
+        throw new Error(`daemon already running (pid=${String(existing.pid)})`);
+      }
+      if (!existing) {
+        let mtimeMs;
+        try {
+          mtimeMs = statSync(lockDir).mtimeMs;
+        } catch (statErr) {
+          if (statErr.code === "ENOENT") {
+            continue;
+          }
+          throw statErr;
+        }
+        if (now - mtimeMs < DAEMON_STARTUP_GRACE_MS) {
+          throw new Error("daemon startup already in progress");
+        }
+      }
+      const stale = `${lockDir}.stale.${String(pid)}.${instanceId}`;
+      try {
+        renameSync3(lockDir, stale);
+        rmSync(stale, { recursive: true, force: true });
+      } catch (renameErr) {
+        if (renameErr.code !== "ENOENT") {
+          throw renameErr;
+        }
+      }
+    }
+  }
+  const ownership2 = {
+    configDir,
+    lockDir,
+    ownerPath,
+    pidPath,
+    pid,
+    instanceId
+  };
+  const record = { pid, instanceId, startedAt: now };
+  writeFileSync3(ownerPath, `${JSON.stringify(record)}
+`, { mode: FILE_MODE });
+  chmodSync2(ownerPath, FILE_MODE);
+  const legacyPid = numericPid(pidPath);
+  if (legacyPid !== void 0 && legacyPid !== pid && isAlive(legacyPid)) {
+    rmSync(lockDir, { recursive: true, force: true });
+    throw new Error(`daemon already running (pid=${String(legacyPid)})`);
+  }
+  writeFileSync3(pidPath, String(pid), { mode: FILE_MODE });
+  chmodSync2(pidPath, FILE_MODE);
+  return ownership2;
+}
+function ownsDaemonInstance(ownership2) {
+  const current = readLockRecord(ownership2.ownerPath);
+  return current?.pid === ownership2.pid && current.instanceId === ownership2.instanceId;
+}
+function releaseDaemonOwnership(ownership2, socketPath) {
+  if (!ownsDaemonInstance(ownership2)) {
+    return false;
+  }
+  let cleanupError;
+  if (socketPath) {
+    try {
+      unlinkSync2(socketPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        cleanupError = err;
+      }
+    }
+  }
+  if (numericPid(ownership2.pidPath) === ownership2.pid) {
+    try {
+      unlinkSync2(ownership2.pidPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        cleanupError ??= err;
+      }
+    }
+  }
+  rmSync(ownership2.lockDir, { recursive: true, force: true });
+  if (cleanupError) {
+    throw cleanupError;
+  }
+  return true;
+}
+
 // src/daemon/server.ts
-var CONFIG_DIR = join(homedir(), ".config", "prim");
-var SOCK_PATH = join(CONFIG_DIR, "sock");
-var PID_PATH = join(CONFIG_DIR, "daemon.pid");
+var CONFIG_DIR = join6(homedir5(), ".config", "prim");
+var SOCK_PATH2 = join6(CONFIG_DIR, "sock");
 var HEARTBEAT_INTERVAL_MS = 3e4;
+var INGESTION_POLL_INTERVAL_MS = 15e3;
 var TOKEN_CHECK_INTERVAL_MS = 6e4;
 var TOKEN_REFRESH_THRESHOLD_MS = 9e4;
 var HTTP_PROXY_TIMEOUT_MS = 1e4;
 var PRESENCE_FRESH_WINDOW_MS = 9e4;
-var SOCKET_DIR_MODE = 448;
-var PID_FILE_MODE = 384;
 var EXIT_OK = 0;
 var EXIT_CRASH = 1;
 var startedAt = Date.now();
 var client = getClient();
+var runtimeVersion = resolveRuntimeVersion();
+var daemonHealth = createDaemonHealthState(runtimeVersion, process.pid, startedAt);
 var activeSessionId = process.env.PRIM_DAEMON_SESSION_ID ?? `daemon-${process.pid}`;
 var lastHeartbeatAt;
 var lastOnlineCount;
@@ -50,57 +928,165 @@ var lastOnlineNames;
 var lastOnlineTeammates;
 var lastOkAtLocal;
 var heartbeatTimer;
+var ingestionTimer;
 var tokenCheckTimer;
-function processIsAlive(pid) {
+var heartbeatInFlight;
+var heartbeatRerunRequested = false;
+var ownership;
+var socketServer;
+var shuttingDown = false;
+function resolveRuntimeVersion() {
+  if (process.env.PRIM_RUNTIME_VERSION) {
+    return process.env.PRIM_RUNTIME_VERSION;
+  }
   try {
-    process.kill(pid, 0);
-    return true;
+    const here = fileURLToPath(new URL(".", import.meta.url));
+    const pkg = JSON.parse(readFileSync4(join6(here, "..", "..", "package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
   } catch {
-    return false;
+    return "unknown";
   }
 }
-function takePidfile() {
-  if (existsSync(PID_PATH)) {
-    const existing = Number(readFileSync(PID_PATH, "utf-8").trim());
-    if (!Number.isNaN(existing) && processIsAlive(existing)) {
-      throw new Error(`daemon already running (pid=${existing})`);
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function persistHealth() {
+  refreshDaemonHealth(daemonHealth, Date.now());
+  daemonHealth.updatedAt = Date.now();
+  try {
+    writeDaemonHealthState(daemonHealth);
+  } catch (err) {
+    process.stderr.write(`[prim-daemon] health-state error: ${errorMessage(err)}
+`);
+  }
+}
+function updatePendingHealth() {
+  const pending = pendingJournalStats();
+  daemonHealth.ingestion.pendingCount = pending.pendingCount;
+  daemonHealth.ingestion.pendingSampled = pending.sampled;
+  daemonHealth.ingestion.oldestPendingAt = pending.oldestPendingAt;
+  daemonHealth.ingestion.strandedCount = pending.strandedCount;
+}
+async function takeOwnership() {
+  const now = Date.now();
+  const recordedOwner = readDaemonOwner(CONFIG_DIR);
+  const recordedPid = readDaemonPid(CONFIG_DIR);
+  const candidatePids = new Set(
+    [recordedOwner?.pid, recordedPid?.pid].filter(
+      (pid) => pid !== void 0 && daemonProcessIsAlive(pid)
+    )
+  );
+  if (existsSync5(SOCK_PATH2) || candidatePids.size > 0) {
+    const snapshot = await daemonRequest(
+      "status_snapshot",
+      {},
+      { timeoutMs: 500 }
+    );
+    if (typeof snapshot?.pid === "number") {
+      throw new Error(`daemon already running (pid=${String(snapshot.pid)})`);
     }
   }
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true, mode: SOCKET_DIR_MODE });
+  const ownerIsStarting = recordedOwner !== void 0 && candidatePids.has(recordedOwner.pid) && now - recordedOwner.startedAt < DAEMON_STARTUP_GRACE_MS;
+  const legacyIsStarting = recordedPid !== void 0 && candidatePids.has(recordedPid.pid) && now - recordedPid.mtimeMs < DAEMON_STARTUP_GRACE_MS;
+  if (ownerIsStarting || legacyIsStarting) {
+    throw new Error("daemon startup already in progress");
   }
-  writeFileSync(PID_PATH, String(process.pid), { mode: PID_FILE_MODE });
-}
-function cleanup() {
-  try {
-    unlinkSync(SOCK_PATH);
-  } catch {
+  if (recordedOwner !== void 0 && candidatePids.has(recordedOwner.pid)) {
+    throw new Error(
+      `daemon ownership held by live pid=${String(recordedOwner.pid)} (socket unavailable)`
+    );
+  }
+  if (recordedPid !== void 0 && candidatePids.has(recordedPid.pid)) {
+    throw new Error(
+      `legacy daemon pid=${String(recordedPid.pid)} is still alive (socket unavailable)`
+    );
   }
+  ownership = acquireDaemonOwnership(CONFIG_DIR);
   try {
-    unlinkSync(PID_PATH);
-  } catch {
+    unlinkSync3(SOCK_PATH2);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
+function cleanup() {
+  if (ownership) {
+    try {
+      releaseDaemonOwnership(ownership, SOCK_PATH2);
+    } catch (err) {
+      process.stderr.write(`[prim-daemon] cleanup error: ${errorMessage(err)}
+`);
+    }
   }
 }
-async function sendHeartbeat() {
+async function performHeartbeat() {
+  daemonHealth.heartbeat.lastAttemptAt = Date.now();
+  persistHealth();
   try {
-    const result = await client.post("/api/cli/presence/heartbeat", {
-      sessionId: activeSessionId
-    });
+    const result = await client.post(
+      "/api/cli/presence/heartbeat",
+      { sessionId: activeSessionId },
+      { signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS) }
+    );
     if (result.accepted) {
-      lastOkAtLocal = Date.now();
+      const now = Date.now();
+      lastOkAtLocal = now;
+      daemonHealth.heartbeat.lastSuccessAt = now;
+      daemonHealth.heartbeat.lastError = void 0;
+      daemonHealth.heartbeat.consecutiveFailures = 0;
       if (typeof result.lastHeartbeatAt === "number") {
         lastHeartbeatAt = result.lastHeartbeatAt;
       }
       lastOnlineCount = typeof result.onlineCount === "number" ? result.onlineCount : void 0;
       lastOnlineNames = Array.isArray(result.onlineNames) ? result.onlineNames : void 0;
       lastOnlineTeammates = Array.isArray(result.onlineTeammates) ? result.onlineTeammates : void 0;
+    } else {
+      daemonHealth.heartbeat.lastRejectedAt = Date.now();
+      daemonHealth.heartbeat.lastError = typeof result.unavailable === "string" ? result.unavailable : "heartbeat rejected";
+      daemonHealth.heartbeat.consecutiveFailures += 1;
     }
+    persistHealth();
   } catch (err) {
-    process.stderr.write(
-      `[prim-daemon] heartbeat error: ${err instanceof Error ? err.message : String(err)}
-`
-    );
+    daemonHealth.heartbeat.lastError = errorMessage(err);
+    daemonHealth.heartbeat.consecutiveFailures += 1;
+    persistHealth();
+    process.stderr.write(`[prim-daemon] heartbeat error: ${errorMessage(err)}
+`);
+  }
+}
+function sendHeartbeat() {
+  if (heartbeatInFlight) {
+    heartbeatRerunRequested = true;
+    return heartbeatInFlight;
+  }
+  if (heartbeatTimer) {
+    clearTimeout(heartbeatTimer);
+    heartbeatTimer = void 0;
+  }
+  heartbeatInFlight = (async () => {
+    do {
+      heartbeatRerunRequested = false;
+      await performHeartbeat();
+    } while (heartbeatRerunRequested && !shuttingDown);
+  })().finally(() => {
+    heartbeatInFlight = void 0;
+    scheduleHeartbeat();
+  });
+  return heartbeatInFlight;
+}
+function scheduleHeartbeat() {
+  if (shuttingDown) {
+    return;
   }
+  const failures = daemonHealth.heartbeat.consecutiveFailures;
+  const delay = failures > 0 ? heartbeatRetryDelayMs(failures) : HEARTBEAT_INTERVAL_MS;
+  daemonHealth.heartbeat.nextRetryAt = failures > 0 ? Date.now() + delay : void 0;
+  persistHealth();
+  heartbeatTimer = setTimeout(() => {
+    heartbeatTimer = void 0;
+    void sendHeartbeat();
+  }, delay);
 }
 async function ensureTokenFresh() {
   const expiresAt = getTokenExpiresAt();
@@ -109,11 +1095,70 @@ async function ensureTokenFresh() {
   }
   if (Date.now() >= expiresAt - TOKEN_REFRESH_THRESHOLD_MS) {
     try {
-      await refreshToken();
+      await refreshToken({ signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS) });
     } catch {
     }
   }
 }
+function scheduleIngestion(delayMs) {
+  if (shuttingDown) {
+    return;
+  }
+  ingestionTimer = setTimeout(() => {
+    ingestionTimer = void 0;
+    void runIngestionLoop();
+  }, delayMs);
+}
+async function runIngestionLoop() {
+  try {
+    updatePendingHealth();
+  } catch (err) {
+    const failures = daemonHealth.ingestion.consecutiveFailures + 1;
+    const delay = ingestionRetryDelayMs(failures);
+    daemonHealth.ingestion.consecutiveFailures = failures;
+    daemonHealth.ingestion.lastError = `journal scan failed: ${errorMessage(err)}`;
+    daemonHealth.ingestion.nextRetryAt = Date.now() + delay;
+    persistHealth();
+    scheduleIngestion(delay);
+    return;
+  }
+  if (daemonHealth.ingestion.pendingCount === 0 && !daemonHealth.ingestion.pendingSampled) {
+    daemonHealth.ingestion.consecutiveFailures = 0;
+    daemonHealth.ingestion.lastError = void 0;
+    daemonHealth.ingestion.nextRetryAt = void 0;
+    persistHealth();
+    scheduleIngestion(INGESTION_POLL_INTERVAL_MS);
+    return;
+  }
+  daemonHealth.ingestion.lastAttemptAt = Date.now();
+  daemonHealth.ingestion.nextRetryAt = void 0;
+  persistHealth();
+  try {
+    const result = await flush();
+    daemonHealth.ingestion.lastSuccessAt = Date.now();
+    daemonHealth.ingestion.lastAcknowledgedCount = result.flushed;
+    daemonHealth.ingestion.consecutiveFailures = 0;
+    daemonHealth.ingestion.lastError = void 0;
+    updatePendingHealth();
+    persistHealth();
+    scheduleIngestion(INGESTION_POLL_INTERVAL_MS);
+  } catch (err) {
+    const failures = daemonHealth.ingestion.consecutiveFailures + 1;
+    const delay = ingestionRetryDelayMs(failures);
+    daemonHealth.ingestion.lastAcknowledgedCount = err instanceof FlushError ? err.flushed : 0;
+    daemonHealth.ingestion.consecutiveFailures = failures;
+    daemonHealth.ingestion.lastError = errorMessage(err);
+    daemonHealth.ingestion.nextRetryAt = Date.now() + delay;
+    try {
+      updatePendingHealth();
+    } catch {
+    }
+    persistHealth();
+    process.stderr.write(`[prim-daemon] ingestion error: ${errorMessage(err)}
+`);
+    scheduleIngestion(delay);
+  }
+}
 async function handleConflictCheck(params) {
   assertCallerEnvMatches(params.callerEnv, getSiteUrl());
   if (typeof params.file !== "string") {
@@ -139,11 +1184,22 @@ async function proxyGet(params, allowedPrefix) {
   return await client.get(path, { signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS) });
 }
 function handleStatusSnapshot(params) {
+  const wasHealthy = daemonHealth.healthy;
+  const heartbeatWasHealthy = daemonHealth.heartbeat.healthy;
+  const ingestionWasHealthy = daemonHealth.ingestion.healthy;
+  refreshDaemonHealth(daemonHealth, Date.now());
+  if (wasHealthy !== daemonHealth.healthy || heartbeatWasHealthy !== daemonHealth.heartbeat.healthy || ingestionWasHealthy !== daemonHealth.ingestion.healthy) {
+    persistHealth();
+  }
   const base = {
     pid: process.pid,
     uptimeMs: Date.now() - startedAt,
     sessionId: activeSessionId,
-    lastHeartbeatAt
+    lastHeartbeatAt,
+    version: runtimeVersion,
+    healthy: daemonHealth.healthy,
+    heartbeat: { ...daemonHealth.heartbeat },
+    ingestion: { ...daemonHealth.ingestion }
   };
   if (isCrossEnv(params.callerEnv, getSiteUrl())) {
     return {
@@ -155,7 +1211,7 @@ function handleStatusSnapshot(params) {
       envMismatch: true
     };
   }
-  const presenceFresh = lastOkAtLocal !== void 0 && Date.now() - lastOkAtLocal < PRESENCE_FRESH_WINDOW_MS;
+  const presenceFresh = lastOkAtLocal !== void 0 && daemonHealth.heartbeat.consecutiveFailures === 0 && Date.now() - lastOkAtLocal < PRESENCE_FRESH_WINDOW_MS;
   const presenceStale = lastOkAtLocal !== void 0 && !presenceFresh;
   return {
     ...base,
@@ -245,68 +1301,85 @@ function handleConnection(conn) {
   conn.on("error", () => {
   });
 }
-function startSocketServer() {
+function shutdown(exitCode, reason) {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  process.stderr.write(`${reason}
+`);
+  stopTimers();
   try {
-    unlinkSync(SOCK_PATH);
+    socketServer?.close();
   } catch {
   }
-  const server = createServer(handleConnection);
-  server.on("error", (err) => {
-    process.stderr.write(`[prim-daemon] socket error: ${err.message}
-`);
+  cleanup();
+  process.exit(exitCode);
+}
+function startSocketServer() {
+  socketServer = createServer(handleConnection);
+  socketServer.on("error", (err) => {
+    shutdown(EXIT_CRASH, `[prim-daemon] fatal socket error: ${err.message}`);
   });
-  server.listen(SOCK_PATH, () => {
-    process.stderr.write(`[prim-daemon] listening on ${SOCK_PATH}
+  socketServer.listen(SOCK_PATH2, () => {
+    process.stderr.write(`[prim-daemon] listening on ${SOCK_PATH2}
 `);
+    startTimers();
+    process.stderr.write(
+      `[prim-daemon] started (pid=${process.pid}, session=${activeSessionId}, version=${runtimeVersion})
+`
+    );
   });
 }
 function startTimers() {
+  persistHealth();
   void sendHeartbeat();
-  heartbeatTimer = setInterval(() => {
-    void sendHeartbeat();
-  }, HEARTBEAT_INTERVAL_MS);
-  tokenCheckTimer = setInterval(() => {
-    void ensureTokenFresh();
-  }, TOKEN_CHECK_INTERVAL_MS);
+  void runIngestionLoop();
+  void runTokenCheckLoop();
+}
+async function runTokenCheckLoop() {
+  await ensureTokenFresh();
+  if (!shuttingDown) {
+    tokenCheckTimer = setTimeout(() => {
+      tokenCheckTimer = void 0;
+      void runTokenCheckLoop();
+    }, TOKEN_CHECK_INTERVAL_MS);
+  }
 }
 function stopTimers() {
   if (heartbeatTimer) {
-    clearInterval(heartbeatTimer);
+    clearTimeout(heartbeatTimer);
+  }
+  if (ingestionTimer) {
+    clearTimeout(ingestionTimer);
   }
   if (tokenCheckTimer) {
-    clearInterval(tokenCheckTimer);
+    clearTimeout(tokenCheckTimer);
   }
 }
 function installSignalHandlers() {
   for (const signal of ["SIGTERM", "SIGINT"]) {
     process.on(signal, () => {
-      process.stderr.write(`[prim-daemon] ${signal}, shutting down (pid=${process.pid})
-`);
-      stopTimers();
-      cleanup();
-      process.exit(EXIT_OK);
+      shutdown(EXIT_OK, `[prim-daemon] ${signal}, shutting down (pid=${process.pid})`);
     });
   }
   process.on("uncaughtException", (err) => {
-    process.stderr.write(`[prim-daemon] uncaught: ${err.message}
-`);
-    stopTimers();
-    cleanup();
-    process.exit(EXIT_CRASH);
+    shutdown(EXIT_CRASH, `[prim-daemon] uncaught: ${err.message}`);
+  });
+  process.on("unhandledRejection", (err) => {
+    shutdown(EXIT_CRASH, `[prim-daemon] unhandled rejection: ${errorMessage(err)}`);
   });
 }
-function main() {
+async function main() {
   try {
-    takePidfile();
+    await takeOwnership();
   } catch (err) {
-    process.stderr.write(`[prim-daemon] ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`[prim-daemon] ${errorMessage(err)}
 `);
+    cleanup();
     process.exit(EXIT_CRASH);
   }
   installSignalHandlers();
   startSocketServer();
-  startTimers();
-  process.stderr.write(`[prim-daemon] started (pid=${process.pid}, session=${activeSessionId})
-`);
 }
-main();
+void main();