total-recall-brain 3.44.0 → 3.46.0

package/scaffold/.agent/skills/total-recall/plugins/automations/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "tr-plugin-automations",
+  "version": "1.2.0",
+  "type": "module",
+  "description": "Scheduled plugin task runner plus automation sources, triggers, observed outcomes and coverage across the Total Recall mesh.",
+  "scripts": {
+    "test": "vitest run",
+    "ssss": "ssss"
+  },
+  "license": "MIT",
+  "files": [
+    "cli.mjs",
+    "plugin.json",
+    "README.md",
+    "LICENSE",
+    "inventory.mjs",
+    "adapters.mjs",
+    "scheduler.mjs",
+    "cron.mjs",
+    "capability/",
+    "BRICK.md",
+    "DESIGN.md",
+    "ui/home.js",
+    "ui/automations.js",
+    "ui/chunks/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@gregiteen/ssss-cli": "0.14.5"
+  },
+  "overrides": {
+    "@ssss/cli": "npm:@gregiteen/ssss-cli@0.14.5"
+  }
+}

package/scaffold/.agent/skills/total-recall/plugins/automations/plugin.json

@@ -0,0 +1,151 @@
+{
+  "$schema": "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
+  "id": "automations",
+  "name": "Automations",
+  "version": "1.2.0",
+  "description": "Run scheduled plugin tasks and inspect automation sources, triggers, observed outcomes and coverage across the mesh.",
+  "author": "Total Recall",
+  "license": "MIT",
+  "reuse": {
+    "commands": ["total-recall mesh nodes"],
+    "owned": "Collects automation sources, triggers, outcomes and node coverage, and delegates confirmed local task cancellation to its owner."
+  },
+  "use_cases": [
+    "automation",
+    "monitoring"
+  ],
+  "gate": {
+    "tasks": ["List scheduled tasks and automations across the mesh", "Check an automation's real outcome", "Cancel a pending local task"],
+    "owned_commands": [
+      { "pattern": "(crontab\\s+-l\\b|launchctl\\s+list\\b)", "use": "total-recall automations list --json" }
+    ]
+  },
+  "cli": {
+    "answers_help": true,
+    "command": "automations",
+    "handler": "./cli.mjs",
+    "subcommands": [
+      {
+        "name": "list",
+        "description": "List automations and source coverage across known nodes",
+        "timeout_ms": 25000,
+        "effect": "read",
+        "output": "json",
+        "args": []
+      },
+      {
+        "name": "status",
+        "description": "Report observed automation states and source coverage",
+        "timeout_ms": 25000,
+        "effect": "read",
+        "output": "json",
+        "args": []
+      },
+      {
+        "name": "show",
+        "description": "Inspect one automation by its stable id",
+        "timeout_ms": 25000,
+        "effect": "read",
+        "output": "json",
+        "args": [
+          { "name": "receipt", "flag": "--receipt", "type": "boolean", "label": "Local terminal failure receipt" }
+        ]
+      },
+      {
+        "name": "dream",
+        "description": "Run dream, including decay, for every brain on this node",
+        "timeout_ms": 600000,
+        "effect": "write",
+        "output": "json",
+        "args": []
+      },
+      {
+        "name": "cancel",
+        "description": "Cancel one pending local durable task through its owner",
+        "effect": "write",
+        "output": "json",
+        "args": []
+      }
+    ]
+  },
+  "tasks": [
+    {
+      "intent": "Dream every brain on this node",
+      "schedule": "40 3 * * *",
+      "command": "dream --all-brains",
+      "placement": "per-node"
+    }
+  ],
+  "runtime": {
+    "modules": {
+      "scheduler": "scheduler.mjs"
+    },
+    "daemon": ["scheduler"]
+  },
+  "ui": {
+    "design_tokens": "DESIGN.md",
+    "home": "automations",
+    "elements": [
+      {
+        "id": "automations",
+        "kind": "panel",
+        "tag": "tr-automations",
+        "module": "ui/home.js",
+        "description": "Live automation inventory with per-source node coverage",
+        "events": [],
+        "tokens": [
+          "color-text",
+          "color-text-secondary",
+          "color-surface",
+          "color-border",
+          "color-success",
+          "color-error",
+          "spacing-md",
+          "radius-md"
+        ],
+        "optional_tokens": []
+      }
+    ]
+  },
+  "auth": {
+    "plugin": "auth",
+    "methods": [
+      "passkey",
+      "google-oauth2"
+    ],
+    "session_verification": true
+  },
+  "deploy": {
+    "targets": [
+      "ssss-app",
+      "nextjs",
+      "react",
+      "flask"
+    ],
+    "required_ssss_version": ">=0.9.3",
+    "access_grants": [
+      "auth:session:verify",
+      "ssss:vault:read",
+      "ssss:vault:write",
+      "ssss:events:append"
+    ]
+  },
+  "branding": {
+    "name": "Automations",
+    "color": "#f2bd63",
+    "badge": "Source coverage",
+    "font": "space-grotesk"
+  },
+  "status": {
+    "command": "status",
+    "refresh_seconds": 300
+  },
+  "capability": {
+    "entry": "capability/index.mjs",
+    "exports": ["collectSources"]
+  },
+  "distribution": {
+    "tier": "official",
+    "license": "open"
+  }
+}

