@agentpulselabs/cli-plugin-pulse 1.1.2 → 1.1.5

package/src/lib/daemonRuntime.js

@@ -152,6 +152,7 @@ export class DaemonRuntime {
           attemptNo: attempt.attemptNo,
           fenceToken: attempt.fenceToken,
           events,
+          itemRefusals: true,
         });
       } catch (error) {
         if (machineWideError(error)) throw error;
@@ -164,15 +165,32 @@ export class DaemonRuntime {
         this.log('events_discarded', { ...trace, discarded });
         continue;
       }
-      if (Array.isArray(response.events)) {
-        await this.ledger.acknowledgeEvents(
-          response.events.map((event) => ({
-            sourceEventId: event.sourceEventId,
-            cloudCursor: event.cloudCursor,
-          }))
-        );
+      await this.#settleUpload(attempt, events, response);
+    }
+  }
+
+  /**
+   * Apply the cloud's answer to one uploaded batch. A stored event comes back with its `cursor` (`cloudCursor` is read
+   * when that is the only one) and leaves the outbox. A refused one ({ refused }) is dropped on its own, so the rest of
+   * the batch is kept. An event the answer leaves out stays pending and is sent again.
+   */
+  async #settleUpload(attempt, events, response) {
+    if (!Array.isArray(response?.events)) return;
+    const sent = new Set(events.map((event) => event.sourceEventId));
+    const accepted = [];
+    const refused = new Map();
+    for (const item of response.events) {
+      if (!sent.has(item?.sourceEventId)) continue;
+      if (item.refused) refused.set(item.sourceEventId, item.refused.code || 'HUB_EVENT_REFUSED');
+      else if (Number.isSafeInteger(item.cursor ?? item.cloudCursor)) {
+        accepted.push({ sourceEventId: item.sourceEventId, cursor: item.cursor ?? item.cloudCursor });
       }
     }
+    if (accepted.length) await this.ledger.acknowledgeEvents(accepted);
+    if (!refused.size) return;
+    const codes = [...new Set(refused.values())].sort().join(',');
+    const { discarded } = await this.ledger.discardEvents(attempt.jobId, codes, { sourceEventIds: [...refused.keys()] });
+    this.log('events_refused', { jobId: attempt.jobId, type: attempt.jobType, attemptNo: attempt.attemptNo, code: codes, discarded });
   }
 
   #compose(grant) {

package/src/lib/hubDbReader.js

@@ -129,4 +129,10 @@ export class HubSnapshot {
     const statement = this.db.prepare('SELECT kind, key, payload, updated_at FROM facts WHERE kind = ? ORDER BY key');
     return kinds.flatMap((kind) => statement.all(kind).map(plain));
   }
+
+  /** The `{ kind, key }` of the same facts in the same order, without their payloads. */
+  factKeys(kinds) {
+    const statement = this.db.prepare('SELECT kind, key FROM facts WHERE kind = ? ORDER BY key');
+    return kinds.flatMap((kind) => statement.all(kind).map(plain));
+  }
 }

package/src/lib/hubScan.js

@@ -17,6 +17,7 @@ export const SKIPPED_FACT_KINDS = Object.freeze({
   run: 'machine_runtime_state',
   wake: 'machine_runtime_state',
   manager: 'machine_runtime_state',
+  'manager-restart': 'machine_runtime_state',
   totals: 'phase1_deviation_totals',
 });
 export const REMOVABLE_KINDS = Object.freeze(['delivery', 'stream', 'agent-row', 'request', 'status_override']);

package/src/lib/ledger.js

@@ -226,6 +226,7 @@ export class DurableLedger {
     return clone(this.data.outbox.slice(0, Math.max(0, Math.min(100, limit))));
   }
 
