@onklave/agent-cli 0.1.12 → 0.1.13

package/main.js

@@ -96,7 +96,7 @@ var AuthService = class {
   /*
    * Save the device token received during machine registration.
    */
-  async saveDeviceToken(deviceToken, machineId) {
+  async saveDeviceToken(deviceToken, machineId, deviceTokenExpiresAt) {
     this.ensureConfigDir();
     const existing = await this.getCredentials();
     if (!existing) {
@@ -107,7 +107,8 @@ var AuthService = class {
     const credentials = {
       ...existing,
       deviceToken,
-      machineId
+      machineId,
+      ...deviceTokenExpiresAt ? { deviceTokenExpiresAt } : {}
     };
     fs.writeFileSync(
       this.credentialsPath,
@@ -554,13 +555,41 @@ var PlatformClient = class {
    * Register this machine as an agent runner.
    */
   async registerMachine(linkingToken, metadata) {
+    return this.request("POST", "/api/v1/runner/register", {
+      linkingToken,
+      metadata
+    });
+  }
+  /*
+   * V6-CLI-002 Phase 6 — refresh the device token without re-running
+   * the linking-token flow. Caller authenticates with the current
+   * device token; backend issues a fresh one with extended expiry.
+   */
+  async refreshDeviceToken(currentDeviceToken) {
+    return this.request("POST", "/api/v1/runner/register/refresh", void 0, {
+      "x-device-token": currentDeviceToken
+    });
+  }
+  /*
+   * V6-CLI-002 Phase 5b — claim an assignment as the registered runner.
+   */
+  async claimAssignment(assignmentId, machineId, deviceToken) {
     return this.request(
       "POST",
-      "/api/v1/runner/register",
-      {
-        linkingToken,
-        metadata
-      }
+      `/api/v1/runner/assignments/${assignmentId}/claim`,
+      { machineId },
+      { "x-device-token": deviceToken }
+    );
+  }
+  /*
+   * V6-CLI-002 Phase 5c — release a previously claimed assignment.
+   */
+  async releaseAssignment(assignmentId, machineId, reason, deviceToken) {
+    return this.request(
+      "POST",
+      `/api/v1/runner/assignments/${assignmentId}/release`,
+      { machineId, reason },
+      { "x-device-token": deviceToken }
     );
   }
   /*
@@ -604,12 +633,13 @@ var PlatformClient = class {
   /*
    * Make an authenticated HTTP request to the platform.
    */
-  async request(method, path7, body) {
+  async request(method, path7, body, extraHeaders) {
     const url = `${this.baseUrl}${path7}`;
     const headers = {
       Authorization: `Bearer ${this.token}`,
       "Content-Type": "application/json",
-      Accept: "application/json"
+      Accept: "application/json",
+      ...extraHeaders ?? {}
     };
     const options = {
       method,
@@ -919,7 +949,13 @@ var DAEMON_AUDIT_ACTIONS = {
   AUTH_WARNING: "daemon.auth_warning",
   AUTH_EXPIRED: "daemon.auth_expired",
   HEARTBEAT_FAILED: "daemon.heartbeat_failed",
-  RESOURCE_LIMIT_BREACHED: "daemon.resource_limit_breached"
+  RESOURCE_LIMIT_BREACHED: "daemon.resource_limit_breached",
+  SESSION_CLAIMED: "daemon.session_claimed",
+  SESSION_COMPLETED: "daemon.session_completed",
+  SESSION_FAILED: "daemon.session_failed",
+  UPDATE_AVAILABLE: "daemon.update_available",
+  UPDATE_APPLIED: "daemon.update_applied",
+  UPDATE_FAILED: "daemon.update_failed"
 };
 
 // _apps/@onklave/agent-cli/src/services/state-publisher.ts
@@ -2789,7 +2825,11 @@ Machine ${creds.machineId} updated successfully.`);
       linkingToken,
       metadata
     );
-    await authService.saveDeviceToken(result.deviceToken, result.machineId);
+    await authService.saveDeviceToken(
+      result.deviceToken,
+      result.machineId,
+      result.deviceTokenExpiresAt
+    );
     console.log(`
 Machine registered successfully.`);
     console.log(`  Machine ID: ${result.machineId}`);
@@ -2938,10 +2978,591 @@ function defaultSleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
+// _apps/@onklave/agent-cli/src/services/daemon-claim-handler.service.ts
+var DaemonClaimHandler = class {
+  constructor(opts) {
+    this.activeSessions = 0;
+    this.machineId = opts.machineId;
+    this.audit = opts.audit;
+    this.maxConcurrentSessions = opts.maxConcurrentSessions ?? 2;
+    this.spawnRunner = opts.spawnRunner ?? defaultSpawnStub;
+    this.platformClient = opts.platformClient;
+    this.deviceToken = opts.deviceToken;
+    this.resourceSampler = opts.resourceSampler;
+    this.maxCpuPercent = opts.maxCpuPercent ?? 80;
+    this.maxMemoryBytes = opts.maxMemoryBytes;
+  }
+  /**
+   * Wire up the inbound event subscriptions. Call after the socket has
+   * connected — CommsClient `onSpawnRequest` / `onAssignmentAvailable`
+   * register handlers via `this.socket?.on(...)` which is a no-op when
+   * the socket is null.
+   */
+  attachToSocket(comms) {
+    comms.onSpawnRequest((req) => {
+      void this.handleSpawn(req);
+    });
+    comms.onAssignmentAvailable((event) => {
+      void this.handleAssignmentAvailable(event);
+    });
+  }
+  getActiveSessionCount() {
+    return this.activeSessions;
+  }
+  getMaxConcurrentSessions() {
+    return this.maxConcurrentSessions;
+  }
+  canAcceptNew() {
+    if (this.activeSessions >= this.maxConcurrentSessions) return false;
+    const breach = this.checkResourceLimits();
+    return breach == null;
+  }
+  /**
+   * Returns the resource limit that would be breached by accepting a
+   * new claim, or null if all limits are within bounds. Exposed so
+   * `daemon status` can surface which limit is the active gate.
+   */
+  checkResourceLimits() {
+    if (!this.resourceSampler) return null;
+    const snap = this.resourceSampler.snapshot();
+    if (snap.sampleCount === 0) return null;
+    if (snap.cpuPercent > this.maxCpuPercent) {
+      return {
+        limit: "cpu",
+        current: snap.cpuPercent,
+        max: this.maxCpuPercent
+      };
+    }
+    if (this.maxMemoryBytes != null && snap.memoryRssBytes > this.maxMemoryBytes) {
+      return {
+        limit: "memory",
+        current: snap.memoryRssBytes,
+        max: this.maxMemoryBytes
+      };
+    }
+    return null;
+  }
+  /**
+   * Test-and-runtime hook: process an `agent:spawn` payload as if it had
+   * arrived over the socket. Exposed for unit tests and for the
+   * future re-emit-after-claim path; the live wiring is in the
+   * constructor's `onSpawnRequest` registration.
+   */
+  async handleSpawn(req) {
+    if (this.activeSessions >= this.maxConcurrentSessions) {
+      this.emitResourceLimitBreached(req.sessionId, "agent:spawn", {
+        limit: "sessions",
+        current: this.activeSessions,
+        max: this.maxConcurrentSessions
+      });
+      return;
+    }
+    const resourceBreach = this.checkResourceLimits();
+    if (resourceBreach) {
+      this.emitResourceLimitBreached(
+        req.sessionId,
+        "agent:spawn",
+        resourceBreach
+      );
+      return;
+    }
+    this.activeSessions += 1;
+    this.audit.record({
+      sessionId: req.sessionId,
+      type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+      action: DAEMON_AUDIT_ACTIONS.SESSION_CLAIMED,
+      details: {
+        machineId: this.machineId,
+        orgId: req.orgId,
+        task: truncate2(req.task, 120)
+      },
+      outcome: "success"
+    });
+    try {
+      await this.spawnRunner(req);
+      this.audit.record({
+        sessionId: req.sessionId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.SESSION_COMPLETED,
+        details: { machineId: this.machineId },
+        outcome: "success"
+      });
+    } catch (err) {
+      this.audit.record({
+        sessionId: req.sessionId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.SESSION_FAILED,
+        details: {
+          machineId: this.machineId,
+          error: err.message
+        },
+        outcome: "failure"
+      });
+    } finally {
+      this.activeSessions -= 1;
+    }
+  }
+  async handleAssignmentAvailable(event) {
+    if (this.activeSessions >= this.maxConcurrentSessions) {
+      this.emitResourceLimitBreached(
+        event.assignmentId,
+        "assignment:claim-available",
+        {
+          limit: "sessions",
+          current: this.activeSessions,
+          max: this.maxConcurrentSessions
+        }
+      );
+      return;
+    }
+    const resourceBreach = this.checkResourceLimits();
+    if (resourceBreach) {
+      this.emitResourceLimitBreached(
+        event.assignmentId,
+        "assignment:claim-available",
+        resourceBreach
+      );
+      return;
+    }
+    if (!this.platformClient || !this.deviceToken) {
+      console.log(
+        `[daemon] assignment:claim-available assignmentId=${event.assignmentId} (platformClient not wired \u2014 Phase 5b config missing)`
+      );
+      return;
+    }
+    try {
+      const result = await this.platformClient.claimAssignment(
+        event.assignmentId,
+        this.machineId,
+        this.deviceToken
+      );
+      this.audit.record({
+        sessionId: event.assignmentId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.SESSION_CLAIMED,
+        details: {
+          machineId: this.machineId,
+          orgId: event.orgId,
+          workItemId: event.workItemId,
+          claimedAt: result.claimedAt,
+          via: "assignment:claim-available"
+        },
+        outcome: "success"
+      });
+    } catch (err) {
+      this.audit.record({
+        sessionId: event.assignmentId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.SESSION_FAILED,
+        details: {
+          machineId: this.machineId,
+          phase: "claim",
+          error: err.message
+        },
+        outcome: "failure"
+      });
+    }
+  }
+  /**
+   * Phase 5c — release a previously claimed assignment when the
+   * daemon cannot proceed (e.g. drain interrupted, capacity check
+   * failed mid-flight). Best-effort: failures here are logged but
+   * the daemon's local state already moved on.
+   */
+  async releaseClaim(assignmentId, reason) {
+    if (!this.platformClient || !this.deviceToken) return;
+    try {
+      await this.platformClient.releaseAssignment(
+        assignmentId,
+        this.machineId,
+        reason,
+        this.deviceToken
+      );
+    } catch (err) {
+      console.warn(
+        `[daemon] release ${assignmentId} failed: ${err.message}`
+      );
+    }
+  }
+  emitResourceLimitBreached(refId, trigger, breach) {
+    this.audit.record({
+      sessionId: refId,
+      type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+      action: DAEMON_AUDIT_ACTIONS.RESOURCE_LIMIT_BREACHED,
+      details: {
+        machineId: this.machineId,
+        trigger,
+        limit: breach.limit,
+        current: breach.current,
+        max: breach.max,
+        activeSessions: this.activeSessions,
+        maxConcurrentSessions: this.maxConcurrentSessions
+      },
+      outcome: "failure"
+    });
+  }
+};
+async function defaultSpawnStub(request) {
+  console.log(
+    `[daemon] STUB: would spawn session ${request.sessionId} for task: ${truncate2(request.task, 80)}`
+  );
+  await new Promise((r) => setTimeout(r, 100));
+}
+function truncate2(s, n) {
+  if (!s) return s;
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+
+// _apps/@onklave/agent-cli/src/services/daemon-resource-sampler.service.ts
+import * as os4 from "os";
+var DEFAULT_SAMPLE_INTERVAL_MS = 5e3;
+var DEFAULT_WINDOW_MS = 6e4;
+var DaemonResourceSampler = class {
+  constructor(opts = {}) {
+    this.samples = [];
+    this.timer = null;
+    this.sampleIntervalMs = opts.sampleIntervalMs ?? DEFAULT_SAMPLE_INTERVAL_MS;
+    this.windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+    this.cpuSource = opts.cpuSource ?? defaultCpuPercent;
+    this.memorySource = opts.memorySource ?? defaultMemoryRss;
+  }
+  /**
+   * Start the periodic sampler. Idempotent — second start is a no-op.
+   * The timer is `unref()`'d so a daemon that has nothing else to do
+   * (no in-flight sessions, no inbound events) does not stay alive only
+   * because of the sampler.
+   */
+  start() {
+    if (this.timer) return;
+    this.sample();
+    this.timer = setInterval(() => this.sample(), this.sampleIntervalMs);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Returns the windowed average of CPU% and the latest memory RSS.
+   * Memory is *not* averaged — the RSS at sample time is what matters
+   * for "can we fit another session right now".
+   */
+  snapshot() {
+    if (this.samples.length === 0) {
+      return {
+        cpuPercent: 0,
+        memoryRssBytes: 0,
+        sampleCount: 0,
+        windowMs: this.windowMs
+      };
+    }
+    const cpuAvg = this.samples.reduce((sum, s) => sum + s.cpuPercent, 0) / this.samples.length;
+    const memLatest = this.samples[this.samples.length - 1].memoryRssBytes;
+    return {
+      cpuPercent: cpuAvg,
+      memoryRssBytes: memLatest,
+      sampleCount: this.samples.length,
+      windowMs: this.windowMs
+    };
+  }
+  /** Take one sample now. Exposed for tests; called internally by start. */
+  sample() {
+    const now = Date.now();
+    this.samples.push({
+      at: now,
+      cpuPercent: this.cpuSource(),
+      memoryRssBytes: this.memorySource()
+    });
+    const cutoff = now - this.windowMs;
+    while (this.samples.length > 0 && this.samples[0].at < cutoff) {
+      this.samples.shift();
+    }
+  }
+};
+function defaultCpuPercent() {
+  const cpus2 = os4.cpus().length || 1;
+  const load1m = os4.loadavg()[0];
+  return load1m / cpus2 * 100;
+}
+function defaultMemoryRss() {
+  return process.memoryUsage().rss;
+}
+
+// _apps/@onklave/agent-cli/src/services/daemon-spawner.service.ts
+var DaemonSpawner = class {
+  constructor(opts) {
+    this.sessionManager = opts.sessionManager ?? new SessionManager();
+    this.platformUrl = opts.platformUrl;
+  }
+  async runSpawnRequest(req) {
+    const config = {
+      task: req.task,
+      context: req.context,
+      persona: req.persona,
+      workflow: req.workflow,
+      model: req.model,
+      timeout: req.timeout,
+      guardrails: [],
+      allowedTools: [],
+      deniedTools: [],
+      apiKey: req.apiKey ?? null,
+      headless: true,
+      platformUrl: this.platformUrl,
+      orgId: req.orgId,
+      systemPromptAppend: null
+    };
+    return new Promise((resolve3, reject) => {
+      void this.sessionManager.spawnSession(req.sessionId, config, {
+        onStdout: (data) => {
+          process.stdout.write(data);
+        },
+        onStderr: (data) => {
+          process.stderr.write(data);
+        },
+        onExit: (code, signal) => {
+          if (code === 0) {
+            resolve3();
+          } else {
+            reject(
+              new Error(
+                `session ${req.sessionId} exited with code=${code} signal=${signal}`
+              )
+            );
+          }
+        }
+      });
+    });
+  }
+};
+
+// _apps/@onklave/agent-cli/src/services/daemon-token-observer.service.ts
+var WARNING_THRESHOLD_DAYS = 30;
+var DaemonTokenObserver = class {
+  constructor(opts) {
+    this.warningEmitted = false;
+    this.expiredEmitted = false;
+    this.machineId = opts.machineId;
+    this.audit = opts.audit;
+    this.expiresAt = opts.deviceTokenExpiresAt ? new Date(opts.deviceTokenExpiresAt) : null;
+    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /**
+   * Update the tracked expiry after a successful refresh. Resets the
+   * one-shot emitted flags so a future warning / expiry can re-emit.
+   */
+  updateExpiry(newExpiresAt) {
+    this.expiresAt = new Date(newExpiresAt);
+    this.warningEmitted = false;
+    this.expiredEmitted = false;
+  }
+  /**
+   * Snapshot the current expiry status. Idempotent — does not emit audit
+   * events. Use {@link emitIfNeeded} for the side-effectful check.
+   */
+  status() {
+    if (!this.expiresAt || Number.isNaN(this.expiresAt.getTime())) {
+      return {
+        state: "unknown",
+        message: "device token expiry not recorded \u2014 re-register to refresh"
+      };
+    }
+    const msRemaining = this.expiresAt.getTime() - this.now().getTime();
+    if (msRemaining <= 0) {
+      return { state: "expired", expiresAt: this.expiresAt.toISOString() };
+    }
+    const daysRemaining = Math.floor(msRemaining / (24 * 60 * 60 * 1e3));
+    if (daysRemaining <= WARNING_THRESHOLD_DAYS) {
+      return {
+        state: "warning",
+        daysRemaining,
+        expiresAt: this.expiresAt.toISOString()
+      };
+    }
+    return {
+      state: "ok",
+      daysRemaining,
+      expiresAt: this.expiresAt.toISOString()
+    };
+  }
+  /**
+   * Emit audit events for state changes (warning crossed, expiry hit).
+   * Emits at most one warning and one expired event per observer
+   * instance — repeated calls are silent until process restart.
+   */
+  emitIfNeeded() {
+    const status = this.status();
+    if (status.state === "expired" && !this.expiredEmitted) {
+      this.audit.record({
+        sessionId: this.machineId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.AUTH_EXPIRED,
+        details: { machineId: this.machineId, expiresAt: status.expiresAt },
+        outcome: "failure"
+      });
+      this.expiredEmitted = true;
+    } else if (status.state === "warning" && !this.warningEmitted) {
+      this.audit.record({
+        sessionId: this.machineId,
+        type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+        action: DAEMON_AUDIT_ACTIONS.AUTH_WARNING,
+        details: {
+          machineId: this.machineId,
+          daysRemaining: status.daysRemaining,
+          expiresAt: status.expiresAt
+        },
+        outcome: "success"
+      });
+      this.warningEmitted = true;
+    }
+    return status;
+  }
+  /** True iff the token has expired right now. */
+  isExpired() {
+    return this.status().state === "expired";
+  }
+};
+
+// _apps/@onklave/agent-cli/src/services/daemon-token-refresher.service.ts
+var REFRESH_THRESHOLD_DAYS = 7;
+var DaemonTokenRefresher = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.inFlight = false;
+    this.lastAttemptAt = null;
+  }
+  /**
+   * Idempotent tick — call from the heartbeat / runtime publisher loop.
+   * Does nothing if the token is healthy (>7 days remaining), if the
+   * token's expiry is unknown, or if a refresh is already in flight.
+   */
+  async maybeRefresh() {
+    if (this.inFlight) return;
+    const status = this.opts.observer.status();
+    if (status.state === "unknown") return;
+    if (status.state === "expired") return;
+    if (status.daysRemaining > REFRESH_THRESHOLD_DAYS) return;
+    this.inFlight = true;
+    this.lastAttemptAt = /* @__PURE__ */ new Date();
+    try {
+      const currentToken = this.opts.getDeviceToken();
+      const result = await this.opts.platformClient.refreshDeviceToken(
+        currentToken
+      );
+      await this.opts.authService.saveDeviceToken(
+        result.deviceToken,
+        this.opts.machineId,
+        result.deviceTokenExpiresAt
+      );
+      this.opts.observer.updateExpiry(result.deviceTokenExpiresAt);
+      this.opts.onTokenRefreshed?.(
+        result.deviceToken,
+        result.deviceTokenExpiresAt
+      );
+    } catch (err) {
+      console.warn(
+        `[daemon] device-token refresh failed: ${err.message} (will retry)`
+      );
+    } finally {
+      this.inFlight = false;
+    }
+  }
+  /** Most recent refresh-attempt time, or null if never tried. */
+  getLastAttemptAt() {
+    return this.lastAttemptAt;
+  }
+};
+
+// _apps/@onklave/agent-cli/src/services/daemon-update-checker.service.ts
+var REGISTRY_URL = "https://registry.npmjs.org";
+var PACKAGE_NAME = "@onklave/agent-cli";
+var DaemonUpdateChecker = class {
+  constructor(opts) {
+    this.latestVersion = null;
+    this.lastCheckedAt = null;
+    this.emittedForVersion = null;
+    this.currentVersion = opts.currentVersion;
+    this.audit = opts.audit;
+    this.registryFetcher = opts.registryFetcher ?? defaultRegistryFetcher;
+  }
+  /**
+   * Hit the registry. On success, sets latestVersion and (if newer than
+   * current) emits `daemon.update_available` — exactly once per version,
+   * even across repeated checks. On failure, logs and returns; the next
+   * tick can retry.
+   */
+  async check() {
+    try {
+      const latest = await this.registryFetcher(PACKAGE_NAME);
+      this.latestVersion = latest;
+      this.lastCheckedAt = /* @__PURE__ */ new Date();
+      if (isNewerVersion(latest, this.currentVersion) && this.emittedForVersion !== latest) {
+        this.audit.record({
+          sessionId: this.currentVersion,
+          type: "daemon_lifecycle" /* DAEMON_LIFECYCLE */,
+          action: DAEMON_AUDIT_ACTIONS.UPDATE_AVAILABLE,
+          details: {
+            currentVersion: this.currentVersion,
+            latestVersion: latest
+          },
+          outcome: "success"
+        });
+        this.emittedForVersion = latest;
+      }
+    } catch (err) {
+      console.warn(
+        `[daemon] update check failed: ${err.message} (will retry)`
+      );
+    }
+  }
+  info() {
+    return {
+      currentVersion: this.currentVersion,
+      latestVersion: this.latestVersion,
+      updateAvailable: !!this.latestVersion && isNewerVersion(this.latestVersion, this.currentVersion),
+      checkedAt: this.lastCheckedAt?.toISOString() ?? null
+    };
+  }
+};
+async function defaultRegistryFetcher(packageName) {
+  const url = `${REGISTRY_URL}/${encodeURIComponent(packageName)}/latest`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    throw new Error(`registry ${response.status} ${response.statusText}`);
+  }
+  const body = await response.json();
+  if (!body.version) throw new Error("registry response missing version");
+  return body.version;
+}
+function isNewerVersion(a, b) {
+  const pa = parseSemverNumeric(a);
+  const pb = parseSemverNumeric(b);
+  if (!pa || !pb) return false;
+  for (let i = 0; i < 3; i += 1) {
+    if (pa[i] > pb[i]) return true;
+    if (pa[i] < pb[i]) return false;
+  }
+  return false;
+}
+function parseSemverNumeric(v) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
+  if (!match) return null;
+  return [
+    Number.parseInt(match[1], 10),
+    Number.parseInt(match[2], 10),
+    Number.parseInt(match[3], 10)
+  ];
+}
+
 // _apps/@onklave/agent-cli/src/services/daemon-state.service.ts
 import * as fs5 from "fs";
 import * as path6 from "path";
-import * as os4 from "os";
+import * as os5 from "os";
 var VALID_TRANSITIONS = {
   installing: ["registered"],
   registered: ["starting"],
@@ -2952,10 +3573,10 @@ var VALID_TRANSITIONS = {
   stopped: ["starting"]
 };
 function defaultStateFilePath() {
-  return path6.join(os4.homedir(), ".config", "onklave", "daemon.state.json");
+  return path6.join(os5.homedir(), ".config", "onklave", "daemon.state.json");
 }
 function defaultPidFilePath() {
-  return path6.join(os4.homedir(), ".config", "onklave", "daemon.pid");
+  return path6.join(os5.homedir(), ".config", "onklave", "daemon.pid");
 }
 var DaemonStateError = class extends Error {
   constructor(message) {
@@ -2968,6 +3589,7 @@ var DaemonStateService = class {
     this.stateFile = stateFile;
     this.machineId = machineId;
     this.listeners = [];
+    this.latestRuntime = null;
     this.current = initial;
     this.enteredAt = /* @__PURE__ */ new Date();
   }
@@ -3036,12 +3658,22 @@ var DaemonStateService = class {
       enteredAt: this.enteredAt.toISOString(),
       pid: process.pid,
       ...this.machineId ? { machineId: this.machineId } : {},
-      ...reason ? { reason } : {}
+      ...reason ? { reason } : {},
+      ...this.latestRuntime ? { runtime: this.latestRuntime } : {}
     };
     const tmp = `${this.stateFile}.tmp`;
     fs5.writeFileSync(tmp, JSON.stringify(payload, null, 2));
     fs5.renameSync(tmp, this.stateFile);
   }
+  /**
+   * Publish the latest runtime snapshot. Persists to the state file
+   * so `daemon status` from another process can read it. Idempotent —
+   * no transition is fired.
+   */
+  publishRuntime(snapshot) {
+    this.latestRuntime = snapshot;
+    this.persist();
+  }
   /**
    * Remove the persisted state file. Called on terminal `stopped` once
    * the daemon process is exiting cleanly so `daemon status` reports
@@ -3179,10 +3811,11 @@ async function daemonCommand(args) {
   const [sub] = args;
   if (sub === "status") return daemonStatus();
   if (sub === "stop" || sub === "drain") return daemonStop();
+  if (sub === "update") return daemonUpdate();
   if (sub && !sub.startsWith("--")) {
     console.error(`Unknown subcommand: ${sub}`);
     console.error(
-      "Usage: onklave daemon [status|stop|drain] | --emit-systemd-unit | --emit-launchd-plist | --emit-nssm-script"
+      "Usage: onklave daemon [status|stop|drain|update] | --emit-systemd-unit | --emit-launchd-plist | --emit-nssm-script"
     );
     process.exitCode = 1;
     return;
@@ -3231,25 +3864,76 @@ async function daemonStart() {
     };
     auditStreamer.record(event);
   });
-  let activeSessions = 0;
+  const spawner = new DaemonSpawner({ platformUrl });
+  const platformClient = new PlatformClient(platformUrl, creds.token);
+  const resourceSampler = new DaemonResourceSampler();
+  const claimHandler = new DaemonClaimHandler({
+    machineId: creds.machineId,
+    audit: auditStreamer,
+    spawnRunner: (req) => spawner.runSpawnRequest(req),
+    platformClient,
+    deviceToken: creds.deviceToken,
+    resourceSampler,
+    maxCpuPercent: 80
+    // spec §8.1 default
+  });
+  const tokenObserver = new DaemonTokenObserver({
+    machineId: creds.machineId,
+    audit: auditStreamer,
+    deviceTokenExpiresAt: creds.deviceTokenExpiresAt
+  });
+  const updateChecker = new DaemonUpdateChecker({
+    currentVersion: readPackageVersion() ?? "0.0.0",
+    audit: auditStreamer
+  });
+  let currentDeviceToken = creds.deviceToken;
+  const tokenRefresher = new DaemonTokenRefresher({
+    machineId: creds.machineId,
+    observer: tokenObserver,
+    platformClient,
+    authService,
+    getDeviceToken: () => currentDeviceToken,
+    onTokenRefreshed: (newToken) => {
+      currentDeviceToken = newToken;
+    }
+  });
+  const initialTokenStatus = tokenObserver.emitIfNeeded();
+  if (initialTokenStatus.state === "expired") {
+    console.error(
+      `Device token expired (${initialTokenStatus.expiresAt}). Re-register: onklave register --token <bootstrap>`
+    );
+    removePid(pidFile);
+    stateService.clearPersisted();
+    process.exit(1);
+  }
+  if (initialTokenStatus.state === "warning") {
+    console.warn(
+      `\u26A0 Device token expires in ${initialTokenStatus.daysRemaining} days (${initialTokenStatus.expiresAt}).`
+    );
+  }
   let shuttingDown = false;
   let sigintCount = 0;
   let sigintTimer = null;
+  let runtimePublisher = null;
+  let updateCheckTimer = null;
   const heartbeat = new HeartbeatService({
     platformUrl,
     deviceToken: creds.deviceToken,
     machineId: creds.machineId,
-    getActiveSessionCount: () => activeSessions
+    getActiveSessionCount: () => claimHandler.getActiveSessionCount()
   });
   const drainAndExit = async (reason) => {
     if (shuttingDown) return;
     shuttingDown = true;
     heartbeat.stop();
+    resourceSampler.stop();
+    if (runtimePublisher) clearInterval(runtimePublisher);
+    if (updateCheckTimer) clearInterval(updateCheckTimer);
     try {
       if (stateService.getCurrent() === "online") {
         await stateService.transition("draining", { reason });
       }
-      while (activeSessions > 0) {
+      while (claimHandler.getActiveSessionCount() > 0) {
         await new Promise((r) => setTimeout(r, 200));
       }
       await stateService.transition("stopping", { reason });
@@ -3298,8 +3982,41 @@ async function daemonStart() {
     process.exit(1);
   }
   console.log("Connected.");
+  claimHandler.attachToSocket(comms.inner());
   await stateService.transition("online");
   heartbeat.start();
+  resourceSampler.start();
+  const publishSnapshot = () => {
+    void tokenRefresher.maybeRefresh();
+    const tokenStatus = tokenObserver.emitIfNeeded();
+    const disconnectedMs = comms.disconnectedForMs();
+    const resourceSnap = resourceSampler.snapshot();
+    stateService.publishRuntime({
+      snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+      activeSessions: claimHandler.getActiveSessionCount(),
+      maxConcurrentSessions: claimHandler.getMaxConcurrentSessions(),
+      socketConnected: comms.isConnected(),
+      ...disconnectedMs != null ? { socketDisconnectedForMs: disconnectedMs } : {},
+      ...resourceSnap.sampleCount > 0 ? {
+        cpuPercent: resourceSnap.cpuPercent,
+        memoryRssBytes: resourceSnap.memoryRssBytes
+      } : {},
+      updateInfo: updateChecker.info(),
+      tokenStatus: tokenStatus.state === "unknown" ? { state: "unknown" } : tokenStatus.state === "expired" ? { state: "expired", expiresAt: tokenStatus.expiresAt } : {
+        state: tokenStatus.state,
+        daysRemaining: tokenStatus.daysRemaining,
+        expiresAt: tokenStatus.expiresAt
+      }
+    });
+  };
+  publishSnapshot();
+  runtimePublisher = setInterval(publishSnapshot, 3e4);
+  runtimePublisher.unref?.();
+  void updateChecker.check();
+  updateCheckTimer = setInterval(() => {
+    void updateChecker.check();
+  }, 60 * 60 * 1e3);
+  updateCheckTimer.unref?.();
   console.log(
     `Daemon online. machineId=${creds.machineId} pid=${process.pid}. Press Ctrl-C to drain.`
   );
@@ -3324,6 +4041,64 @@ async function daemonStatus() {
   if (persisted.pid) console.log(`PID:            ${persisted.pid}`);
   console.log(`Entered state:  ${persisted.enteredAt}`);
   if (persisted.reason) console.log(`Reason:         ${persisted.reason}`);
+  if (persisted.runtime) {
+    const rt = persisted.runtime;
+    console.log(
+      `Active sessions: ${rt.activeSessions} / ${rt.maxConcurrentSessions}`
+    );
+    const socketStatus = rt.socketConnected ? "connected" : rt.socketDisconnectedForMs != null ? `disconnected ${Math.round(rt.socketDisconnectedForMs / 1e3)}s` : "disconnected";
+    console.log(`Comms socket:   ${socketStatus}`);
+    if (rt.cpuPercent != null) {
+      console.log(`CPU (60s avg):  ${rt.cpuPercent.toFixed(1)}%`);
+    }
+    if (rt.memoryRssBytes != null) {
+      const mb = rt.memoryRssBytes / (1024 * 1024);
+      console.log(`Memory (RSS):   ${mb.toFixed(1)} MB`);
+    }
+    if (rt.updateInfo) {
+      const u = rt.updateInfo;
+      const versionLine = u.updateAvailable ? `${u.currentVersion} \u2192 ${u.latestVersion} available (run: onklave daemon update)` : `${u.currentVersion}${u.latestVersion ? " (latest)" : ""}`;
+      console.log(`Daemon version: ${versionLine}`);
+    }
+    if (rt.tokenStatus) {
+      if (rt.tokenStatus.state === "expired") {
+        console.log(`Device token:   EXPIRED (${rt.tokenStatus.expiresAt})`);
+      } else if (rt.tokenStatus.state === "warning") {
+        console.log(
+          `Device token:   \u26A0 ${rt.tokenStatus.daysRemaining} days remaining (${rt.tokenStatus.expiresAt})`
+        );
+      } else if (rt.tokenStatus.state === "ok") {
+        console.log(
+          `Device token:   ${rt.tokenStatus.daysRemaining} days remaining`
+        );
+      } else {
+        console.log("Device token:   expiry unknown \u2014 re-register to refresh");
+      }
+    }
+    console.log(`Snapshot age:   ${snapshotAge(rt.snapshotAt)}`);
+  }
+}
+function snapshotAge(iso) {
+  const ms = Date.now() - new Date(iso).getTime();
+  if (ms < 0) return "just now";
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s ago`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m ago`;
+  return `${Math.round(ms / 36e5)}h ago`;
+}
+async function daemonUpdate() {
+  console.log("To update the Onklave agent CLI, run as the install owner:");
+  console.log("");
+  console.log("    npm install -g @onklave/agent-cli@latest");
+  console.log("");
+  console.log(
+    "Then restart the supervisor: `systemctl restart onklave-daemon` (Linux),"
+  );
+  console.log("`launchctl kickstart -k system/app.onklave.daemon` (macOS), or");
+  console.log("`nssm restart OnklaveDaemon` (Windows).");
+  console.log("");
+  console.log(
+    "Self-replace via npm provenance verification (spec \xA76.3) is deferred \u2014 see V6-CLI-002 Phase 7 in the kanban."
+  );
 }
 async function daemonStop() {
   const pidFile = defaultPidFilePath();
@@ -3380,6 +4155,25 @@ function isPidAlive(pidFile) {
   if (pid == null) return false;
   return isProcessAlive(pid);
 }
+function readPackageVersion() {
+  try {
+    const candidates = [
+      // dist layout (bin/onklave.js → ../package.json)
+      `${__dirname}/../../package.json`,
+      // src layout during dev
+      `${__dirname}/../../../package.json`
+    ];
+    for (const p of candidates) {
+      if (fs6.existsSync(p)) {
+        const pkg = JSON.parse(fs6.readFileSync(p, "utf8"));
+        if (pkg.name === "@onklave/agent-cli" && pkg.version)
+          return pkg.version;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onklave/agent-cli",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Onklave Agent CLI — local agent runner with cloud orchestration",
   "bin": {
     "onklave": "./main.js"