total-recall-brain 3.44.0 → 3.45.0

package/frontend/dist/index.html

@@ -17,7 +17,7 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:opsz,wght@12..96,600;12..96,800&family=Cabinet+Grotesk:wght@700;800&family=Chivo+Mono:wght@500;700&family=Cinzel:wght@600;700;900&family=Cormorant+Garamond:ital,wght@0,600;0,700;1,600;1,700&family=DM+Mono:wght@500&family=DM+Sans:wght@500;700&family=Fraunces:opsz,wght@9..144,600;9..144,800&family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;700&family=Lexend:wght@600;800&family=Newsreader:ital,opsz,wght@0,6..72,600;1,6..72,600&family=Orbitron:wght@700;900&family=Outfit:wght@500;700;800&family=Plus+Jakarta+Sans:wght@600;700;800&family=Space+Grotesk:wght@600;700&family=Syne:wght@700;800&display=swap" rel="stylesheet" />
     <title>Total Recall — Portable Memory</title>
-    <script type="module" crossorigin src="/assets/index-DD4qONvH.js"></script>
+    <script type="module" crossorigin src="/assets/index-DACh1dhx.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DtwsDyFM.css">
   </head>
   <body>

package/frontend/src/App.tsx

@@ -323,7 +323,7 @@ function MainContent({ activeBrainId }: { activeBrainId: string }) {
           <Route path="/memory" element={<MemoryPage activeBrainId={activeBrainId} />} />
           <Route path="/rules" element={<RulesPage activeBrainId={activeBrainId} />} />
           <Route path="/graph" element={<GraphPage activeBrainId={activeBrainId} />} />
-          <Route path="/tasks" element={<Navigate to="/plugins?id=user-automations" replace />} />
+          <Route path="/tasks" element={<Navigate to="/plugins?id=automations" replace />} />
           <Route path="/skills" element={<Navigate to="/plugins?id=skill-manager" replace />} />
           <Route path="/openwiki" element={<Navigate to="/plugins?id=openwiki" replace />} />
           <Route path="/plugins" element={<PluginsPage activeBrainId={activeBrainId} />} />
@@ -339,7 +339,7 @@ function MainContent({ activeBrainId }: { activeBrainId: string }) {
           {/* Legacy OS-control-plane routes → core product */}
           <Route path="/vault" element={<Navigate to="/memory" replace />} />
           <Route path="/inbox" element={<Navigate to="/tasks" replace />} />
-          <Route path="/automations" element={<Navigate to="/plugins?id=user-automations" replace />} />
+          <Route path="/automations" element={<Navigate to="/plugins?id=automations" replace />} />
           <Route path="/files" element={<Navigate to="/memory" replace />} />
           <Route path="/sandbox" element={<Navigate to="/memory" replace />} />
           <Route path="/models" element={<Navigate to="/settings" replace />} />

package/frontend/src/pages/PluginsPage.tsx

@@ -52,7 +52,7 @@ const DEFAULT_CORE_PLUGINS = new Set([
   "code-quality",
   "security",
   "embeddings",
-  "git-sentinel"
+  "git"
 ])
 
 const AGENT_RECIPE_PROMPT = `You are my coding agent. Author a bespoke Total Recall plugin for [DOMAIN] following the Total Recall Plugin Recipe:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.44.0",
+  "version": "3.45.0",
   "description": "The Vibe Coding Brain & Autonomous Software Factory: memory, rules, secrets, and 33 visual plugins automatically managed across all your devices.",
   "type": "module",
   "bin": {

package/scaffold/.agent/skills/total-recall/plugins/auth/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "tr-plugin-auth",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tr-plugin-auth",
-      "version": "1.2.9",
+      "version": "1.2.10",
       "license": "MIT",
       "dependencies": {
         "@gregiteen/ssss-cli": "0.14.5",
@@ -19,7 +19,7 @@
       },
       "devDependencies": {
         "supertest": "^7.3.1",
-        "total-recall-brain": "3.43.3",
+        "total-recall-brain": "3.44.0",
         "vitest": "^4.1.12"
       }
     },
@@ -6704,9 +6704,9 @@
       }
     },
     "node_modules/total-recall-brain": {
-      "version": "3.43.3",
-      "resolved": "https://registry.npmjs.org/total-recall-brain/-/total-recall-brain-3.43.3.tgz",
-      "integrity": "sha512-yjfPN/BQxEEa+iodyFXQov/6fRt1pZg/7RcmgsbpALwBt6Ki3JJjT3tzArBC7NxHQmXgGYyKnCYId6xe/W2rPg==",
+      "version": "3.44.0",
+      "resolved": "https://registry.npmjs.org/total-recall-brain/-/total-recall-brain-3.44.0.tgz",
+      "integrity": "sha512-VNPaIO9zsSwoxAsJ5ByIQBP9zPpLq4RiQO7Vrex4rBOHFQJT50P7utcZiLMSZTyZJU4C/m5uB8qTCSBMp6+l6Q==",
       "dev": true,
       "license": "MIT",
       "workspaces": [
@@ -6714,7 +6714,7 @@
       ],
       "dependencies": {
         "@simplewebauthn/server": "^13.3.2",
-        "@ssss/cli": "npm:@gregiteen/ssss-cli@0.14.4",
+        "@ssss/cli": "npm:@gregiteen/ssss-cli@0.14.5",
         "bcrypt": "^6.0.0",
         "better-sqlite3": "^12.11.1",
         "cookie-parser": "^1.4.7",

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

@@ -1,6 +1,6 @@
 {
   "name": "tr-plugin-auth",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "White-label Total Recall auth plugin: Passkey biometric FIDO2 and Google OAuth2 authentication.",
   "type": "module",
   "main": "cli.mjs",

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

@@ -2,7 +2,7 @@
   "$schema": "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
   "id": "auth",
   "name": "Auth & Secrets",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "Hardware WebAuthn biometric FIDO2 passkeys, OAuth session security, and access control.",
   "author": "Total Recall contributors",
   "license": "MIT",

package/scaffold/.agent/skills/total-recall/plugins/auth/src/cli-secret.mjs

@@ -294,6 +294,8 @@ function printHelp() {
     carriers              Find shell profiles and /etc files that export the master
                            password to every process; --remove-ambient deletes them
                            once an owner-only carrier holds the same password.
+    scan --stdin          Name the keys whose stored values occur in the text on stdin
+                           (values are never printed; exit 1 when one occurs)
     fingerprint           Identify a credential without printing it: length, type
                            prefix, fingerprint and the store keys holding the same
                            value. --from-clipboard | --stdin; --expect-prefix <p>
@@ -773,7 +775,7 @@ export default async function secretCli(argv) {
   }
   const brainDir = secretsStoreDir();
 
-  if (opts.stdin && opts.command !== 'fingerprint') {
+  if (opts.stdin && opts.command !== 'fingerprint' && opts.command !== 'scan') {
     if (!['set', 'rotate', 'rekey'].includes(opts.command)) {
       console.error('❌ --stdin is only valid with `set`, `rotate`, `rekey`, or `fingerprint`');
       await exitAfterFlush(1);
@@ -1292,6 +1294,23 @@ export default async function secretCli(argv) {
       return;
     }
 
+    if (opts.command === 'scan') {
+      // Name every store key whose value occurs in the text on stdin. Values never leave this
+      // process: callers (the git plugin's secret firewall) get key names only. One call per scan.
+      if (!opts.stdin) {
+        console.error('Usage: total-recall auth secret scan --stdin [--json]   (exit 1 when a stored value occurs)');
+        await exitAfterFlush(2);
+      }
+      // Diffs and staged files are large; one value check is not, so scan alone gets 64 MB.
+      const text = readAllStdinSync({ maxBytes: 64 * 1024 * 1024 }).toString();
+      const { textContainsSecrets } = await import('./secrets-store.mjs');
+      const result = await textContainsSecrets(brainDir, text);
+      if (opts.json) console.log(JSON.stringify({ ok: !result.leak, leak: result.leak, keys: result.keys, scanned_bytes: Buffer.byteLength(text) }));
+      else console.log(result.leak ? `  ❌ stored values found for: ${result.keys.join(', ')}` : '  ✅ no stored value found');
+      if (result.leak) process.exitCode = 1;
+      return;
+    }
+
     if (opts.command === 'fingerprint') {
       // Identify a credential without seeing it: which store keys hold the same
       // value, its length and its non-secret type prefix. Lets an operator check

package/scaffold/.agent/skills/total-recall/plugins/auth/src/secrets-store.mjs

@@ -771,13 +771,24 @@ export function listUsageEvents(brainDir, { limit = 100, key_ref = null, days =
 /**
  * True if any secret value appears in text (for surface/openwiki conformance).
  */
+export function isSettingValue(val) {
+  if (/^[a-z]+$/.test(val)) return true;
+  if (/^(?=.{4,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i.test(val)) return true;
+  if (/^[^\s@:/]+@([a-z0-9-]+\.)+[a-z]{2,63}$/i.test(val)) return true;
+  if (/^https?:\/\/[^\s@/]+(\/[^\s@]*)?$/i.test(val)) return true;
+  return false;
+}
+
 export async function textContainsSecrets(brainDir, text) {
   if (!text) return { leak: false, keys: [] };
   const secrets = await loadSecrets(brainDir);
   const leaked = [];
   for (const [key, val] of Object.entries(secrets)) {
     if (key === META_KEY) continue;
-    if (typeof val === 'string' && val.length >= 8 && text.includes(val)) {
+    // Settings, not credentials: a single lowercase word (DEPLOY_ENV=production), a hostname
+    // (MAILCOW_HOST), an email address, or a URL without user info. Matching them would refuse
+    // ordinary text. A URL that carries user:password@ is still checked, as is every other value.
+    if (typeof val === 'string' && val.length >= 8 && !isSettingValue(val) && text.includes(val)) {
       leaked.push(key);
     }
   }

package/scaffold/.agent/skills/total-recall/plugins/automations/BRICK.md

@@ -0,0 +1,7 @@
+# Automation source collection
+
+Copy `capability/` into your application. Import `collectSources` from `./capability/index.mjs` and supply unique source IDs, an adapter map, an ISO check timestamp and an optional positive record limit.
+
+Each adapter returns records or `{records,status,error?}`. Status is `ok`, `partial`, `unsupported`, `disabled`, `error` or `unauthorized`. The collector returns `automations`, independent source `coverage`, and `checked_at`; one failed source does not erase successful evidence. Missing adapters stay unsupported and oversized inventories become partial.
+
+Your application owns authorization, data shape, adapter timeouts, execution and persistence. Supply transports and credentials directly to your own adapters. This capability performs no filesystem, network, process or environment access and prints nothing.

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Greg Iteen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/scaffold/.agent/skills/total-recall/plugins/automations/README.md

@@ -0,0 +1,66 @@
+# Automations
+
+Inspect automation sources, triggers, observed outcomes and source coverage across the Total Recall mesh. Composable CLI remains the owner of reusable commands; a command definition is labelled as a manual definition until an explicit automation binding exists.
+
+```
+total-recall automations --help
+total-recall automations list --json
+total-recall automations list --local --source task-queue
+total-recall automations status --node <node>
+total-recall automations show <automation-id>
+total-recall automations cancel <local-task-id>
+total-recall automations dream --all-brains --json
+```
+
+Inventory includes plugin schedules, durable tasks, research queue work, daemon maintenance/watchers, SSSS workflow/trigger declarations, reusable composed commands, and operating-system automation declarations. macOS reads user/system launchd definitions and the current user’s crontab. Linux reads installed and loaded system/user timer units and the current user’s crontab. Commands, environment variables, queued payloads and secret values are excluded from OS summaries.
+
+Each source reports its own coverage. A missing integration, unreadable definition, denied peer, offline node or old collector remains explicit. External agent-platform automation providers have no authenticated inventory contract in this runtime and report unsupported; the plugin does not invent their state. Inventory can therefore be partial even when visible automation records are valid.
+
+A declared schedule does not prove a running scheduler. Last handled slot is not a successful run. Observed execution outcomes come from source-owned records/events; unavailable telemetry stays unknown. Individual daemon watcher registration is not reported by the current owner, so those records remain unknown even when the daemon itself is running.
+
+Selected-node tasks report `selected_node` and `placement_state`. A task without a canonical selection is `unplaced`. Peer metadata without selection evidence stays `unknown`. `last_run` includes the observed slot. `last_handled_outcome` reports the event for the exact stored handled slot. It stays unknown when no matching event exists.
+
+Full peer reads use mesh's authenticated command transport with a fixed local inventory command. If that read is unavailable, the plugin requests mesh-authenticated plugin metadata and marks coverage partial. It never sends a mesh-sync token to the PAT-protected plugin-run route.
+
+The card and panel use the same CLI contracts. Cancellation requires a pending local durable task and an owner that supports a conditional pending-to-cancelled transition. The plugin checks the saved owner state before reporting success. Older hosts can still inventory automations. Mesh peers use the plugin's local inventory operation and can report incomplete coverage. [Owner acceptance tracker](docs/projects/in-progress/ALL_AUTOMATIONS/ALL_AUTOMATIONS_PROJECT_TRACKER.md)
+
+## Scheduled plugin tasks
+
+This plugin runs the `tasks` every plugin declares in its manifest. Total Recall core has no scheduler of its own: the daemon starts this plugin's `scheduler` module through `runtime.daemon`, and it ships bundled with Total Recall.
+
+- `command` is a subcommand followed by its arguments, so `cleanup --auto --json` runs `cleanup` with `--auto --json`.
+- The timeout is the task's `timeout_ms`, else the subcommand's declared `timeout_ms`, else 60 seconds.
+- Scheduling runs against the global brain in the home folder, so run records and `plugin.task_run` events are where `list` reads them.
+- A failed run logs its reason and the end of its output, and alerts the operator through operator-alerts once per task per day.
+- A plugin switched off runs no tasks; a missed slot within the last day runs once; the first run is the first matching slot after the task is first seen.
+
+## Installation and ownership
+
+Use `total-recall plugin install <path-to-this-checkout>` for your own Total Recall workflow. Credentials belong to shared auth. The plugin id and CLI command are `automations`. The package name is `tr-plugin-automations`. The GitHub repository name and folder name change separately.
+
+For an application you ship, `total-recall plugin vendor <path-to-this-checkout>` selects the declared capability. Its `collectSources` export takes explicit source adapters and configuration. The Total Recall CLI wrapper, scheduler and platform accounts are host dependencies.
+
+## Dream and decay
+
+Automations owns one dream task at `40 3 * * *` in each node's local time. Its placement is `per-node`. Its command is `dream --all-brains`. Decay is a phase of dream. It has no separate schedule.
+
+The plugin calls `total-recall dream --all-brains --json` through `spawnSync` with no shell. It checks core's help for `--all-brains` first. Older core versions can ignore unknown flags. The operation fails before execution if core lacks the flag. It also fails for process errors, signals, invalid output and failed brain results. The JSON response reports `exit_code`, `child_exit_code` and `results`. Core must return a nonempty results array, either directly or in a `results` or `brains` field. The child timeout is 30 minutes. The host timeout is 31 minutes.
+
+`list` shows the dream task on each node. It reads the last real outcome from that node's task events. A handled slot stays separate from a real outcome. The cloud daemon must coordinate tasks across the mesh through Automations. This checkout change adds no new transport or deployment. Fleet execution requires a compatible core and an installed plugin on each node.
+
+## Development
+
+`npm test` runs only owner root/UI specs through `vitest.config.mjs`. Injected skill evaluations run independently in their owner and are not Vitest suites. Tests must use isolated/injected state and must not cancel real tasks. Plugin state is derived; persistent source state and controls stay with their owning APIs.
+
+## Using this from an agent
+
+Send questions about what is scheduled here: tasks, triggers and real outcomes across the mesh. A declared schedule does not prove anything ran, so read the outcome. To create a reusable command, use Composable CLI.
+
+```bash
+total-recall automations list --json
+total-recall automations status --node <node>
+total-recall automations show <automation-id>
+total-recall automations cancel <local-task-id>
+```
+
+Raw commands this plugin owns: `crontab -l` and `launchctl list`.

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

@@ -0,0 +1,231 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { collectSources } from './capability/index.mjs';
+
+const exec = promisify(execFile);
+export const SOURCES = Object.freeze(['plugin-tasks', 'task-queue', 'research-queue', 'daemon', 'workflows', 'composed-commands', 'operating-system', 'agent-platforms']);
+export const coreModule = (root, name) => import(pathToFileURL(path.join(root, 'src/core', `${name}.mjs`)).href);
+const digest = text => crypto.createHash('sha256').update(text).digest('hex').slice(0, 20);
+export const recordId = (node, source, key) => `${source}:${digest(`${node}\0${key}`)}`;
+const text = (value, max = 240) => typeof value === 'string' ? value.slice(0, max) : '';
+const canCancelPending = async (tasks, queueDir) =>
+  tasks.TASK_CANCELLATION_SUPPORTS_EXPECTED_STATUS === true
+  && typeof tasks.supportsPendingTaskCancellation === 'function'
+  && await tasks.supportsPendingTaskCancellation(queueDir) === true;
+export function automation(ctx, source, key, data) {
+  return { id: recordId(ctx.node_id, source, key), node_id: ctx.node_id, source,
+    name: key, origin: source, trigger: { kind: 'unknown', summary: 'Not reported' },
+    enabled: null, state: 'unknown', runner_available: null, last_run: null, actions: [], ...data };
+}
+export function scheduledTasks(plugins = [], ctx = { node_id: 'local' }) {
+  return plugins.flatMap(plugin => (Array.isArray(plugin.tasks) ? plugin.tasks : []).map(task => {
+    const selected_node = typeof plugin.task_nodes?.[task.command] === 'string' ? plugin.task_nodes[task.command].trim() || null : null;
+    const placement_state = task.placement !== 'selected-node' ? 'per-node'
+      : !Object.hasOwn(plugin, 'task_nodes') ? 'unknown' : selected_node ? 'selected' : 'unplaced';
+    return automation(ctx, 'plugin-tasks', `${plugin.id}:${task.command}`, {
+      name: text(task.intent || `${plugin.name || plugin.id} · ${task.command}`), origin: `plugin:${plugin.id}`,
+      plugin_id: plugin.id, plugin_name: plugin.name, command: task.command, intent: text(task.intent), schedule: task.schedule,
+      trigger: { kind: 'cron', summary: text(task.schedule) }, placement: task.placement || 'per-node',
+      selected_node, placement_state,
+      enabled: plugin.activation?.enabled ?? null, state: plugin.valid === false ? 'invalid' : plugin.activation?.enabled === false ? 'disabled' : placement_state === 'unplaced' ? 'unplaced' : 'declared',
+      runner_available: placement_state === 'unplaced' ? false : null,
+      valid: plugin.valid, last_handled_slot: task.last_run || null,
+      last_handled_outcome: task.last_run ? { slot: task.last_run, state: 'unknown' } : null,
+    });
+  }));
+}
+
+export async function boundedCommand(file, args, options = {}) {
+  try { const result = await exec(file, args, { timeout: 4000, maxBuffer: 2 * 1024 * 1024, encoding: 'utf8', windowsHide: true, ...options }); return result.stdout; }
+  catch (error) { const failure = new Error(error.code === 'ENOENT' ? `${file} is unavailable` : `${file} inventory failed (${error.killed ? 'timeout' : error.code || 'error'})`); failure.code = error.code; throw failure; }
+}
+
+/** Read only scheduler facts; never return commands, environments or secret-bearing arguments. */
+export async function operatingSystem(ctx) {
+  const run = ctx.runCommand || boundedCommand;
+  const records = [], warnings = [];
+  if (ctx.platform === 'darwin') {
+    const dirs = [path.join(ctx.home, 'Library/LaunchAgents'), '/Library/LaunchAgents', '/Library/LaunchDaemons', '/System/Library/LaunchAgents', '/System/Library/LaunchDaemons'];
+    let loaded = new Map();
+    try { loaded = new Map((await run('/bin/launchctl', ['list'])).split('\n').slice(1).map(line => line.trim().split(/\s+/)).filter(parts => parts.length >= 3).map(([pid, exit, label]) => [label, { pid, exit }])); }
+    catch (error) { warnings.push(error.message); }
+    for (const dir of dirs) {
+      let entries;
+      try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (error) { if (error.code !== 'ENOENT') warnings.push(`Cannot inspect ${dir}`); continue; }
+      const jobs = entries.filter(item => item.isFile() && item.name.endsWith('.plist'));
+      let cursor = 0;
+      await Promise.all(Array.from({ length: Math.min(4, jobs.length) }, async () => { while (cursor < jobs.length) {
+        const entry = jobs[cursor++];
+        const file = path.join(dir, entry.name);
+        try {
+          if (fs.statSync(file).size > 1024 * 1024) throw new Error('Job definition exceeds size limit');
+          const job = JSON.parse(await run('/usr/bin/plutil', ['-convert', 'json', '-o', '-', file]));
+          const label = text(job.Label || entry.name), runtime = loaded.get(label);
+          const kinds = [job.StartCalendarInterval && 'calendar', job.StartInterval && 'interval', job.WatchPaths && 'file-change', job.QueueDirectories && 'directory', job.KeepAlive && 'keep-alive', job.RunAtLoad && 'boot'].filter(Boolean);
+          // Socket/on-demand jobs are automations too; absence of a timer is not absence of a job.
+          records.push(automation(ctx, 'operating-system', file, { name: label, origin: `launchd:${label}`,
+            trigger: { kind: kinds[0] || 'on-demand', summary: job.StartInterval ? `Every ${Number(job.StartInterval)} seconds${kinds.length > 1 ? `; ${kinds.filter(kind => kind !== 'interval').join(', ')}` : ''}` : kinds.length ? kinds.join(', ') : 'On demand' },
+            enabled: job.Disabled === true ? false : null, state: runtime?.pid !== '-' && runtime?.pid ? 'running' : runtime ? 'loaded' : 'declared',
+            runner_available: runtime ? true : null, last_exit_code: runtime && runtime.exit !== '-' ? Number(runtime.exit) : null }));
+        } catch { warnings.push(`Cannot inspect launchd definition ${entry.name}`); }
+      } }));
+    }
+  } else if (ctx.platform === 'linux') {
+    for (const scope of ['system', 'user']) {
+      const scopeArgs = scope === 'user' ? ['--user'] : [];
+      try {
+        const [installed, loaded] = await Promise.all([
+          run('systemctl', [...scopeArgs, 'list-unit-files', '--type=timer', '--no-legend', '--no-pager']),
+          run('systemctl', [...scopeArgs, 'list-units', '--type=timer', '--all', '--no-legend', '--no-pager', '--plain']),
+        ]);
+        const active = new Map(loaded.trim().split('\n').map(line => line.trim().split(/\s+/)).filter(parts => parts[0]?.endsWith('.timer')).map(parts => [parts[0], parts[2]]));
+        for (const line of installed.trim().split('\n')) {
+          const [name, state] = line.trim().split(/\s+/); if (!name?.endsWith('.timer')) continue;
+          records.push(automation(ctx, 'operating-system', `${scope}:${name}`, { name, origin: `systemd:${scope}:${name}`, trigger: { kind: 'timer', summary: 'System timer' }, enabled: ['enabled', 'enabled-runtime', 'linked', 'linked-runtime'].includes(state) ? true : ['disabled', 'masked'].includes(state) ? false : null, state: active.get(name) || state, runner_available: active.has(name) ? true : null }));
+        }
+      } catch (error) { warnings.push(`${scope}: ${error.message}`); }
+    }
+  } else return { status: 'unsupported', records: [], error: `No operating-system adapter for ${ctx.platform}` };
+  try {
+    const cron = await run('crontab', ['-l']);
+    for (const [index, line] of cron.split('\n').entries()) {
+      const clean = line.trim(); if (!clean || clean.startsWith('#') || /^[A-Za-z_][A-Za-z0-9_]*\s*=/.test(clean)) continue;
+      const match = clean.match(/^(@\w+|(?:\S+\s+){4}\S+)\s+.+$/); if (!match) { warnings.push(`Unrecognized crontab line ${index + 1}`); continue; }
+      records.push(automation(ctx, 'operating-system', `crontab:${digest(clean)}`, { name: `Crontab job ${index + 1}`, origin: 'crontab:current-user', trigger: { kind: 'cron', summary: match[1] }, enabled: true, state: 'declared' }));
+    }
+  } catch (error) {
+    // Exit 1 means either no crontab or an access error; never claim empty coverage without evidence.
+    warnings.push(error.message);
+  }
+  records.sort((left, right) => left.id.localeCompare(right.id));
+  return { records, status: warnings.length ? 'partial' : 'ok', ...(warnings.length ? { error: [...new Set(warnings)].slice(0, 12).join('; ') } : {}) };
+}
+
+export async function createContext(packageRoot, options = {}) {
+  const config = options.config || await coreModule(packageRoot, 'config');
+  const active = config.getActiveBrains(options.projectRoot || process.cwd());
+  const brains = [active.global, active.project].filter(Boolean);
+  const unique = [...new Map(brains.map(brain => [path.resolve(brain.brainDir), brain])).values()];
+  return { packageRoot, projectRoot: options.projectRoot || process.cwd(), node_id: options.node_id || os.hostname(), home: options.home || os.homedir(), platform: options.platform || process.platform, brains: unique, config, ...options };
+}
+
+export async function sourceAdapters(ctx) {
+  const load = name => ctx.modules?.[name] || coreModule(ctx.packageRoot, name);
+  return {
+    'plugin-tasks': async () => {
+      const store = await load('plugin-store');
+      const plugins = store.listInstalledPlugins(ctx.projectRoot).map(plugin => ({ ...plugin }));
+      if (plugins.some(plugin => plugin.tasks?.some(task => task.placement === 'selected-node'))) {
+        const loader = await load('plugin-loader');
+        const discovered = new Map(loader.discoverPlugins(ctx.projectRoot).map(plugin => [plugin.id, plugin]));
+        for (const plugin of plugins) {
+          if (!plugin.tasks?.some(task => task.placement === 'selected-node')) continue;
+          const source = discovered.get(plugin.id);
+          if (source) plugin.task_nodes = store.readPluginRecord(source)?.task_nodes || {};
+        }
+      }
+      const records = scheduledTasks(plugins, ctx);
+      const events = await load('ssss-operation-service');
+      const payloads = [];
+      for (const brain of ctx.brains) for (const event of await events.listVfsEvents({ vaultRoot: path.join(brain.brainDir, 'memory-vault') })) {
+        let payload = event?.payload || event?.content; if (typeof payload === 'string') { try { payload = JSON.parse(payload); } catch { continue; } }
+        if (payload?.kind === 'plugin.task_run' && (!payload.node_id || payload.node_id === ctx.node_id)) payloads.push({ ...payload, at: event.timestamp || event.created_at || payload.at || null });
+      }
+      const eventTime = event => Date.parse(event.at || event.slot || '') || 0;
+      const outcome = event => ({ at: event.at || event.slot || null, slot: event.slot || null,
+        state: event.ok === true ? 'success' : event.ok === false ? 'failed' : 'unknown', exit_code: event.exit_code ?? null });
+      for (const record of records) {
+        const matching = payloads.filter(event => event.plugin_id === record.plugin_id && event.command === record.command)
+          .sort((a, b) => eventTime(a) - eventTime(b));
+        const last = matching.at(-1);
+        if (last) record.last_run = outcome(last);
+        const handled = record.last_handled_slot && matching.filter(event => event.slot === record.last_handled_slot).at(-1);
+        if (handled) record.last_handled_outcome = outcome(handled);
+      }
+      return records;
+    },
+    'task-queue': async () => {
+      const tasks = await load('task-envelope');
+      const queues = await Promise.all(ctx.brains.map(async (brain) => {
+        const queueDir = tasks.resolveQueueDir(brain.brainDir);
+        const canCancel = await canCancelPending(tasks, queueDir);
+        return tasks.listTasks(queueDir, { status: 'all' }).map((task) => {
+          const record = automation(ctx, 'task-queue', `${brain.layer}:${task.slug}`, { name: text(task.intent || task.slug), origin: `task:${brain.layer}:${task.slug}`, trigger: { kind: 'queue', summary: 'Queued work' }, enabled: !['completed', 'cancelled'].includes(task.status), state: task.status, owner_ref: { layer: brain.layer, slug: task.slug }, last_run: task.completed_at || task.failed_at ? { at: task.completed_at || task.failed_at, state: task.status, exit_code: null } : null });
+          if (canCancel && task.status === 'pending') record.actions = [{ command: 'cancel', label: 'Cancel task', args: [record.id], effect: 'write' }];
+          return record;
+        });
+      }));
+      return queues.flat();
+    },
+    'research-queue': async () => {
+      const research = await load('research-queue');
+      const records = [];
+      for (const brain of ctx.brains) {
+        let offset = 0;
+        while (true) {
+          const page = research.listQueue({ brainDir: brain.brainDir, limit: 500, offset });
+          if (!Array.isArray(page.items)) throw new Error('Invalid research queue response');
+          records.push(...page.items.map(task => automation(ctx, 'research-queue', `${brain.layer}:${task.id}`, { name: text(task.topic), origin: `research:${brain.layer}:${task.id}`, trigger: { kind: 'queue', summary: task.research_phase || 'Research queue' }, enabled: ['pending', 'in_progress'].includes(task.status), state: task.status, last_run: task.completed_at ? { at: task.completed_at, state: task.status, exit_code: null } : null })));
+          offset += page.items.length;
+          if (offset >= page.total) break;
+          if (!page.items.length) throw new Error('Research pagination made no progress');
+          if (records.length >= 10000) return { records, status: 'partial', error: 'Research queue exceeded 10000 records' };
+        }
+      }
+      return records;
+    },
+    daemon: async () => {
+      const [health, update] = await Promise.all([load('startup-health'), load('automatic-brain-updates')]);
+      return ctx.brains.flatMap(brain => {
+        const observation = health.observeDaemon(brain.brainDir), running = observation.status === 'running';
+        const maintenance = update.automaticUpdateStatus(brain.brainDir);
+        return [automation(ctx, 'daemon', `${brain.layer}:daemon`, { name: `${brain.layer} background worker`, origin: `daemon:${brain.layer}`, trigger: { kind: 'queue', summary: 'Durable queue and maintenance loop' }, state: observation.status, runner_available: running, enabled: null }),
+          automation(ctx, 'daemon', `${brain.layer}:package-updates`, { name: `${brain.layer} package maintenance`, origin: `automatic-brain-updates:${brain.layer}`, trigger: { kind: 'interval', summary: `Every ${maintenance.intervalMs / 60000} minutes; failed checks retry` }, enabled: maintenance.enabled, state: maintenance.enabled ? 'configured' : 'disabled', runner_available: running, last_run: maintenance.last ? { at: maintenance.last.checkedAt ? new Date(maintenance.last.checkedAt).toISOString() : null, state: maintenance.last.failed ? 'failed' : 'success', exit_code: null } : null }),
+          ...['vault-watch', 'source-watch', 'session-ingest', 'cli-surfaces', 'repo-sync', 'github-sync', 'obsidian-watch'].map(name => automation(ctx, 'daemon', `${brain.layer}:${name}`, { name: `${brain.layer} ${name}`, origin: `daemon:${brain.layer}:${name}`, trigger: { kind: name.includes('watch') ? 'file-change' : name === 'session-ingest' ? 'boot' : 'maintenance', summary: 'Daemon-managed; individual registration is not reported by owner' }, state: 'unknown', runner_available: running }))];
+      });
+    },
+    workflows: async () => {
+      const vfs = await load('vfs-documents');
+      return ctx.brains.flatMap(brain => vfs.listVfsDocuments(path.join(brain.brainDir, 'memory-vault')).filter(doc => ['workflow', 'trigger'].includes(doc.type)).flatMap(doc => {
+        const triggers = doc.type === 'trigger' ? [{ ...doc, type: doc.source }] : Array.isArray(doc.triggers) && doc.triggers.length ? doc.triggers : [{ type: 'manual' }];
+        return triggers.map((trigger, index) => automation(ctx, 'workflows', `${brain.layer}:${doc.vfs_path}:${trigger.id || trigger.trigger_id || index}`, { name: text(doc.title || doc.name || doc.id || doc.slug), origin: `vfs:${brain.layer}:${doc.vfs_path}`, trigger: { kind: text(trigger.type), summary: text(trigger.cron || trigger.interval || trigger.event_type || trigger.type || 'Unknown trigger'), ...(trigger.timezone ? { timezone: text(trigger.timezone) } : {}) }, enabled: doc.type === 'trigger' ? doc.status === 'active' ? true : ['disabled', 'paused'].includes(doc.status) ? false : null : typeof doc.isActive === 'boolean' ? doc.isActive : null, state: 'declared', runner_available: null }));
+      }));
+    },
+    'composed-commands': async () => {
+      const commands = await load('command-surface');
+      const dirs = commands.commandScopeDirectories(ctx.projectRoot, ctx.config.globalAgentDir);
+      return commands.listSurfaceCommands(dirs).map(command => automation(ctx, 'composed-commands', `${command.scope}:${command.name}`, { name: command.name, origin: `composable-cli:${command.scope}:${command.name}`, trigger: { kind: 'manual', summary: 'Reusable command; requires explicit automation binding' }, state: 'definition', enabled: null }));
+    },
+    'operating-system': () => operatingSystem(ctx),
+    'agent-platforms': async () => ({ status: 'unsupported', records: [], error: 'No authenticated agent-platform inventory contract is configured; provider automations cannot be inferred from local command definitions.' }),
+  };
+}
+
+export async function collectLocalAutomations(packageRoot, options = {}) {
+  const ctx = await createContext(packageRoot, options), checked_at = new Date().toISOString();
+  const adapters = options.adapters || await sourceAdapters(ctx);
+  return { node_id: ctx.node_id, ...await collectSources({ sources: SOURCES, adapters, checkedAt: checked_at }) };
+}
+
+export async function cancelAutomation(packageRoot, id, options = {}) {
+  const ctx = await createContext(packageRoot, options);
+  const tasks = ctx.modules?.['task-envelope'] || await coreModule(packageRoot, 'task-envelope');
+  for (const brain of ctx.brains) {
+    const queueDir = tasks.resolveQueueDir(brain.brainDir);
+    const task = tasks.listTasks(queueDir, { status: 'all' })
+      .find((candidate) => recordId(ctx.node_id, 'task-queue', `${brain.layer}:${candidate.slug}`) === id);
+    if (!task) continue;
+    if (task.status !== 'pending') throw new Error('Task is no longer pending');
+    if (!await canCancelPending(tasks, queueDir)) throw new Error('This host cannot safely cancel a pending task');
+    const result = await tasks.cancelTask(queueDir, task.slug, { expectedStatus: 'pending' });
+    if (!result.success) throw new Error(result.error || 'Task cancellation failed');
+    if (tasks.getTask(queueDir, task.slug)?.status !== 'cancelled') throw new Error('Task owner did not confirm cancellation');
+    return { success: true, id, state: 'cancelled' };
+  }
+  throw new Error('Cancellable local automation not found');
+}

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

@@ -0,0 +1,16 @@
+/** Source collection for an application-owned automation inventory. No host or transport assumptions. */
+export async function collectSources({ sources, adapters, checkedAt, limit = 10000 }) {
+  if (!Array.isArray(sources) || !sources.every(source => typeof source === 'string') || new Set(sources).size !== sources.length) throw new Error('Unique source ids are required');
+  if (!adapters || typeof adapters !== 'object' || !checkedAt || !Number.isSafeInteger(limit) || limit < 1) throw new Error('Adapters, checkedAt and a positive record limit are required');
+  const results = await Promise.all(sources.map(async source => {
+    try {
+      if (typeof adapters[source] !== 'function') return { source, status: 'unsupported', checked_at: checkedAt, records: [], error: 'Source adapter is unavailable' };
+      const value = await adapters[source]();
+      const result = Array.isArray(value) ? { records: value, status: 'ok' } : value;
+      if (!result || !Array.isArray(result.records) || !['ok', 'partial', 'unsupported', 'disabled', 'error', 'unauthorized'].includes(result.status)) throw new Error('Invalid source result');
+      if (result.records.length > limit) return { source, status: 'partial', checked_at: checkedAt, records: result.records.slice(0, limit), error: `Source inventory exceeded ${limit} records` };
+      return { ...result, source, checked_at: checkedAt };
+    } catch (error) { return { source, status: 'error', checked_at: checkedAt, records: [], error: `Source discovery failed${typeof error.code === 'string' && /^[A-Z_0-9]+$/.test(error.code) ? ` (${error.code})` : ''}` }; }
+  }));
+  return { automations: results.flatMap(result => result.records), coverage: results.map(({ records, ...coverage }) => coverage), checked_at: checkedAt };
+}