+  /** Events the cloud stored, as { sourceEventId, cursor } with the cloud cursor it gave each, the wire's names. */
   async acknowledgeEvents(acknowledgements) {
     return this.#mutate((state) => {
       if (!Array.isArray(acknowledgements) || acknowledgements.length > 100) {
@@ -237,15 +238,15 @@ export class DurableLedger {
         if (
           !pendingIds.has(item.sourceEventId) ||
           seen.has(item.sourceEventId) ||
-          !Number.isSafeInteger(item.cloudCursor) ||
-          item.cloudCursor < 1
+          !Number.isSafeInteger(item.cursor) ||
+          item.cursor < 1
         ) {
           throw new HubError('HUB_EVENT_ACK_INVALID', 'Event acknowledgement does not match the sent batch');
         }
         seen.add(item.sourceEventId);
       }
       const accepted = new Map(
-        acknowledgements.map((item) => [item.sourceEventId, Number(item.cloudCursor)])
+        acknowledgements.map((item) => [item.sourceEventId, Number(item.cursor)])
       );
       for (const event of state.outbox) {
         if (!accepted.has(event.sourceEventId) || !TERMINAL_STATES.has(event.terminalState)) continue;
@@ -465,19 +466,27 @@ export class DurableLedger {
   }
 
   /**
-   * Drop a job's pending events the cloud refused for good (its fence is gone or the batch is invalid). They never
-   * count toward acceptedLocalCursor, and a terminal attempt has nothing left to upload.
+   * Drop a job's pending events the cloud refused for good: all of them (its fence is gone or the batch is invalid),
+   * or only sourceEventIds (the cloud refused those items and stored the rest). They never count toward
+   * acceptedLocalCursor. A terminal attempt has nothing left to upload once its terminal event is gone.
    */
-  async discardEvents(jobId, code) {
+  async discardEvents(jobId, code, { sourceEventIds = null } = {}) {
+    const only = sourceEventIds ? new Set(sourceEventIds) : null;
     return this.#mutate((state) => {
-      const discarded = state.outbox.filter((event) => event.jobId === jobId).length;
-      state.outbox = state.outbox.filter((event) => event.jobId !== jobId);
+      const dropped = (event) => event.jobId === jobId && (!only || only.has(event.sourceEventId));
+      const gone = state.outbox.filter(dropped);
+      state.outbox = state.outbox.filter((event) => !dropped(event));
       const attempt = state.attempts[jobId];
-      if (attempt && discarded) {
-        attempt.eventsDiscarded = { count: discarded, code, at: new Date().toISOString() };
-        if (TERMINAL_STATES.has(attempt.state)) attempt.terminalUploaded = true;
+      if (attempt && gone.length) {
+        attempt.eventsDiscarded = {
+          count: (only ? attempt.eventsDiscarded?.count || 0 : 0) + gone.length,
+          code,
+          at: new Date().toISOString(),
+        };
+        const terminalGone = !only || gone.some((event) => event.terminalState === attempt.state);
+        if (TERMINAL_STATES.has(attempt.state) && terminalGone) attempt.terminalUploaded = true;
       }
-      return { discarded };
+      return { discarded: gone.length };
     });
   }
 

package/src/lib/lifecycle.js

@@ -3,10 +3,12 @@ import { HubError } from './errors.js';
 import { validateJobResult } from './intents.js';
 import { redactText } from './redaction.js';
 
+// Hex, so the id always starts with a letter or digit: Pulse clouds before 1.1.3 refuse a sourceEventId starting with
+// '-' or '_', which a base64url digest does about 3% of the time.
 function eventId(tuple, type) {
   return createHash('sha256')
     .update(`${tuple.jobId}\0${tuple.attemptNo}\0${tuple.fenceToken}\0${type}`)
-    .digest('base64url');
+    .digest('hex');
 }
 
 export class AttemptCoordinator {

package/src/lib/runnerStore.js

@@ -91,6 +91,8 @@ export class RunnerStore {
     }
   }
 
+  #statements = new Map();
+
   constructor({ db, file, now, maxPending }) {
     this.db = db;
     this.file = file;
@@ -103,20 +105,30 @@ export class RunnerStore {
     this.db.close();
   }
 
+  /** The statement for this SQL, prepared once per connection: the scanners call the store once or more per row. */
+  sql(text) {
+    let statement = this.#statements.get(text);
+    if (!statement) {
+      statement = this.db.prepare(text);
+      this.#statements.set(text, statement);
+    }
+    return statement;
+  }
+
   /**
    * Run `fn` in one immediate transaction: everything it enqueues and every cursor it moves commit together. Inside a
    * transaction already open on this connection (the runner's capture) it joins that one.
    */
   transaction(fn) {
     if (this.depth > 0 || this.db.isTransaction) return fn();
-    this.db.prepare('BEGIN IMMEDIATE').run();
+    this.sql('BEGIN IMMEDIATE').run();
     this.depth += 1;
     try {
       const out = fn();
-      this.db.prepare('COMMIT').run();
+      this.sql('COMMIT').run();
       return out;
     } catch (error) {
-      this.db.prepare('ROLLBACK').run();
+      this.sql('ROLLBACK').run();
       throw error;
     } finally {
       this.depth -= 1;
@@ -124,34 +136,34 @@ export class RunnerStore {
   }
 
   meta(key) {
-    const row = this.db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+    const row = this.sql('SELECT value FROM meta WHERE key = ?').get(key);
     return row ? JSON.parse(row.value) : null;
   }
 
   setMeta(key, value) {
-    this.db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value')
+    this.sql('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value')
       .run(key, JSON.stringify(value));
   }
 
   cursor(source) {
-    const row = this.db.prepare('SELECT position FROM cursor WHERE source = ?').get(source);
+    const row = this.sql('SELECT position FROM cursor WHERE source = ?').get(source);
     return row ? JSON.parse(row.position) : null;
   }
 
   setCursor(source, position) {
-    this.db.prepare('INSERT INTO cursor (source, position) VALUES (?, ?) ON CONFLICT (source) DO UPDATE SET position = excluded.position')
+    this.sql('INSERT INTO cursor (source, position) VALUES (?, ?) ON CONFLICT (source) DO UPDATE SET position = excluded.position')
       .run(source, JSON.stringify(position));
   }
 
   /** Whether a key was ever enqueued: pending, acknowledged or dead. */
   known(key) {
-    return Boolean(this.db.prepare(
+    return Boolean(this.sql(
       'SELECT 1 AS found FROM outbox WHERE key = ? UNION ALL SELECT 1 FROM sent WHERE key = ? UNION ALL SELECT 1 FROM dead WHERE key = ? LIMIT 1',
     ).get(key, key, key));
   }
 
   pendingCount() {
-    return Number(this.db.prepare('SELECT COUNT(*) AS n FROM outbox').get().n);
+    return Number(this.sql('SELECT COUNT(*) AS n FROM outbox').get().n);
   }
 
   /**
@@ -160,7 +172,7 @@ export class RunnerStore {
    */
   enqueue(entries) {
     return this.transaction(() => {
-      const insert = this.db.prepare(
+      const insert = this.sql(
         `INSERT INTO outbox (key, grp, type, payload, source, enqueued_at)
          SELECT ?, ?, ?, ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM sent WHERE key = ?) AND NOT EXISTS (SELECT 1 FROM dead WHERE key = ?)
          ON CONFLICT (key) DO NOTHING`,
@@ -214,40 +226,40 @@ export class RunnerStore {
   /** The cloud stored (or already had) this key. */
   acked(key, { seq = null, duplicate = false } = {}) {
     this.transaction(() => {
-      const row = this.db.prepare('SELECT source, type FROM outbox WHERE key = ?').get(key);
+      const row = this.sql('SELECT source, type FROM outbox WHERE key = ?').get(key);
       if (!row) return;
-      this.db.prepare('INSERT INTO sent (key, source, type, seq, duplicate, at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (key) DO NOTHING')
+      this.sql('INSERT INTO sent (key, source, type, seq, duplicate, at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (key) DO NOTHING')
         .run(key, row.source, row.type, seq === null ? null : String(seq), duplicate ? 1 : 0, this.now());
-      this.db.prepare('DELETE FROM outbox WHERE key = ?').run(key);
+      this.sql('DELETE FROM outbox WHERE key = ?').run(key);
     });
   }
 
   /** A retryable refusal: the row stays first in its group and is due again after `delayMs`. */
   retry(key, { code, delayMs }) {
-    this.db.prepare('UPDATE outbox SET attempts = attempts + 1, next_at = ?, last_error = ? WHERE key = ?').run(this.now() + delayMs, code, key);
+    this.sql('UPDATE outbox SET attempts = attempts + 1, next_at = ?, last_error = ? WHERE key = ?').run(this.now() + delayMs, code, key);
   }
 
   /** Held behind an earlier command of its group: due again after `delayMs`, without counting an attempt. */
   hold(key, { code, delayMs }) {
-    this.db.prepare('UPDATE outbox SET next_at = ?, last_error = ? WHERE key = ?').run(this.now() + delayMs, code, key);
+    this.sql('UPDATE outbox SET next_at = ?, last_error = ? WHERE key = ?').run(this.now() + delayMs, code, key);
   }
 
   /** A refusal that repeating cannot fix: the row leaves the outbox with its reason. */
   dead(key, { code, message = null }) {
     this.transaction(() => {
-      const row = this.db.prepare('SELECT grp, type, payload, source FROM outbox WHERE key = ?').get(key);
+      const row = this.sql('SELECT grp, type, payload, source FROM outbox WHERE key = ?').get(key);
       if (!row) return;
-      this.db.prepare(
+      this.sql(
         `INSERT INTO dead (key, grp, type, payload, source, code, message, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT (key) DO UPDATE SET code = excluded.code, message = excluded.message, at = excluded.at`,
       ).run(key, row.grp, row.type, row.payload, row.source, code, message, this.now());
-      this.db.prepare('DELETE FROM outbox WHERE key = ?').run(key);
+      this.sql('DELETE FROM outbox WHERE key = ?').run(key);
     });
   }
 
   /** A command refused before it was queued (it never reaches the cloud), recorded with its reason. */
   refuse(entry, { code, message = null }) {
-    this.db.prepare(
+    this.sql(
       `INSERT INTO dead (key, grp, type, payload, source, code, message, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT (key) DO NOTHING`,
     ).run(entry.key, entry.group, entry.type, JSON.stringify(entry.payload ?? null), entry.source, code, message, this.now());
@@ -255,38 +267,38 @@ export class RunnerStore {
 
   /** The code a key was refused or dead-lettered with, or null. */
   deadCode(key) {
-    return this.db.prepare('SELECT code FROM dead WHERE key = ?').get(key)?.code ?? null;
+    return this.sql('SELECT code FROM dead WHERE key = ?').get(key)?.code ?? null;
   }
 
   /** Every queued command in queue order, payload parsed (a reconcile reads a scratch store's whole scan this way). */
   planned() {
-    return this.db.prepare('SELECT key, grp, type, payload, source FROM outbox ORDER BY ord').all()
+    return this.sql('SELECT key, grp, type, payload, source FROM outbox ORDER BY ord').all()
       .map((row) => ({ key: row.key, group: row.grp, type: row.type, payload: JSON.parse(row.payload), source: row.source }));
   }
 
   /** Every set-aside key with its code (all of them; deadRows is the newest few). */
   deadKeys() {
-    return this.db.prepare('SELECT key, type, source, code FROM dead ORDER BY key').all().map((row) => ({ ...row }));
+    return this.sql('SELECT key, type, source, code FROM dead ORDER BY key').all().map((row) => ({ ...row }));
   }
 
   deadRows({ limit = 20 } = {}) {
-    return this.db.prepare('SELECT key, type, source, code, message, at FROM dead ORDER BY at DESC LIMIT ?').all(limit).map((row) => ({ ...row }));
+    return this.sql('SELECT key, type, source, code, message, at FROM dead ORDER BY at DESC LIMIT ?').all(limit).map((row) => ({ ...row }));
   }
 
   /** Counts per source: pending, sent (written or duplicate) and dead (by code). */
   counts() {
     const out = {};
     const at = (source) => (out[source] ||= { pending: 0, written: 0, duplicate: 0, dead: {} });
-    for (const row of this.db.prepare('SELECT source, COUNT(*) AS n FROM outbox GROUP BY source').all()) at(row.source).pending = Number(row.n);
-    for (const row of this.db.prepare('SELECT source, duplicate, COUNT(*) AS n FROM sent GROUP BY source, duplicate').all()) {
+    for (const row of this.sql('SELECT source, COUNT(*) AS n FROM outbox GROUP BY source').all()) at(row.source).pending = Number(row.n);
+    for (const row of this.sql('SELECT source, duplicate, COUNT(*) AS n FROM sent GROUP BY source, duplicate').all()) {
       at(row.source)[row.duplicate ? 'duplicate' : 'written'] = Number(row.n);
     }
-    for (const row of this.db.prepare('SELECT source, code, COUNT(*) AS n FROM dead GROUP BY source, code').all()) at(row.source).dead[row.code] = Number(row.n);
+    for (const row of this.sql('SELECT source, code, COUNT(*) AS n FROM dead GROUP BY source, code').all()) at(row.source).dead[row.code] = Number(row.n);
     return out;
   }
 
   version(entity) {
-    const row = this.db.prepare('SELECT sha, raw_sha, static_sha, key, at FROM version WHERE entity = ?').get(entity);
+    const row = this.sql('SELECT sha, raw_sha, static_sha, key, at FROM version WHERE entity = ?').get(entity);
     return row ? { sha: row.sha, rawSha: row.raw_sha, staticSha: row.static_sha, key: row.key, at: Number(row.at) } : null;
   }
 
@@ -295,7 +307,7 @@ export class RunnerStore {
    * `<prefix><sep><sha>.<k>` when it returns after another version (A→B→A), so the return is a new event that applies.
    */
   versionKey(entity, prefix, sha, separator = ':') {
-    const seen = this.db.prepare('SELECT count FROM version_seen WHERE entity = ? AND sha = ?').get(entity, sha);
+    const seen = this.sql('SELECT count FROM version_seen WHERE entity = ? AND sha = ?').get(entity, sha);
     const count = seen ? Number(seen.count) : 0;
     return count === 0 ? `${prefix}${separator}${sha}` : `${prefix}${separator}${sha}.${count}`;
   }
@@ -304,12 +316,12 @@ export class RunnerStore {
   setVersion(entity, { sha, rawSha = null, staticSha = null, key }) {
     const last = this.version(entity);
     if (last?.sha !== sha) {
-      this.db.prepare(
+      this.sql(
         `INSERT INTO version_seen (entity, sha, count) VALUES (?, ?, 1)
          ON CONFLICT (entity, sha) DO UPDATE SET count = count + 1`,
       ).run(entity, sha);
     }
-    this.db.prepare(
+    this.sql(
       `INSERT INTO version (entity, sha, raw_sha, static_sha, key, at) VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT (entity) DO UPDATE SET sha = excluded.sha, raw_sha = excluded.raw_sha, static_sha = excluded.static_sha,
          key = excluded.key, at = excluded.at`,
@@ -318,67 +330,67 @@ export class RunnerStore {
 
   /** The raw form last read, without changing what was sent (an unchanged row skips redaction next time). */
   touchVersion(entity, rawSha) {
-    this.db.prepare('UPDATE version SET raw_sha = ? WHERE entity = ?').run(rawSha, entity);
+    this.sql('UPDATE version SET raw_sha = ? WHERE entity = ?').run(rawSha, entity);
   }
 
   dropVersion(entity) {
-    this.db.prepare('DELETE FROM version WHERE entity = ?').run(entity);
+    this.sql('DELETE FROM version WHERE entity = ?').run(entity);
   }
 
   entities(prefix) {
-    return this.db.prepare("SELECT entity FROM version WHERE entity >= ? AND entity < ? || char(1114111)").all(prefix, prefix).map((row) => row.entity);
+    return this.sql("SELECT entity FROM version WHERE entity >= ? AND entity < ? || char(1114111)").all(prefix, prefix).map((row) => row.entity);
   }
 
   /** The receipt state last queued for each recipient row still able to change (not acked or expired). */
   openReceipts() {
-    return this.db.prepare("SELECT message_id, recipient, state FROM receipt_state WHERE state NOT IN ('acked', 'expired')").all()
+    return this.sql("SELECT message_id, recipient, state FROM receipt_state WHERE state NOT IN ('acked', 'expired')").all()
       .map((row) => ({ messageId: row.message_id, recipient: row.recipient, state: row.state }));
   }
 
   receiptState(messageId, recipient) {
-    return this.db.prepare('SELECT state FROM receipt_state WHERE message_id = ? AND recipient = ?').get(messageId, recipient)?.state ?? null;
+    return this.sql('SELECT state FROM receipt_state WHERE message_id = ? AND recipient = ?').get(messageId, recipient)?.state ?? null;
   }
 
   setReceiptState(messageId, recipient, state) {
-    this.db.prepare(
+    this.sql(
       `INSERT INTO receipt_state (message_id, recipient, state) VALUES (?, ?, ?)
        ON CONFLICT (message_id, recipient) DO UPDATE SET state = excluded.state`,
     ).run(messageId, recipient, state);
   }
 
   dropReceipts(messageId) {
-    this.db.prepare('DELETE FROM receipt_state WHERE message_id = ?').run(messageId);
+    this.sql('DELETE FROM receipt_state WHERE message_id = ?').run(messageId);
   }
 
   rememberMessage(id, createdAt, group) {
-    this.db.prepare('INSERT INTO recent_message (id, created_at, grp) VALUES (?, ?, ?) ON CONFLICT (id) DO NOTHING').run(id, createdAt, group);
+    this.sql('INSERT INTO recent_message (id, created_at, grp) VALUES (?, ?, ?) ON CONFLICT (id) DO NOTHING').run(id, createdAt, group);
   }
 
   recentMessages(sinceMs) {
-    return this.db.prepare('SELECT id, created_at, grp FROM recent_message WHERE created_at >= ? ORDER BY created_at').all(sinceMs)
+    return this.sql('SELECT id, created_at, grp FROM recent_message WHERE created_at >= ? ORDER BY created_at').all(sinceMs)
       .map((row) => ({ id: row.id, createdAt: Number(row.created_at), group: row.grp }));
   }
 
   forgetMessage(id) {
-    this.db.prepare('DELETE FROM recent_message WHERE id = ?').run(id);
+    this.sql('DELETE FROM recent_message WHERE id = ?').run(id);
   }
 
   pruneRecentMessages(beforeMs) {
-    this.db.prepare('DELETE FROM recent_message WHERE created_at < ?').run(beforeMs);
+    this.sql('DELETE FROM recent_message WHERE created_at < ?').run(beforeMs);
   }
 
   ingested(channel) {
-    return this.db.prepare('SELECT ordinal, sha, post_key, at FROM ingested WHERE channel = ? ORDER BY ordinal').all(channel)
+    return this.sql('SELECT ordinal, sha, post_key, at FROM ingested WHERE channel = ? ORDER BY ordinal').all(channel)
       .map((row) => ({ ordinal: Number(row.ordinal), sha: row.sha, postKey: row.post_key, at: Number(row.at) }));
   }
 
   /** The key a channel's block (its digest and occurrence) was first sent under, or null. */
   ingestedKey(channel, sha) {
-    return this.db.prepare('SELECT post_key FROM ingested WHERE channel = ? AND sha = ?').get(channel, sha)?.post_key ?? null;
+    return this.sql('SELECT post_key FROM ingested WHERE channel = ? AND sha = ?').get(channel, sha)?.post_key ?? null;
   }
 
   setIngested(channel, { ordinal, sha, postKey, at }) {
-    this.db.prepare(
+    this.sql(
       `INSERT INTO ingested (channel, ordinal, sha, post_key, at) VALUES (?, ?, ?, ?, ?)
        ON CONFLICT (channel, ordinal) DO UPDATE SET sha = excluded.sha, post_key = excluded.post_key, at = excluded.at`,
     ).run(channel, ordinal, sha, postKey, at);
@@ -387,18 +399,18 @@ export class RunnerStore {
   /** What one channel file holds now, by position, replacing what was recorded before. */
   replaceIngested(channel, rows) {
     this.transaction(() => {
-      this.db.prepare('DELETE FROM ingested WHERE channel = ?').run(channel);
+      this.sql('DELETE FROM ingested WHERE channel = ?').run(channel);
       for (const row of rows) this.setIngested(channel, row);
     });
   }
 
   presenceSent(actorId) {
-    const row = this.db.prepare('SELECT last_seen, sent_at FROM presence_sent WHERE actor_id = ?').get(actorId);
+    const row = this.sql('SELECT last_seen, sent_at FROM presence_sent WHERE actor_id = ?').get(actorId);
     return row ? { lastSeen: Number(row.last_seen), sentAt: Number(row.sent_at) } : null;
   }
 
   setPresenceSent(actorId, lastSeen) {
-    this.db.prepare(
+    this.sql(
       `INSERT INTO presence_sent (actor_id, last_seen, sent_at) VALUES (?, ?, ?)
        ON CONFLICT (actor_id) DO UPDATE SET last_seen = excluded.last_seen, sent_at = excluded.sent_at`,
     ).run(actorId, lastSeen, this.now());
@@ -406,12 +418,12 @@ export class RunnerStore {
 
   /** Whether the cloud acknowledged `key` as a command of `type`. */
   sentAs(key, type) {
-    return Boolean(this.db.prepare('SELECT 1 AS found FROM sent WHERE key = ? AND type = ?').get(key, type));
+    return Boolean(this.sql('SELECT 1 AS found FROM sent WHERE key = ? AND type = ?').get(key, type));
   }
 
   /** Acknowledged keys older than `beforeMs` go; the cloud's dedupe is the backstop for anything resent after that. */
   pruneSent(beforeMs) {
-    return Number(this.db.prepare('DELETE FROM sent WHERE at < ?').run(beforeMs).changes);
+    return Number(this.sql('DELETE FROM sent WHERE at < ?').run(beforeMs).changes);
   }
 }
 

package/src/lib/serviceManager.js

@@ -10,7 +10,9 @@ import {
 } from './storage.js';
 import { execFileBounded as execFile } from './subprocess.js';
 
-const LABEL = 'com.agentpulse.hub';
+/** The Pulse daemon's own service label; the cutover that runs inside it must never retire it. */
+export const SERVICE_LABEL = 'com.agentpulse.hub';
+const LABEL = SERVICE_LABEL;
 const SYSTEMD_UNIT = 'agentpulse-hub.service';
 const START_ATTEMPTS = 6;
 const START_RETRY_MS = 250;

package/src/runner/bridge.js

@@ -24,6 +24,8 @@ const PRESENCE_CURSOR = 'presence_cursor';
 export const SYNC_FAILING_AFTER = 3;
 /** SCOPE-02: while blocked for a scope or grant, the sync is retried this often with the sign-in read again, so a re-login clears it. */
 export const BLOCK_RETRY_MS = 60_000;
+/** Changes capture refused to send because they hold secret-like content (hubScan): set aside by design, not a fault. */
+const WITHHELD_CODE = 'content_withheld';
 const ERROR_CODES = new Set(['HUB_LOGIN_REQUIRED', 'HUB_SCOPE_DENIED', 'capability_denied', 'cloud_first_off', 'HUB_MACHINE_REVOKED']);
 
 /**
@@ -63,6 +65,7 @@ export class RunnerBridge {
     if (this.running) return;
     this.running = true;
     this.runner.on('wrote', () => this.kick());
+    this.runner.on('loop_stall', (message) => this.log('loop_stall', message.details || {}));
     this.syncing = this.#syncLoop();
     this.flushing = this.#flushLoop();
     if (this.leaseConfig) this.leasing = this.#leaseLoop();
@@ -254,10 +257,12 @@ export class RunnerBridge {
     const now = this.now();
     const pending = this.store.pendingCount();
     const dead = Number(this.store.db.prepare('SELECT COUNT(*) AS n FROM dead').get().n);
+    const withheld = Number(this.store.db.prepare('SELECT COUNT(*) AS n FROM dead WHERE code = ?').get(WITHHELD_CODE).n);
+    const setAside = dead - withheld;
     const quarantined = Number(this.store.db.prepare('SELECT COUNT(*) AS n FROM pulse_quarantine').get()?.n || 0);
     const applied = this.applied();
     const lag = Math.max(0, this.state.head - applied);
-    const outbox = { pending, dead, capacity: OUTBOX_MAX_PENDING };
+    const outbox = { pending, dead, withheld, capacity: OUTBOX_MAX_PENDING };
     const base = { lastSyncAt: this.state.lastSyncAt, applied, head: this.state.head, lag, outbox, quarantined,
       staleSeconds: this.state.lastSyncAt ? (now - this.state.lastSyncAt) / 1000 : null };
     const { block } = this.state.error || {};
@@ -276,8 +281,8 @@ export class RunnerBridge {
       return { ...base, state: 'offline', reason: this.state.lastContactAt ? 'no contact with Pulse' : 'not connected yet' };
     }
     if (lag > LAG_EVENTS || (pending > 0 && this.state.flushError)) return { ...base, state: 'catching_up', reason: `${lag} events and ${pending} changes to go` };
-    if (dead || quarantined || pending > 0.8 * OUTBOX_MAX_PENDING) {
-      return { ...base, state: 'degraded', reason: `${dead} change${dead === 1 ? '' : 's'} and ${quarantined} event${quarantined === 1 ? '' : 's'} set aside` };
+    if (setAside || quarantined || pending > 0.8 * OUTBOX_MAX_PENDING) {
+      return { ...base, state: 'degraded', reason: `${setAside} change${setAside === 1 ? '' : 's'} and ${quarantined} event${quarantined === 1 ? '' : 's'} set aside` };
     }
     if (!this.state.lastSyncAt || now - this.state.lastSyncAt > ONLINE_MS) return { ...base, state: 'catching_up', reason: 'waiting for a sync' };
     return { ...base, state: 'online', reason: 'in sync' };