package/scaffold/.agent/skills/total-recall/plugins/automations/scheduler.mjs

@@ -0,0 +1,246 @@
+/**
+ * Scheduled plugin tasks.
+ *
+ * A manifest task `{ intent, schedule: "<5-field cron>", command }` runs the
+ * plugin's own CLI on that schedule, out of process. `command` is a subcommand
+ * followed by its arguments ("cleanup --auto --json"). Tasks are per node by
+ * default; selected-node tasks run only on the node named in
+ * plugin_record.task_nodes[command].
+ *
+ * Scheduling runs against the global brain (the home installation), so run
+ * records and plugin.task_run events land where `automations list` reads
+ * them, whatever directory the daemon was started from.
+ *
+ * The last minute-slot each command ran in is kept in the plugin_record, so a
+ * restart neither repeats a slot nor loses one: when the daemon was busy or
+ * down, the most recent matching slot since the last run (within a day) runs
+ * once. A task never runs just because it was installed: the first run is the
+ * first matching slot after the scheduler first sees it.
+ *
+ * The daemon starts this module through the plugin's `runtime.daemon`
+ * declaration; Total Recall core holds no scheduler of its own.
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseCron, cronMatches } from './cron.mjs';
+
+export { parseCron, cronMatches } from './cron.mjs';
+
+const DEFAULT_TIMEOUT_MS = 60_000;
+const MAX_CATCHUP_MINUTES = 24 * 60;
+const TAIL_BYTES = 2000;
+const pad = (n) => String(n).padStart(2, '0');
+
+/** Core primitives the scheduler uses, loaded from the running Total Recall package. */
+export async function loadCore(packageRoot = process.env.TR_PACKAGE_ROOT) {
+  if (!packageRoot) throw new Error('TR_PACKAGE_ROOT is not set; the scheduler runs inside the Total Recall daemon');
+  const load = (name) => import(pathToFileURL(path.join(packageRoot, 'src', 'core', `${name}.mjs`)).href);
+  const [loader, store, state, runner, events, log, mesh] = await Promise.all([
+    load('plugin-loader'), load('plugin-store'), load('plugin-state'), load('plugin-runner'),
+    load('ssss-operation-service'), load('logger'), load('mesh'),
+  ]);
+  return {
+    discoverPlugins: loader.discoverPlugins,
+    vaultForPluginsDir: loader.vaultForPluginsDir,
+    readPluginRecord: store.readPluginRecord,
+    patchPluginRecord: store.patchPluginRecord,
+    ensurePluginRecord: store.ensurePluginRecord,
+    pluginExecutionEnabled: state.pluginExecutionEnabled,
+    runPluginCommand: runner.runPluginCommand,
+    appendVfsEvent: events.appendVfsEvent,
+    logger: log.logger,
+    getMeshSelf: mesh.getMeshSelf,
+    meshNodeKey: mesh.meshNodeKey,
+  };
+}
+
+/** Split a manifest task command into its subcommand and arguments. */
+export function splitTaskCommand(command) {
+  const [subcommand = '', ...args] = String(command || '').trim().split(/\s+/).filter(Boolean);
+  return { subcommand, args };
+}
+
+/** Task timeout: the task's own, else the subcommand's declared one, else 60 s. */
+export function taskTimeoutMs(task, manifest) {
+  if (Number.isInteger(task.timeout_ms)) return task.timeout_ms;
+  const { subcommand } = splitTaskCommand(task.command);
+  const declared = manifest?.cli?.subcommands?.find((s) => s.name === subcommand);
+  const value = declared?.timeout_ms ?? declared?.timeoutMs;
+  return Number.isInteger(value) ? value : DEFAULT_TIMEOUT_MS;
+}
+
+/** A selected-node task stays idle until this node's plugin record selects it. */
+export function taskRunsOnNode(task, record, self, meshNodeKey = (v) => String(v).toLowerCase()) {
+  if (task.placement !== 'selected-node') return true;
+  const selected = String(record?.task_nodes?.[task.command] || '').trim();
+  if (!selected || !self?.hostname) return false;
+  return selected === self.ip || meshNodeKey(selected) === meshNodeKey(self.hostname);
+}
+
+/** Local minute-slot key, e.g. 2026-09-22T14:05. */
+export function minuteSlot(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function slotToDate(slot) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(String(slot || ''));
+  return m ? new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5])) : null;
+}
+
+/** The most recent slot matching `cron` in (lastSlot, now], or null. */
+export function latestDueSlot(cron, lastSlot, now = new Date()) {
+  const floorNow = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), now.getMinutes());
+  const last = slotToDate(lastSlot);
+  for (let i = 0; i < MAX_CATCHUP_MINUTES; i++) {
+    const candidate = new Date(floorNow.getTime() - i * 60_000);
+    if (last && candidate <= last) return null;
+    if (cronMatches(cron, candidate)) return minuteSlot(candidate);
+  }
+  return null;
+}
+
+/** Last non-empty lines of a run's output, bounded for logs and alerts. */
+export function outputTail(output, maxChars = 400) {
+  const lines = String(output || '').trim().split('\n').map((l) => l.trim()).filter(Boolean);
+  const tail = lines.slice(-3).join(' | ');
+  return tail.length > maxChars ? tail.slice(-maxChars) : tail;
+}
+
+/** Ask the operator-alerts owner to report a failed run, once per task per day. */
+async function alertFailure(core, { plugin, command, slot, result, projectRoot }) {
+  const owner = core.discoverPlugins(projectRoot).find((p) => p.id === 'operator-alerts' && p.valid);
+  if (!owner) return { sent: false, error: 'operator-alerts is not installed' };
+  const reason = result.timedOut ? 'timed out' : `exit ${result.exitCode}`;
+  const tail = outputTail(result.output) || 'no output';
+  const args = [
+    '--title', `Scheduled task failed: ${plugin.id} ${command}`,
+    '--message', `${plugin.id} "${command}" (slot ${slot}) failed: ${reason}. ${tail}`,
+    '--event-id', `plugin-task-${plugin.id}-${command.replace(/[^a-z0-9]+/gi, '-')}-${slot.slice(0, 10)}`,
+  ];
+  try {
+    const sent = await core.runPluginCommand(owner, { subcommand: 'send', args, cwd: projectRoot, timeoutMs: 30_000 });
+    return { sent: sent.ok, error: sent.ok ? null : outputTail(sent.output) };
+  } catch (err) {
+    return { sent: false, error: err.message };
+  }
+}
+
+/**
+ * Run every task that is due. Tasks run sequentially so a slow plugin cannot
+ * multiply into concurrent processes on a constrained host.
+ * @param {{ core: object, projectRoot?: string, now?: Date, selfNode?: object, alert?: Function }} options
+ */
+export async function runDuePluginTasks(options) {
+  const { core, projectRoot = os.homedir(), now = new Date() } = options;
+  const alert = options.alert || ((info) => alertFailure(core, info));
+  const selfNode = options.selfNode === undefined ? core.getMeshSelf() : options.selfNode;
+  const results = [];
+
+  for (const plugin of core.discoverPlugins(projectRoot)) {
+    if (!plugin.valid || !Array.isArray(plugin.manifest.tasks) || plugin.manifest.tasks.length === 0) continue;
+
+    let record = core.readPluginRecord(plugin);
+    if (!record) record = await core.ensurePluginRecord(plugin);
+    if (!core.pluginExecutionEnabled(plugin, { projectRoot })) continue;
+    const runs = { ...(record?.task_runs || {}) };
+    let changed = false;
+
+    for (const task of plugin.manifest.tasks) {
+      if (!taskRunsOnNode(task, record, selfNode, core.meshNodeKey)) continue;
+      let cron;
+      try {
+        cron = parseCron(task.schedule);
+      } catch (err) {
+        core.logger.warn('plugin-tasks', `Skipping ${plugin.id}:${task.command} — ${err.message}`);
+        continue;
+      }
+
+      if (!runs[task.command]) {
+        // First sighting: mark the present so the first run is the next real slot.
+        runs[task.command] = minuteSlot(now);
+        changed = true;
+        continue;
+      }
+
+      const slot = latestDueSlot(cron, runs[task.command], now);
+      if (!slot) continue;
+
+      const { subcommand, args } = splitTaskCommand(task.command);
+      const result = await core.runPluginCommand(plugin, { subcommand, args, cwd: projectRoot, timeoutMs: taskTimeoutMs(task, plugin.manifest) })
+        .catch((err) => ({ ok: false, exitCode: null, output: err.message, durationMs: 0, timedOut: false }));
+      runs[task.command] = slot;
+      changed = true;
+      const entry = { plugin: plugin.id, command: task.command, slot, ok: result.ok, exitCode: result.exitCode, timedOut: !!result.timedOut, tail: result.ok ? '' : outputTail(result.output) };
+      if (!result.ok) entry.alert = await alert({ plugin, command: task.command, slot, result, projectRoot });
+      results.push(entry);
+
+      try {
+        await core.appendVfsEvent(
+          `plugins/${plugin.id}/task-${Date.now()}`,
+          {
+            kind: 'plugin.task_run',
+            plugin_id: plugin.id,
+            command: task.command,
+            intent: task.intent,
+            slot,
+            ok: result.ok,
+            exit_code: result.exitCode,
+            timed_out: !!result.timedOut,
+            duration_ms: result.durationMs,
+            output_tail: String(result.output || '').slice(-TAIL_BYTES),
+          },
+          { actorRole: 'system', intent: 'Record plugin task run', vaultRoot: core.vaultForPluginsDir(plugin.pluginsDir) }
+        );
+      } catch (err) {
+        core.logger.warn('plugin-tasks', `Could not record task run for ${plugin.id}: ${err.message}`);
+      }
+    }
+
+    if (changed) {
+      try {
+        await core.patchPluginRecord(plugin, { task_runs: runs });
+      } catch (err) {
+        core.logger.warn('plugin-tasks', `Could not update task runs for ${plugin.id}: ${err.message}`);
+      }
+    }
+  }
+
+  return results;
+}
+
+/** One log line per run; failures carry the reason and the output tail. */
+export function describeRun(r) {
+  if (r.ok) return `${r.plugin}:${r.command} slot ${r.slot} ok`;
+  const reason = r.timedOut ? 'timed out' : `exit ${r.exitCode}`;
+  const alert = r.alert ? (r.alert.sent ? '; operator alerted' : `; alert not sent (${r.alert.error})`) : '';
+  return `${r.plugin}:${r.command} slot ${r.slot} failed (${reason}): ${r.tail || 'no output'}${alert}`;
+}
+
+/**
+ * Daemon service entry point: check for due tasks once a minute.
+ * @returns {Promise<Function>} stop function
+ */
+export async function start(options = {}) {
+  const core = options.core || await loadCore();
+  const projectRoot = options.projectRoot || os.homedir();
+  let running = false;
+  const tick = async () => {
+    if (running) return;
+    running = true;
+    try {
+      for (const r of await runDuePluginTasks({ core, projectRoot })) {
+        core.logger[r.ok ? 'info' : 'warn']('plugin-tasks', describeRun(r));
+      }
+    } catch (err) {
+      core.logger.warn('plugin-tasks', `Scheduler tick failed: ${err.message}`);
+    } finally {
+      running = false;
+    }
+  };
+  const timer = setInterval(tick, 60_000);
+  timer.unref?.();
+  tick();
+  core.logger.info('plugin-tasks', `Plugin task scheduler started (automations) for ${projectRoot}`);
+  return () => clearInterval(timer);
+}

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/automations.js

