@agentpulselabs/cli-plugin-pulse 1.0.0 → 1.1.3

package/src/lib/daemonProcess.js

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import { CUTOVER_PROTOCOL, CutoverService } from './cutoverRequest.js';
+import { createCutover } from './cutoverWiring.js';
 import { createProductionDependencies } from './daemonComposition.js';
 import { DaemonLock } from './daemonLock.js';
 import { createHeartbeat, MIRROR_UPDATE_STEP, TERMINAL_STATES } from './daemonLoop.js';
@@ -17,6 +19,8 @@ import {
   Watchdog,
   watchSource,
 } from './selfRestart.js';
+import { ShadowService } from './shadowService.js';
+import { RunnerService } from '../runner/runnerService.js';
 import { readOwnerOnlyJson } from './storage.js';
 
 // The longest a healthy cycle goes between two steps: a transport retry backoff (capped at 60 s) or a held claim (35 s).
@@ -26,6 +30,8 @@ const CYCLE_INTERVAL_MS = 60_000;
 const MIRROR_INTERVAL_MS = 60_000;
 const STALL_FACTOR = 3;
 const MIRROR_LOOPS = ['mirror', 'mirror windows'];
+// The shadow feed's calls run on their own timer; they never count as progress of the job cycle.
+const SHADOW_PATHS = ['/commands', '/cloud-first', '/parity'];
 /** The failure code of a job a restart had to abort: a drain that ran out of time, or a stalled loop. */
 export const RESTART_ABORT_CODE = 'HUB_DAEMON_RESTARTING';
 const DEFAULT_TIMING = Object.freeze({
@@ -56,7 +62,8 @@ const inside = (child, parent) => {
  * - start_failed: it could not start while it was holding restarts back.
  * A code or request restart drains (no new claim; running jobs finish and settle) for up to drainMs; a stall aborts at
  * once. Every trigger goes through one check that runs each tickMs. While the daemon has restarted too often it holds
- * the restart (health says restart_loop) until the window clears. SIGTERM always wins and exits 0.
+ * the restart (health says restart_loop) until the window clears, and while it runs a cutover request (CUT-03) it holds
+ * it until the cutover ends, whose own deadlines bound it. SIGTERM always wins and exits 0.
  */
 export async function runDaemon({
   directory,
@@ -68,6 +75,10 @@ export async function runDaemon({
   signals = process,
   createDependencies = createProductionDependencies,
   createMirror = (options) => new MirrorController(options),
+  createShadow = (options) => new ShadowService(options),
+  createRunner = (options) => new RunnerService(options),
+  createCutoverService = (options) => new CutoverService(options),
+  cutoverFactory = createCutover,
   dependencyOptions = {},
   runtimeOptions = {},
   lockOptions = {},
@@ -79,7 +90,7 @@ export async function runDaemon({
   const lock = new DaemonLock({ directory, ...lockOptions });
   await lock.acquire();
   // The first cycle (token exchange, reconnect, claim) can outlast `pulse start`'s wait; say we are up before it.
-  await lock.heartbeat({ state: 'starting' });
+  await lock.heartbeat({ state: 'starting', cutoverProtocol: CUTOVER_PROTOCOL });
   let startingHealthAt = Date.now();
   const guard = new RestartGuard({ directory, now });
   await guard.recordStart();
@@ -91,6 +102,13 @@ export async function runDaemon({
   let failure = null;
   let heartbeat = null;
   let runtime = null;
+  let shadow = null;
+  let runnerService = null;
+  let cutoverService = null;
+  let cutoverDeferralLogged = false;
+  // Every read of config.json is numbered, so the runner never applies one older than it already has (CUT-03).
+  let configGeneration = 0;
+  let heartbeatGeneration = 0;
   let stopServices = async () => {};
   let timer = null;
   let watcher = null;
@@ -199,6 +217,14 @@ export async function runDaemon({
       const requestedAt = await consumeRestartRequest(directory);
       if (requestedAt !== null && requestedAt < bootedAt) log('restart_request_satisfied', { requestedAt: new Date(requestedAt).toISOString() });
       else if (requestedAt !== null) pending ??= { reason: 'request' };
+      if (pending && cutoverService?.busy()) {
+        if (!cutoverDeferralLogged) {
+          cutoverDeferralLogged = true;
+          log('restart_deferred', { reason: pending.reason, cutover: cutoverService.health()?.requestId ?? null });
+        }
+        return;
+      }
+      cutoverDeferralLogged = false;
       if (pending) restart(pending.reason);
     } catch (error) {
       log('restart_check_failed', { code: error.code || 'HUB_RESTART_CHECK_FAILED' });
@@ -209,9 +235,15 @@ export async function runDaemon({
 
   const extraHealth = () => {
     const loop = degraded();
+    const cutover = cutoverService?.health();
     return {
       ...(loop ? { degraded: loop } : {}),
       ...(restarting ? { restarting: { ...restarting, draining: runtime?.activeJobIds() ?? [] } } : {}),
+      ...(pending && cutoverService?.busy() ? { restartDeferred: { reason: pending.reason, untilCutoverEnds: cutover?.requestId ?? null } } : {}),
+      ...(shadow ? { shadow: shadow.health() } : {}),
+      ...(runnerService ? { runner: runnerService.health() } : {}),
+      cutoverProtocol: CUTOVER_PROTOCOL,
+      ...(cutover ? { cutover } : {}),
     };
   };
 
@@ -277,7 +309,7 @@ export async function runDaemon({
       onTransportAttempt: ({ path: requestPath, phase }) => {
         const call = `${phase} ${requestPath}`;
         if (requestPath === MIRROR_PATH) mirrorProgress(call);
-        else watchdog.progress('cycle', { call });
+        else if (!SHADOW_PATHS.some((suffix) => requestPath.split('?')[0].endsWith(suffix))) watchdog.progress('cycle', { call });
       },
       ...dependencyOptions,
     });
@@ -312,18 +344,37 @@ export async function runDaemon({
         },
       },
     });
+    shadow = createShadow({ directory, transportFactory: production.transportFactory, tokenStore: production.tokenStore, log: mirrorLog });
+    runnerService = createRunner({ directory, transportFactory: production.transportFactory, log });
     heartbeat = createHeartbeat({
-      readConfig: () => readOwnerOnlyJson(configFile),
+      readConfig: () => {
+        heartbeatGeneration = ++configGeneration;
+        return readOwnerOnlyJson(configFile);
+      },
       runtime,
       mirror,
+      shadow,
+      runner: { update: (config) => runnerService.update(config, { generation: heartbeatGeneration }) },
       lock,
       ledger,
       ownerStore,
       progress: cycleProgress,
       extraHealth,
     });
+    // A cutover request runs here, beside the heartbeat; its facade step starts this daemon's runner at once.
+    const serve = async () => {
+      const generation = ++configGeneration;
+      runnerService.update(await readOwnerOnlyJson(configFile), { generation });
+    };
+    cutoverService = createCutoverService({
+      directory,
+      log,
+      canTake: () => !exiting && !restarting && !pending,
+      createCutover: ({ log: stepLog }) => cutoverFactory({ configDir: directory, log: stepLog, serve }),
+    });
+    cutoverService.start();
     stopServices = async ({ abortCode }) => {
-      const results = await Promise.allSettled([mirror.stop(), runtime.shutdown({ abortCode })]);
+      const results = await Promise.allSettled([cutoverService.stop(), mirror.stop(), shadow.stop(), runnerService.stop(), runtime.shutdown({ abortCode })]);
       const failed = results.find((result) => result.status === 'rejected');
       if (failed) throw failed.reason;
     };
@@ -353,7 +404,7 @@ export async function runDaemon({
       // A cycle that ends after shutdown released the lock has no health left to report.
       if (exiting) return;
       await Promise.resolve()
-        .then(() => lock.heartbeat({ state: 'error', code: error.code || 'HUB_DAEMON_LOOP_FAILED' }))
+        .then(() => lock.heartbeat({ state: 'error', code: error.code || 'HUB_DAEMON_LOOP_FAILED', ...extraHealth() }))
         .catch(() => {});
       wait = t.errorRetryMs;
     } finally {

package/src/lib/daemonRuntime.js

@@ -49,6 +49,8 @@ const SETTLE_GIVE_UP_MS = 30_000;
 // 20 s Retry-After. An open session is reused, so these two set the steady call rate.
 const HEARTBEAT_INTERVAL_MS = 15_000;
 const CLAIM_SPACING_MS = 10_000;
+// With claims off a cycle is only the heartbeat, so it runs at the heartbeat's own pace.
+const CLAIMS_OFF_WAIT_MS = HEARTBEAT_INTERVAL_MS;
 // A cloud that refuses this connector's contract version is asked again this late, or at the next daemon start.
 export const CONTRACT_RETRY_MS = 60 * 60 * 1_000;
 
@@ -610,6 +612,12 @@ export class DaemonRuntime {
     await this.#flush(transport);
     if (this.stopping) return { state: 'stopping', processed: 0 };
     if (this.draining) return { state: 'draining', processed: 0 };
+    // `jobs.claim: false` keeps the session, heartbeat and mirror but takes no work, so a test connector beside the
+    // live hub can never run a hub.* job into it.
+    if (this.config.jobs?.claim === false) {
+      this.state = 'running';
+      return { state: this.state, processed: 0, claims: 'off', retryAfterMs: CLAIMS_OFF_WAIT_MS };
+    }
     this.progress('claim');
     const claimedAt = this.now();
     const claimed = await transport.poll({

package/src/lib/doctorWarnings.js

@@ -0,0 +1,53 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileBounded } from './subprocess.js';
+
+/**
+ * `pulse doctor` warnings (Pulse 1.1.1): facts about this machine worth knowing that never make it unhealthy. Each
+ * probe answers `{ ok: true, warn, message, ... }`, or `{ ok: true, skipped }` when there is nothing to look at.
+ */
+
+/** In use at or above this share of max_connections, the local Postgres is close to refusing new connections. */
+export const POSTGRES_HEADROOM_WARN = 0.8;
+/** The hook events the Pulse hook needs beyond postToolUse, stop and afterAgentResponse: failed Shell calls bind aliases, the rest say whether a session is in a tool call or gone. */
+export const HUB_HOOK_EVENTS = ['postToolUseFailure', 'preToolUse', 'sessionEnd'];
+const QUERY = "SELECT count(*), current_setting('max_connections') FROM pg_stat_activity";
+
+/** Connections in use against max_connections on the local Postgres (PULSE_PG_URL, else localhost), through psql. */
+export async function postgresHeadroom({ url = process.env.PULSE_PG_URL || 'postgres://localhost/postgres', run = execFileBounded } = {}) {
+  let stdout;
+  try {
+    ({ stdout } = await run('psql', [url, '-X', '-A', '-t', '-F', ',', '-c', QUERY], { timeout: 5_000 }));
+  } catch (error) {
+    return { ok: true, skipped: error && error.code === 'ENOENT' ? 'psql is not installed' : 'no local Postgres answered' };
+  }
+  const [used, max] = String(stdout).trim().split(',').map(Number);
+  if (!Number.isFinite(used) || !Number.isFinite(max) || max <= 0) return { ok: true, skipped: 'unreadable answer from psql' };
+  const warn = used / max >= POSTGRES_HEADROOM_WARN;
+  return {
+    ok: true, used, max, warn,
+    message: `Local Postgres: ${used} of ${max} connections in use${warn ? `; past ${Math.round(POSTGRES_HEADROOM_WARN * 100)}%, new connections may soon be refused` : ''}.`,
+  };
+}
+
+/** Which of HUB_HOOK_EVENTS ~/.cursor/hooks.json sends to the hub hook (hub-bridge.mjs). Read-only. */
+export async function hubHooks({ file = path.join(os.homedir(), '.cursor', 'hooks.json') } = {}) {
+  let hooks;
+  try {
+    hooks = JSON.parse(await readFile(file, 'utf8')).hooks || {};
+  } catch {
+    return { ok: true, skipped: 'no readable ~/.cursor/hooks.json' };
+  }
+  const wired = Object.entries(hooks)
+    .filter(([, entries]) => Array.isArray(entries) && entries.some((e) => e && typeof e.command === 'string' && e.command.includes('hub-bridge.mjs')))
+    .map(([event]) => event);
+  if (!wired.length) return { ok: true, skipped: 'the hub hook is not in ~/.cursor/hooks.json' };
+  const missing = HUB_HOOK_EVENTS.filter((event) => !wired.includes(event));
+  return {
+    ok: true, wired, missing, warn: missing.length > 0,
+    message: missing.length
+      ? `~/.cursor/hooks.json does not send ${missing.join(', ')} to the hub hook: a bus register chained to a failing command does not bind, and a session in a long tool call can look gone. Add them with the same command as postToolUse.`
+      : 'The hub hook gets every event it uses.',
+  };
+}

package/src/lib/errors.js

@@ -8,6 +8,20 @@ export class HubError extends Error {
   }
 }
 
+/** Pulse 1.1.2 (SCOPE-02): what fixes a refusal no retry can fix: a sign-in missing scopes, or a machine grant missing a capability. */
+export const SCOPE_FIX = 'agentpulse pulse login';
+export const GRANT_FIX = 'agentpulse pulse log-write on';
+
+/** A refusal for scopes or grant as health shows it (`{ code, missingScopes, fix }`), or null for any other error. */
+export function scopeBlock(error) {
+  const code = error?.code;
+  if (code === 'HUB_SCOPE_DENIED' || code === 'HUB_SCOPE_MISSING') {
+    return { code, missingScopes: Array.isArray(error.details?.missingScopes) ? error.details.missingScopes : [], fix: SCOPE_FIX };
+  }
+  if (code === 'capability_denied') return { code, missingScopes: [], fix: GRANT_FIX };
+  return null;
+}
+
 export function assertNever(value, label = 'value') {
   throw new HubError('HUB_INTERNAL_UNHANDLED_VARIANT', `Unhandled ${label}: ${String(value)}`);
 }

package/src/lib/hubDbReader.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import { openDatabase } from './sqlite.js';
+
+const parseJson = (text, fallback) => {
+  if (text === null || text === undefined || text === '') return fallback;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+};
+
+/** An actor row in the local registry's shape (agents-hub core/registry.mjs rowActor at 37a0b2f, without `title`). */
+export function rowActor(r) {
+  return {
+    id: r.id,
+    node_type: r.node_type,
+    role: r.role,
+    parent_id: r.parent_id,
+    delivery_id: r.delivery_id,
+    stream_key: r.stream_key,
+    cursor_title: r.cursor_title,
+    prompt_title: r.prompt_title,
+    persona_name: r.persona_name,
+    persona_first: r.persona_first,
+    persona_username: r.persona_username,
+    persona_seed: r.persona_seed,
+    persona: parseJson(r.persona_json, null),
+    source: r.source,
+    topics: parseJson(r.topics, []),
+    started_at: r.started_at,
+    last_at: r.last_at,
+    tokens_est: r.tokens_est,
+    msgs_in: r.msgs_in,
+    msgs_out: r.msgs_out,
+    repo: r.repo,
+    channel: r.channel,
+    synthetic: !!r.synthetic,
+    extra: parseJson(r.extra, null),
+  };
+}
+
+const plain = (row) => ({ ...row });
+
+/**
+ * Read-only access to the local hub's `state/hub.db`. Each `read(fn)` opens the file read-only (no `immutable`, no
+ * pragma that writes), runs every query of one pass inside a single short read transaction so recipients and their
+ * messages come from the same snapshot, and closes the handle, so the hub's writers and WAL checkpoints never wait on
+ * a reader across an await. `fn` must be synchronous.
+ */
+export class HubDbReader {
+  constructor({ hubDir, file = path.join(hubDir, 'state', 'hub.db'), busyMs = 2_000 }) {
+    this.file = file;
+    this.busyMs = busyMs;
+  }
+
+  read(fn) {
+    const db = openDatabase(this.file, { readOnly: true });
+    try {
+      db.prepare(`PRAGMA busy_timeout = ${Number(this.busyMs)}`).run();
+      db.prepare('BEGIN').run();
+      try {
+        return fn(new HubSnapshot(db));
+      } finally {
+        db.prepare('COMMIT').run();
+      }
+    } finally {
+      db.close();
+    }
+  }
+}
+
+/** The queries of one read transaction. */
+export class HubSnapshot {
+  constructor(db) {
+    this.db = db;
+  }
+
+  /** Every actor in table order (the order the local registry lists them). */
+  actors() {
+    return this.db.prepare('SELECT * FROM actors ORDER BY rowid').all().map(rowActor);
+  }
+
+  presence() {
+    return this.db.prepare('SELECT actor_id, last_seen, last_event FROM presence ORDER BY rowid').all().map(plain);
+  }
+
+  /** Messages created at or after `sinceMs`, in (created_at, rowid) order: rowid breaks ties the way the hub inserted them. */
+  messagesSince(sinceMs) {
+    return this.db.prepare('SELECT rowid AS _rowid, * FROM messages WHERE created_at >= ? ORDER BY created_at, rowid').all(sinceMs)
+      .map((row) => ({ ...row, meta: parseJson(row.meta, {}) }));
+  }
+
+  messageIdsSince(sinceMs) {
+    return new Set(this.db.prepare('SELECT id FROM messages WHERE created_at >= ?').all(sinceMs).map((row) => row.id));
+  }
+
+  messageExists(id) {
+    return Boolean(this.db.prepare('SELECT 1 AS found FROM messages WHERE id = ?').get(id));
+  }
+
+  /** Recipient rows of these messages, in table order. */
+  recipients(messageIds) {
+    const out = new Map();
+    const statement = this.db.prepare(
+      'SELECT message_id, recipient, state, attempts, delivered_at, delivered_via, acked_at FROM deliveries WHERE message_id = ? ORDER BY rowid',
+    );
+    for (const id of messageIds) out.set(id, statement.all(id).map(plain));
+    return out;
+  }
+
+  /** One recipient row with its message's expiry, or null when either is gone. */
+  receipt(messageId, recipient) {
+    const row = this.db.prepare(
+      `SELECT d.message_id, d.recipient, d.state, d.attempts, d.delivered_at, d.delivered_via, d.acked_at, m.expires_at, m.topic
+         FROM deliveries d JOIN messages m ON m.id = d.message_id
+        WHERE d.message_id = ? AND d.recipient = ?`,
+    ).get(messageId, recipient);
+    return row ? plain(row) : null;
+  }
+
+  eventsAfter(id) {
+    return this.db.prepare('SELECT id, at, kind, actor, payload FROM events WHERE id > ? ORDER BY id').all(id)
+      .map((row) => ({ ...row, payload: parseJson(row.payload, {}) }));
+  }
+
+  /** Facts of these kinds with their payload text as stored (parsed by the caller only when it changed). */
+  facts(kinds) {
+    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));
+  }
+}

package/src/lib/hubMapping.js

@@ -0,0 +1,108 @@
+import { createHash } from 'node:crypto';
+import { pathRejected } from './mirrorContract.js';
+import { canonicalJson } from './planContract.js';
+
+/**
+ * The local hub's rows as Pulse commands (design §11 table, cf-phase2 PLAN v2), as pure functions: the import, the
+ * shadow feed and anything that captures the same rows later (Phase 3) produce the same keys and payloads. Redaction
+ * is not done here: callers pass rows through the UploadRedactor, and content keys are taken from redacted payloads.
+ */
+const KEY_PART = /^[A-Za-z0-9._:/@-]{1,200}$/;
+const PERSONA_FIELDS = ['name', 'first', 'username', 'seed', 'personality'];
+
+const sha = (text) => createHash('sha256').update(text).digest('hex');
+export const without = (object, ...keys) => Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+
+/** `<label>:<part>` when the part is key-safe, else `<label>:h:<sha40>`, so a key never carries a space, path or secret. */
+export function keyPart(label, part) {
+  return KEY_PART.test(String(part)) && !pathRejected(String(part)) ? `${label}:${part}` : `${label}:h:${sha(String(part)).slice(0, 40)}`;
+}
+
+/** The content key of a state entity: the redacted payload without its `at`, digested. */
+export function contentSha(redactedPayload) {
+  return sha(canonicalJson(without(redactedPayload, 'at'))).slice(0, 12);
+}
+
+export function actorPayload(actor) {
+  return { id: actor.id, actor, at: Math.floor(Number(actor.last_at) || 0) };
+}
+
+export function messagePayload(message, recipients) {
+  return {
+    id: message.id, from: message.sender, fromName: message.from_name ?? null, topic: message.topic, type: message.type,
+    body: message.body, to: [...new Set(recipients.map((row) => row.recipient))], needsAck: Boolean(message.needs_reply),
+    expiresAt: Number(message.expires_at), replyTo: message.reply_to ?? null, reaction: message.reaction ?? null,
+    meta: message.meta ?? {}, at: Number(message.created_at),
+  };
+}
+
+/** The receipts a recipient row's current state implies (`leased` is `queued`: leases stay on the machine). */
+export function receiptEvents(row, topic, expiresAt) {
+  const base = { messageId: row.message_id, recipient: row.recipient };
+  const events = [];
+  const state = row.state === 'leased' ? 'queued' : row.state;
+  if (row.delivered_at !== null && row.delivered_at !== undefined) {
+    events.push({ type: 'receipt.delivered', key: `rcpt:${row.message_id}:${row.recipient}:delivered`, payload: { ...base, at: Number(row.delivered_at), ...(row.delivered_via ? { via: row.delivered_via } : {}) } });
+  }
+  if (state === 'acked') {
+    events.push({ type: 'receipt.acked', key: `rcpt:${row.message_id}:${row.recipient}:acked`, payload: { ...base, at: Number(row.acked_at ?? row.delivered_at ?? row.queued_at ?? expiresAt) } });
+  }
+  if (state === 'expired') {
+    events.push({ type: 'receipt.expired', key: `rcpt:${row.message_id}:${row.recipient}:expired`, payload: { ...base, at: Number(expiresAt) } });
+  }
+  return { state, events: events.map((event) => ({ ...event, group: `bus:${topic}` })) };
+}
+
+export function eventPayload(event) {
+  return { kind: event.kind, actor: event.actor ?? null, data: event.payload ?? {}, at: Number(event.at) };
+}
+
+export function personaPayload(id, persona) {
+  const value = Object.fromEntries(PERSONA_FIELDS.filter((field) => persona?.[field] !== undefined && persona?.[field] !== null).map((field) => [field, persona[field]]));
+  return { actorId: id, persona: value };
+}
+
+/**
+ * The commands of one fact row, each with its entity and key prefix (content keyed): a delivery travels without its
+ * streams, which go as stream facts of their own so a large delivery fits a command.
+ */
+export function factDescriptors(row, fact) {
+  const entity = `fact:${row.kind}:${row.key}`;
+  const prefix = keyPart(`fact:${row.kind}`, row.key);
+  const at = Number.isFinite(fact.at) ? fact.at : Number(row.updated_at);
+  const one = (type, payload) => ({ type, entity, prefix, group: entity, payload });
+  switch (row.kind) {
+    case 'delivery': {
+      const streams = Array.isArray(fact.streams) ? fact.streams : [];
+      const delivery = { ...without(fact, 'streams'), streamKeys: streams.map((stream) => stream.key) };
+      return [
+        one('delivery.updated', { id: row.key, delivery, at: Number(row.updated_at) }),
+        ...streams.map((stream) => ({
+          type: 'stream.updated', entity: `fact:stream:${stream.key}`, prefix: keyPart('fact:stream', stream.key), group: `fact:stream:${stream.key}`,
+          payload: { key: stream.key, deliveryId: row.key, stream: without(stream, 'deliveryId'), at: Number(row.updated_at) },
+        })),
+      ];
+    }
+    case 'agent-row':
+      return [one('actor.row_updated', { id: row.key, row: fact, at: Number(row.updated_at) })];
+    case 'request':
+      return [one('request.created', { id: row.key, request: fact, at })];
+    case 'accepted':
+      return [one('delivery.accepted', { id: row.key, at })];
+    case 'settings':
+      return [one('settings.changed', { key: row.key, value: fact, at: Number(row.updated_at) })];
+    case 'status_override':
+      return [one('status.overridden', { key: row.key, override: fact, at })];
+    default:
+      throw new TypeError(`hub mapping: fact kind ${row.kind} has no command`);
+  }
+}
+
+/** A task-channel post: its key from its own block's digest and occurrence, never from its inferred time. */
+export function postKey(channelKey, digestId) {
+  return `post:${channelKey}:${digestId}`;
+}
+
+export function postPayload(channel, post, body, truncated) {
+  return { channel, author: post.role, role: post.role, type: post.type, body, at: post.at, ...(truncated ? { truncated } : {}) };
+}