@@ -0,0 +1,2 @@
+/** External bundlers may use this entrypoint; the sandbox loads the Home directly. */
+export { AutomationsElement } from './home.js';

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/control-ledger.md

@@ -0,0 +1,42 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: control-ledger
+title: Automation control ledger
+description: Browse observed automation records, filter by trigger and state, and distinguish declarations from an actual run.
+timestamp: "2026-11-08T10:14:00Z"
+intents: [automation inventory, scheduled work control ledger, filter automation trigger state and source]
+surfaces: [page]
+panel: automations
+operations: [list]
+data:
+  - list:/schema_version
+  - list:/checked_at
+  - list:/complete
+  - list:/nodes/0/automations/0/id
+  - list:/nodes/0/automations/0/node_id
+  - list:/nodes/0/automations/0/source
+  - list:/nodes/0/automations/0/name
+  - list:/nodes/0/automations/0/intent
+  - list:/nodes/0/automations/0/origin
+  - list:/nodes/0/automations/0/trigger/kind
+  - list:/nodes/0/automations/0/trigger/summary
+  - list:/nodes/0/automations/0/trigger/timezone
+  - list:/nodes/0/automations/0/enabled
+  - list:/nodes/0/automations/0/state
+  - list:/nodes/0/automations/0/runner_available
+  - list:/nodes/0/automations/0/placement
+  - list:/nodes/0/automations/0/plugin_id
+  - list:/nodes/0/automations/0/plugin_name
+  - list:/nodes/0/automations/0/schedule
+  - list:/nodes/0/automations/0/valid
+  - list:/nodes/0/automations/0/last_handled_slot
+  - list:/nodes/0/automations/0/last_run/at
+  - list:/nodes/0/automations/0/last_run/state
+  - list:/nodes/0/automations/0/last_run/exit_code
+---
+<section data-design-component="ledger-note" aria-label="Automation control ledger">
+  <p data-design-component="ledger-label">Triggers · sources · outcomes</p>
+  <h2>Automation control ledger</h2>
+  <p>Filter the inventory by node, source, trigger or observed state. Start with this node and scan the mesh when you need remote coverage.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/local-inventory-triage.md

@@ -0,0 +1,17 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: local-inventory-triage
+title: Triage missing automations in local inventory
+description: Inspect this machine's source coverage before treating an absent record as a missing automation.
+timestamp: "2026-11-08T23:12:00Z"
+intents: [why is an automation missing locally, check local automation inventory completeness, narrow fleet automation inventory to this host]
+surfaces: [page]
+panel: automations
+operations: [list, status]
+data: ["list:/complete", "list:/nodes/0/self", "list:/nodes/0/coverage/0/source", "list:/nodes/0/coverage/0/status"]
+---
+<section data-design-component="ledger-note">
+  <h2>Start with local source coverage</h2>
+  <p>Switch the ledger to this machine. Check whether the automation's source was read before looking elsewhere or deciding that its record is absent.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/pending-control.md

@@ -0,0 +1,39 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: pending-control
+title: Confirm pending task cancellation
+description: Review the local source-owned control, confirm the pending task target, and verify its final cancellation receipt.
+timestamp: "2026-11-08T10:14:00Z"
+intents: [cancel pending local durable automation, source owned task cancellation receipt, pending task safety controls]
+surfaces: [page]
+operations: [list, show, cancel]
+data:
+  - list:/nodes/0/coverage/0/source
+  - list:/nodes/0/coverage/0/status
+  - list:/nodes/0/coverage/0/checked_at
+  - list:/nodes/0/coverage/0/error
+  - list:/nodes/0/automations/0/last_exit_code
+  - list:/nodes/0/automations/0/command
+  - list:/nodes/0/automations/0/actions/0/command
+  - list:/nodes/0/automations/0/actions/0/label
+  - list:/nodes/0/automations/0/actions/0/args/0
+  - list:/nodes/0/automations/0/actions/0/effect
+  - list:/nodes/0/automations/0/owner_ref/layer
+  - list:/nodes/0/automations/0/owner_ref/slug
+  - show:/automation/actions/0/command
+  - show:/automation/actions/0/label
+  - show:/automation/actions/0/args/0
+  - show:/automation/actions/0/effect
+  - show:/automation/owner_ref/layer
+  - show:/automation/owner_ref/slug
+  - show:/automation/last_exit_code
+  - cancel:/success
+  - cancel:/id
+  - cancel:/state
+---
+<section data-design-component="ledger-note" aria-label="Confirm pending task cancellation">
+  <p data-design-component="ledger-label">Local controls</p>
+  <h2>Confirm pending task cancellation</h2>
+  <p>Choose a pending record with an advertised cancellation action. Review its source and stable ID before confirming. The owner must report the final cancelled state.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/run-evidence.md

@@ -0,0 +1,41 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: run-evidence
+title: Automation run evidence
+description: Inspect the source-owned automation record, schedule, last handled slot and actual outcome by stable ID.
+timestamp: "2026-11-08T10:14:00Z"
+intents: [inspect automation run outcome, audit handled slot and exit code, show automation by stable ID]
+surfaces: [page]
+operations: [show]
+data:
+  - show:/schema_version
+  - show:/checked_at
+  - show:/automation/id
+  - show:/automation/node_id
+  - show:/automation/source
+  - show:/automation/name
+  - show:/automation/intent
+  - show:/automation/command
+  - show:/automation/origin
+  - show:/automation/trigger/kind
+  - show:/automation/trigger/summary
+  - show:/automation/trigger/timezone
+  - show:/automation/enabled
+  - show:/automation/state
+  - show:/automation/runner_available
+  - show:/automation/last_run/at
+  - show:/automation/last_run/state
+  - show:/automation/last_run/exit_code
+  - show:/automation/placement
+  - show:/automation/plugin_id
+  - show:/automation/plugin_name
+  - show:/automation/schedule
+  - show:/automation/valid
+  - show:/automation/last_handled_slot
+---
+<section data-design-component="ledger-note" aria-label="Automation run evidence">
+  <p data-design-component="ledger-label">Observed runs</p>
+  <h2>Automation run evidence</h2>
+  <p>Read the record by stable ID. A handled slot records scheduler activity. The run timestamp, state and exit code describe execution when the owner reports them.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/schedule-vs-run-evidence.md

@@ -0,0 +1,17 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: schedule-vs-run-evidence
+title: Verify that a scheduled automation actually ran
+description: Compare the declared schedule and last handled slot with the observed run time and exit state for an automation.
+timestamp: "2026-11-08T23:12:00Z"
+intents: [verify scheduled automation actually ran, investigate missed schedule slot, compare schedule with observed automation outcome]
+surfaces: [page]
+panel: automations
+operations: [list, show]
+data: ["show:/automation/schedule", "show:/automation/last_handled_slot", "show:/automation/last_run/at", "show:/automation/last_run/state", "show:/automation/last_run/exit_code"]
+---
+<section data-design-component="ledger-note">
+  <h2>Find observed run evidence</h2>
+  <p>Open the automation in the ledger. Compare the schedule and last handled slot with the observed run time and exit state. A schedule identifies when work should run.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/automations/ui/chunks/source-coverage.md

@@ -0,0 +1,41 @@
+---
+type: ui-chunk:chunk
+plugin: automations
+id: source-coverage
+title: Mesh automation source coverage
+description: Inspect node reachability, per-source coverage and observed state counts before relying on an inventory.
+timestamp: "2026-11-08T10:14:00Z"
+intents: [automation node coverage, offline or unauthorized automation source, observed automation state counts]
+surfaces: [page]
+operations: [list, status]
+data:
+  - status:/schema_version
+  - status:/checked_at
+  - status:/complete
+  - status:/nodes/0/node_id
+  - status:/nodes/0/hostname
+  - status:/nodes/0/ip
+  - status:/nodes/0/self
+  - status:/nodes/0/online
+  - status:/nodes/0/checked_at
+  - status:/nodes/0/status
+  - status:/nodes/0/error
+  - status:/nodes/0/counts
+  - status:/nodes/0/coverage/0/source
+  - status:/nodes/0/coverage/0/status
+  - status:/nodes/0/coverage/0/checked_at
+  - status:/nodes/0/coverage/0/error
+  - list:/nodes/0/node_id
+  - list:/nodes/0/hostname
+  - list:/nodes/0/ip
+  - list:/nodes/0/self
+  - list:/nodes/0/online
+  - list:/nodes/0/checked_at
+  - list:/nodes/0/status
+  - list:/nodes/0/error
+---
+<section data-design-component="ledger-note" aria-label="Mesh automation source coverage">
+  <p data-design-component="ledger-label">Coverage</p>
+  <h2>Mesh automation source coverage</h2>
+  <p>Review the node check time and each source outcome. A count is meaningful only beside its coverage, including unsupported sources and offline nodes.</p>
+</section>