total-recall-brain 3.44.0 → 3.46.0

package/scaffold/.agent/skills/plugin/evals/cases/01-fabricated-seed.mjs

@@ -1,12 +1,14 @@
 /**
- * A card that seeds a telemetry reading in its constructor.
+ * A native Home that displays seeded telemetry.
  *
  * Observed: system-monitor held a literal hostname, uptime, load average and
  * `usedPercent: 99.1` before any command ran, with the comment
  * "// Retain fallback telemetry".
  */
-const CARD = `
-export class SeededCard extends HTMLElement {
+import correct from './06-correct-plugin.mjs';
+
+const HOME = `
+export class SeededHome extends HTMLElement {
   constructor() {
     super();
     this.sample = {
@@ -17,26 +19,21 @@ export class SeededCard extends HTMLElement {
       memory: { total: 17179869184, free: 159334400, usedPercent: 99.1 }
     };
   }
-  connectedCallback() { this.attachShadow({ mode: 'open' }) }
+  connectedCallback() {
+    const root = this.attachShadow({ mode: 'open' })
+    const value = document.createElement('output')
+    value.textContent = this.sample.memory.usedPercent + '%'
+    root.append(value)
+  }
 }
-customElements.define('tr-seeded-card', SeededCard)
+customElements.define('tr-example-home', SeededHome)
 `;
 
 export default {
+  ...correct,
   name: 'fabricated-seed',
-  why: 'a fabricated reading on the face is the most consequential kind of lie',
-  files: {
-    'plugin.json': JSON.stringify({
-      id: 'seeded', name: 'Seeded', version: '1.0.0', description: 'A plugin that fabricates a reading.',
-      reuse: { commands: [], owned: 'Displays its own telemetry reading.' },
-      cli: { command: 'seeded', handler: './cli.mjs', subcommands: [{ name: 'sample', effect: 'read' }] },
-      status: { command: 'sample', refresh_seconds: 30 },
-      branding: { color: '#059669' },
-      ui: { elements: [{ id: 'card', kind: 'card', tag: 'tr-seeded-card', module: 'ui/card.js' }] },
-    }, null, 2),
-    'cli.mjs': 'export default async function run() {}\n',
-    'ui/card.js': CARD,
-  },
+  why: 'Operators may act on a reading that no service returned.',
+  files: { ...correct.files, 'ui/home.js': HOME },
   expect: {
     fail: ['no seeded values'],
   },

package/scaffold/.agent/skills/plugin/evals/cases/02-reassuring-default.mjs

@@ -1,39 +1,34 @@
 /**
- * A card that reads fields its command does not return, and defaults to a
- * reassurance.
+ * A native Home that reports success when its command returns no health reading.
  *
  * Observed: a git card read `data.worktree.unstaged`, `data.synced` and
  * `data.upstream.status`, none of which the command returns, and defaulted to
  * "Up to date" — so a repository with three unpushed commits rendered clean.
  */
-const CARD = `
-export class ReassuringCard extends HTMLElement {
-  async read() {
-    const data = await this.host.run('audit', ['--json'])
-    const isClean = data.worktree?.clean ?? (data.clean ?? false)
-    const upstream = data.upstream?.status || (data.synced ? 'Synced' : 'Up to date')
-    this.shadowRoot.querySelector('.state').textContent = isClean ? 'Clean' : upstream
+import correct from './06-correct-plugin.mjs';
+
+const HOME = `
+export class ReassuringHome extends HTMLElement {
+  connectedCallback() {
+    const root = this.attachShadow({ mode: 'open' })
+    const output = document.createElement('output')
+    const button = document.createElement('button')
+    button.textContent = 'Read status'
+    button.addEventListener('click', async () => {
+      const data = await this.host.run('status', ['--json'])
+      output.textContent = data.health || 'Healthy'
+    })
+    root.append(output, button)
   }
-  connectedCallback() { this.attachShadow({ mode: 'open' }); this.read() }
 }
-customElements.define('tr-reassuring-card', ReassuringCard)
+customElements.define('tr-example-home', ReassuringHome)
 `;
 
 export default {
+  ...correct,
   name: 'reassuring-default',
-  why: 'an unverified reassurance is worse than no value, because it is believed',
-  files: {
-    'plugin.json': JSON.stringify({
-      id: 'reassuring', name: 'Reassuring', version: '1.0.0', description: 'A plugin that reassures without checking.',
-      reuse: { commands: [], owned: 'Displays the status returned by its own command.' },
-      cli: { command: 'reassuring', handler: './cli.mjs', subcommands: [{ name: 'audit', effect: 'read' }] },
-      status: { command: 'audit', refresh_seconds: 30 },
-      branding: { color: '#b45309' },
-      ui: { elements: [{ id: 'card', kind: 'card', tag: 'tr-reassuring-card', module: 'ui/card.js' }] },
-    }, null, 2),
-    'cli.mjs': 'export default async function run() {}\n',
-    'ui/card.js': CARD,
-  },
+  why: 'An unverified success can hide a failed read.',
+  files: { ...correct.files, 'ui/home.js': HOME },
   expect: {
     fail: ['no reassuring default'],
   },

package/scaffold/.agent/skills/plugin/evals/cases/03-declared-template.mjs

@@ -1,33 +1,25 @@
 /**
- * A manifest that declares a shared layout template.
+ * A valid native Home package that still ships legacy presentation artifacts.
  *
  * Observed: core enforced a closed allowlist of seven layouts, and 24 of 34
  * plugins shared a byte-identical card signature.
  */
-const CARD = `
-export class TemplatedCard extends HTMLElement {
-  connectedCallback() { this.attachShadow({ mode: 'open' }) }
-}
-customElements.define('tr-templated-card', TemplatedCard)
-`;
+import correct from './06-correct-plugin.mjs';
+
+const manifest = JSON.parse(correct.files['plugin.json']);
+manifest.card_layout = { template: 'ledger', regions: [{ widget: 'status' }] };
 
 export default {
+  ...correct,
   name: 'declared-template',
-  why: 'a shared layout vocabulary is the mechanism that made unrelated plugins look alike',
+  why: 'Keeping the legacy template or asset ships an unsupported presentation alongside native Home.',
+  flags: ['--manifest'],
   files: {
-    'plugin.json': JSON.stringify({
-      id: 'templated', name: 'Templated', version: '1.0.0', description: 'A plugin that declares a layout template.',
-      reuse: { commands: [], owned: 'Displays the plugin-specific view.' },
-      cli: { command: 'templated', handler: './cli.mjs', subcommands: [{ name: 'status', effect: 'read' }] },
-      status: { command: 'status', refresh_seconds: 30 },
-      branding: { color: '#475569' },
-      card_layout: { template: 'ledger', regions: [{ widget: 'status' }, { widget: 'table', source: { command: 'status' } }] },
-      ui: { elements: [{ id: 'card', kind: 'card', tag: 'tr-templated-card', module: 'ui/card.js' }] },
-    }, null, 2),
-    'cli.mjs': 'export default async function run() {}\n',
-    'ui/card.js': CARD,
+    ...correct.files,
+    'plugin.json': JSON.stringify(manifest),
+    'ui/card.js': "customElements.define('tr-example-card', class extends HTMLElement {})\n",
   },
   expect: {
-    fail: ['no template', 'card_layout'],
+    fail: ['contract', 'native presentation only'],
   },
 };

package/scaffold/.agent/skills/plugin/evals/cases/04-home-collects-credential.mjs

@@ -0,0 +1,35 @@
+/**
+ * A native Home that collects an API key in a password field.
+ *
+ * Observed: the scaffolder generated exactly this, dispatching the raw value
+ * as a `save-token` event — a second credential store and a leak surface.
+ */
+import correct from './06-correct-plugin.mjs';
+
+const HOME = `
+export class CollectingHome extends HTMLElement {
+  connectedCallback() {
+    const root = this.attachShadow({ mode: 'open' })
+    const input = document.createElement('input')
+    input.type = 'password'
+    input.setAttribute('aria-label', 'API key')
+    const button = document.createElement('button')
+    button.textContent = 'Save'
+    button.addEventListener('click', () => {
+      this.dispatchEvent(new CustomEvent('save-token', { detail: { token: input.value }, bubbles: true }))
+    })
+    root.append(input, button)
+  }
+}
+customElements.define('tr-example-home', CollectingHome)
+`;
+
+export default {
+  ...correct,
+  name: 'home-collects-credential',
+  why: 'An unapproved password input can expose a service key to a plugin event handler.',
+  files: { ...correct.files, 'ui/home.js': HOME },
+  expect: {
+    fail: ['credential interface'],
+  },
+};

package/scaffold/.agent/skills/plugin/evals/cases/05-host-leak-in-scaffold.mjs

@@ -5,51 +5,31 @@
  * credential read — failing with `Auth credential read failed` once it was
  * absent — and carried `https://example.com/checkout/success`.
  */
-const CARD = `
-export class LeakyCard extends HTMLElement {
-  connectedCallback() { this.attachShadow({ mode: 'open' }) }
-}
-customElements.define('tr-leaky-card', LeakyCard)
-`;
+import correct from './06-correct-plugin.mjs';
 
 const CAPABILITY = `
 import { spawnSync } from 'node:child_process'
 
 function secret() {
   const binary = process.env.TOTAL_RECALL_BIN || 'total-recall'
-  const out = spawnSync(binary, ['auth', 'secret', 'get', 'LEAKY_API_KEY', '--json'])
+  const out = spawnSync(binary, ['auth', 'secret', 'get', 'EXAMPLE_API_KEY', '--json'])
   return JSON.parse(out.stdout).value
 }
 
-export async function createCheckout({ amount }) {
-  const successUrl = 'https://example.com/checkout/success'
-  const res = await fetch('https://api.example.com/v1/sessions', {
-    method: 'POST',
+export async function readStatus({ endpoint }) {
+  const url = endpoint ? endpoint + '/status' : 'https://example.com/status'
+  const res = await fetch(url, {
     headers: { Authorization: 'Bearer ' + secret() },
-    body: JSON.stringify({ amount, success_url: successUrl }),
   })
   return res.json()
 }
 `;
 
 export default {
+  ...correct,
   name: 'host-leak-in-scaffold',
-  why: 'a scaffold is laid into an application that has no Total Recall, and no placeholders',
-  files: {
-    'plugin.json': JSON.stringify({
-      id: 'leaky', name: 'Leaky', version: '1.0.0', description: 'A plugin whose capability depends on the host.',
-      reuse: { commands: ['total-recall auth secret'], owned: 'Submits a checkout request to the service.' },
-      cli: { command: 'leaky', handler: './cli.mjs', subcommands: [{ name: 'status', effect: 'read' }] },
-      capability: { entry: 'capability/index.mjs', exports: ['createCheckout'] },
-      secrets: [{ key: 'LEAKY_API_KEY', description: 'Service key', required: true }],
-      status: { command: 'status', refresh_seconds: 30 },
-      branding: { color: '#b45309' },
-      ui: { elements: [{ id: 'card', kind: 'card', tag: 'tr-leaky-card', module: 'ui/card.js' }] },
-    }, null, 2),
-    'cli.mjs': 'export default async function run() {}\n',
-    'ui/card.js': CARD,
-    'capability/index.mjs': CAPABILITY,
-  },
+  why: 'A standalone capability must run without Total Recall and use the caller’s endpoint.',
+  files: { ...correct.files, 'capability/index.mjs': CAPABILITY },
   expect: {
     fail: ['no Total Recall dependency', 'no placeholder values'],
   },

package/scaffold/.agent/skills/plugin/evals/cases/06-correct-plugin.mjs

@@ -1,56 +1,69 @@
 /**
- * A plugin that satisfies the recipe: one bespoke face, real data only,
- * credentials through auth, values the caller supplies.
+ * A plugin with native Home, an SSSS block, and Auth-managed credentials.
  *
  * This is the positive case. It must produce no failures.
  */
-const CARD = `
-const DASH = '\\u2014'
-
-export class ExampleCard extends HTMLElement {
-  constructor() {
-    super()
-    this.state = 'idle'
-    this.reading = null
-    this.lastError = null
-    this.lastAttempt = null
-    this.screen = 'status'
-  }
-  get screens() { return [{ id: 'status', label: 'Status' }] }
+const HOME = `
+export class ExampleHome extends HTMLElement {
   connectedCallback() {
-    if (!this.shadowRoot) this.attachShadow({ mode: 'open' })
-    this.render()
-    void this.read()
+    if (this.shadowRoot) return
+    const root = this.attachShadow({ mode: 'open' })
+    root.innerHTML =
+      '<style>:host{display:block;color:var(--colors-ink);background:var(--colors-paper);padding:16px}' +
+      'button{min-height:44px}</style>' +
+      '<h2>Service memory</h2><output aria-label="Memory in use">No reading yet</output>' +
+      '<p role="status"></p><button type="button">Read memory use</button>'
+    root.querySelector('button').addEventListener('click', () => this.read())
   }
+
   async read() {
-    this.lastAttempt = new Date()
+    const value = this.shadowRoot.querySelector('output')
+    const note = this.shadowRoot.querySelector('[role="status"]')
+    const time = new Date().toLocaleTimeString()
     try {
       const payload = await this.host.run('status', ['--json'])
-      this.reading = payload && typeof payload === 'object' ? payload : null
-      if (!this.reading) throw new Error('The status command returned nothing readable')
-      this.lastError = null
-      this.state = 'ready'
-    } catch (err) {
-      this.reading = null
-      this.lastError = err && err.message ? err.message : String(err)
-      this.state = 'error'
-    } finally {
-      this.paint()
+      if (payload?.ok !== true || !Number.isFinite(payload.usedPercent)) throw new Error('No readable memory measurement')
+      value.textContent = payload.usedPercent + '%'
+      note.textContent = 'Read at ' + time
+    } catch {
+      value.textContent = 'Unavailable'
+      note.textContent = 'Could not read memory use at ' + time
     }
   }
-  paint() {
-    const value = this.shadowRoot.querySelector('#value')
-    const note = this.shadowRoot.querySelector('#note')
-    if (value) value.textContent = this.reading ? String(this.reading.usedPercent ?? DASH) : DASH
-    if (note) note.textContent = this.lastError ? this.lastError + ' at ' + this.lastAttempt.toLocaleTimeString() : ''
-  }
-  render() {
-    this.shadowRoot.innerHTML = '<style>:host{display:block;color:var(--text-primary);border:1px solid var(--border);padding:14px}' +
-      'button{min-height:44px}</style>' +
-      '<h2>Example</h2><span id="value">' + DASH + '</span><p id="note"></p><button type="button">Read</button>'
-  }
 }
-customElements.define('tr-example-card', ExampleCard)
+customElements.define('tr-example-home', ExampleHome)
+`;
+
+const DESIGN = `---
+colors:
+  ink: "#13241f"
+  paper: "#ecf5f0"
+  accent: "#047857"
+---
+# Service memory
+
+Use a quiet green surface for the memory readout. Keep the last attempt beside the measured value.
+`;
+
+const STATUS_BLOCK = `---
+type: ui-chunk:chunk
+plugin: example
+id: memory-use
+title: Service memory use
+description: Reads memory use from the configured service and displays the returned percentage.
+timestamp: '2026-11-08T00:00:00Z'
+intents:
+  - inspect service memory use
+surfaces: [page]
+operations: [status]
+data:
+  - 'status:/usedPercent'
+panel: home
+---
+<section>
+  <h2>Service memory use</h2>
+  <p>Read the current percentage from the service in the live panel.</p>
+</section>
 `;
 
 const CAPABILITY = `
@@ -62,6 +75,28 @@ export async function readStatus({ endpoint, apiKey, fetchImpl = fetch }) {
 }
 `;
 
+const CLI = `
+import { readAuthSecret } from './auth-client.mjs'
+import { readStatus } from './capability/index.mjs'
+
+export default async function run([operation]) {
+  if (operation !== 'status') {
+    process.exitCode = 1
+    return console.log(JSON.stringify({ ok: false, error: 'Use the status operation' }))
+  }
+  try {
+    const apiKey = readAuthSecret('EXAMPLE_API_KEY')
+    if (!apiKey) throw new Error('Service key unavailable')
+    const status = await readStatus({ endpoint: process.env.EXAMPLE_ENDPOINT, apiKey })
+    if (!Number.isFinite(status.usedPercent)) throw new Error('Invalid memory reading')
+    console.log(JSON.stringify({ ok: true, usedPercent: status.usedPercent }))
+  } catch {
+    process.exitCode = 1
+    console.log(JSON.stringify({ ok: false, error: 'Could not read service memory use' }))
+  }
+}
+`;
+
 export default {
   name: 'correct-plugin',
   why: 'the recipe must accept a plugin that follows it, or it is not a recipe',
@@ -71,23 +106,26 @@ export default {
       reuse: { commands: ['total-recall auth secret'], owned: 'Reads the service-specific status endpoint.' },
       cli: { command: 'example', handler: './cli.mjs', subcommands: [
         { name: 'status', description: 'Read current status', effect: 'read', output: 'json' },
-        { name: 'set-key', description: 'Store the service key', effect: 'write',
-          args: [{ name: 'apiKey', label: 'API key', type: 'string', secret: true }] },
       ] },
       capability: { entry: 'capability/index.mjs', exports: ['readStatus'] },
       secrets: [{ key: 'EXAMPLE_API_KEY', description: 'Reads the service', required: true }],
+      auth: { plugin: 'auth', methods: ['passkey'], session_verification: true },
       status: { command: 'status', refresh_seconds: 30 },
       distribution: { tier: 'official', license: 'open' },
       branding: { name: 'Example', color: '#047857', accent: '#10b981', font: 'inter', density: 'comfortable', radius: 'sm', header: 'plain' },
-      ui: { design_tokens: 'ui/DESIGN.md', elements: [{ id: 'card', kind: 'card', tag: 'tr-example-card', module: 'ui/card.js' }] },
+      ui: { home: 'home', design_tokens: 'DESIGN.md', elements: [
+        { id: 'home', kind: 'panel', tag: 'tr-example-home', module: 'ui/home.js' },
+      ] },
     }, null, 2),
-    'cli.mjs': "import { readAuthSecret } from './auth-client.mjs'\nimport { readStatus } from './capability/index.mjs'\nexport default async function run() {\n  return readStatus({ endpoint: process.env.EXAMPLE_ENDPOINT, apiKey: readAuthSecret('EXAMPLE_API_KEY') })\n}\n",
+    'cli.mjs': CLI,
     'auth-client.mjs': "/** Auth-only transport: the plugin holds no credential of its own. */\nimport { spawnSync } from 'node:child_process'\nexport function readAuthSecret(key) {\n  const out = spawnSync('total-recall', ['auth', 'secret', 'get', key, '--json'], { encoding: 'utf8' })\n  const parsed = JSON.parse(out.stdout)\n  return parsed.found ? parsed.value : ''\n}\n",
-    'ui/DESIGN.md': '# DESIGN.md — Example\n\n```yaml\ntokens:\n  brand-name: "Example"\n  color-primary: "#047857"\n```\n\nOne screen: the status reading.\n',
-    'ui/card.js': CARD,
+    'DESIGN.md': DESIGN,
+    'ui/home.js': HOME,
+    'ui/chunks/memory-use.md': STATUS_BLOCK,
     'capability/index.mjs': CAPABILITY,
   },
   expect: {
     fail: [],
+    pass: ['Bundled Auth', 'Home element', 'Owner design', 'SSSS block', 'Operation coverage', 'owner commands resolve', 'loads with Total Recall absent'],
   },
 };

package/scaffold/.agent/skills/plugin/evals/run.mjs

@@ -9,8 +9,7 @@
  *
  *   node evals/run.mjs [--case <name>] [--json] [--keep]
  *
- * A case passes when record.mjs reports exactly the failures the case expects:
- * an eval that passes because the checker looks at nothing is not evidence.
+ * A case requires the exact set of failure check names and any declared passes.
  */
 import fs from 'node:fs'
 import os from 'node:os'
@@ -49,9 +48,9 @@ function materialise(spec, dir) {
   }
 }
 
-function runRecord(dir) {
+function runRecord(dir, flags) {
   try {
-    const out = execFileSync(process.execPath, [RECORD, dir, '--json'], { encoding: 'utf8', timeout: 60000 })
+    const out = execFileSync(process.execPath, [RECORD, dir, '--json', ...flags], { encoding: 'utf8', timeout: 60000 })
     return { code: 0, report: JSON.parse(out) }
   } catch (err) {
     // record.mjs exits non-zero when it finds failures; the JSON is still valid.
@@ -67,7 +66,7 @@ for (const spec of cases) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), `plugin-eval-${spec.name}-`))
   try {
     materialise(spec, dir)
-    const { report } = runRecord(dir)
+    const { report } = runRecord(dir, spec.flags ?? [])
 
     if (!report) {
       results.push({ name: spec.name, ok: false, reason: 'record.mjs produced no JSON' })
@@ -75,24 +74,24 @@ for (const spec of cases) {
     }
 
     const failures = report.results.filter((r) => r.level === 'FAIL')
-    const failureText = failures.map((f) => `${f.check}: ${f.detail}`).join(' | ')
-    const expected = spec.expect.fail || []
-
-    const missing = expected.filter((want) => !failureText.includes(want.split(':')[0].trim()))
-    const unexpected = expected.length === 0
-      ? failures.map((f) => `${f.check}: ${f.detail}`)
-      : []
-
-    const ok = missing.length === 0 && unexpected.length === 0
+    const failedChecks = new Set(failures.map((f) => f.check))
+    const passedChecks = new Set(report.results.filter((r) => r.level === 'PASS').map((r) => r.check))
+    const expected = spec.expect.fail ?? []
+    const missing = expected.filter((check) => !failedChecks.has(check))
+    const unexpected = failures.filter((f) => !expected.includes(f.check))
+    const missingPasses = (spec.expect.pass ?? []).filter((check) => !passedChecks.has(check))
+    const reasons = [
+      missing.length ? `checker missed: ${missing.join(', ')}` : null,
+      unexpected.length ? `unexpected failures: ${unexpected.map((f) => f.check).join(', ')}` : null,
+      missingPasses.length ? `missing passes: ${missingPasses.join(', ')}` : null,
+    ].filter(Boolean)
     results.push({
       name: spec.name,
-      ok,
+      ok: reasons.length === 0,
       why: spec.why,
       expected,
       found: failures.map((f) => `${f.check} — ${f.detail}`),
-      reason: ok ? null
-        : missing.length ? `checker missed: ${missing.join(', ')}`
-          : `unexpected failures: ${unexpected.join(' | ')}`,
+      reason: reasons.join(' | ') || null,
     })
   } finally {
     if (!keep) fs.rmSync(dir, { recursive: true, force: true })

package/scaffold/.agent/skills/plugin/prompts/05-credentials.md

@@ -14,7 +14,7 @@ Resolve it only through `total-recall auth secret`. The plugin has no store of i
 
 **Settings.** Every setting goes in `configuration.fields` with its type and default. Field keys are camelCase and may not contain `password`, `secret`, `apiKey` or `token` — those belong in `secrets`.
 
-**The card** reports a credential as *present* or *missing*. It never renders a value, and never renders an input that accepts one. To set a key, the card hands over the command:
+**The Home** reports a credential as *present* or *missing*. It never renders a value, and never renders an input that accepts one. To set a key, the Home hands over the command:
 
 ```
 total-recall auth secret set SERVICE_API_KEY --stdin
@@ -23,14 +23,14 @@ total-recall auth secret set SERVICE_API_KEY --stdin
 ## Correct means
 
 - Exactly one credential path exists, and it is auth.
-- The card has no code path that can receive a key value, so it cannot leak one.
+- The Home has no code path that can receive a key value, so it cannot leak one.
 - A setting a user must change is declared, so it is visible rather than buried in code.
 
-## Why the card must not collect keys
+## Why the Home must not collect keys
 
 The rule is not bureaucracy: one store means one rotation path and one audit trail. A per-plugin key screen violates it even when it writes to the same store, because it makes the plugin the place an operator thinks of when a key must change. It also creates a receive path for the secret inside plugin code, which is a leak surface that would otherwise not exist.
 
-Evidence: a scaffolded panel rendered `<input type="password">` and dispatched the raw value to the host; a real card built three such screens.
+Evidence: a scaffolded panel rendered `<input type="password">` and dispatched the raw value to the host; another interface built three such screens.
 
 ## Check
 

package/scaffold/.agent/skills/plugin/prompts/07-scaffold.md

@@ -13,7 +13,7 @@ tr-plugin-<id>/
   capability/     ← the scaffold payload: exported functions, no host
     index.mjs
   cli.mjs         ← the Total Recall entry: parse argv, resolve credentials, call capability/
-  ui/             ← the face; Total Recall only
+  ui/             ← the Home; Total Recall only
   test/
 ```
 
@@ -33,7 +33,7 @@ The capability must be:
 - **returning data**, not printing text
 - **throwing errors**, not setting `process.exitCode`
 - **free of Total Recall** — no `total-recall`, no `TOTAL_RECALL_BIN`, no auth store
-- **free of UI** — no card, no `DESIGN.md`, no logo
+- **free of UI** — keep the Home, `DESIGN.md` and logo in the plugin
 
 Write `BRICK.md`: what to import, what to pass, where credentials come from, what comes back.
 

package/scaffold/.agent/skills/plugin/prompts/08-verify.md

@@ -15,10 +15,10 @@ Then work the list, and record the actual outcome of each. Do not tick a box you
 - [ ] Each shared dependency uses its existing owner command or a vendored brick. The reuse gate passes and the workflow tests exercise the declared interfaces.
 - [ ] Every operation has typed arguments and an effect.
 - [ ] `--json` works on every subcommand; failures exit non-zero; `--help` works without credentials.
-- [ ] No secret value appears in `argv`, stdout, stderr, a log or the card state.
-- [ ] The card declares exactly one element of kind `card`, and no `card_layout`.
-- [ ] Every value on the card came from a command; failures render as failures; unknown values render an em dash.
-- [ ] The card renders on the real dark dashboard at 360, 768 and 1280 px with no horizontal overflow.
+- [ ] No secret value appears in `argv`, stdout, stderr, logs or UI state.
+- [ ] The Home and its bespoke design are declared. The owner inventory and the operation and data bindings cover the same workflows.
+- [ ] Every displayed value came from an actual operation. Failures and unknown values are explicit.
+- [ ] Home and its assembled blocks render at 360, 768 and 1280 px with no horizontal overflow.
 - [ ] Every state renders: credential present, missing, provider unreachable, rejected call, empty, stale.
 - [ ] The suite passes — per-subcommand unit tests including failure paths, a manifest test, a secrets test.
 - [ ] No seeded value, placeholder or example default survives anywhere in the plugin.

package/scaffold/.agent/skills/plugin/references/anti-patterns.md

@@ -12,7 +12,7 @@ Every entry below was observed in a real plugin in this ecosystem, with the evid
 
 **Hard-coded claims.** A header rendered `Stripe API (Live Secret)` and `HMAC-SHA256 Verified` with no command behind either. A merchant with no key and no webhook secret saw an identical card.
 
-**Fixed text where a command belongs.** `card_face.metrics` held literal strings such as `ONLINE`. The validator warns on it; the card must never carry it.
+**Fixed text where a command belongs.** `card_face.metrics` held literal strings such as `ONLINE`. The validator rejects it; the card must never carry it.
 
 > **Rule.** A value appears only if a command or the host returned it. If a source fails, show the failure and when it was last attempted.
 
@@ -34,7 +34,7 @@ Related: a missing upstream comparison becoming `unpushedCommits: 0` instead of
 - A card built three separate key-entry screens.
 - A plugin's error text told the *application's* users to run a Total Recall command.
 
-> **Rule.** One credential path exists in the whole plugin, and it is `total-recall auth secret`. The card reports present or missing, never renders a value, and never collects one.
+> **Rule.** One credential path exists in the whole plugin, and it is `total-recall auth secret`. The Home reports present or missing, never renders a value, and never collects one.
 
 ## Templates
 

package/scaffold/.agent/skills/plugin/references/generative-home.md

@@ -0,0 +1,38 @@
+# Generative plugin Home
+
+1. Inventory the owner with `total-recall plugin info <id>`, `total-recall plugin library --plugin <id> --json` and its existing provider adapters. Identify the operator's primary workflows, useful readouts, and the exact operation and response field for each. Record expected coverage in the owner's plan.
+2. Write the root `DESIGN.md` around those workflows. Describe the plugin's visual identity, typography, layout, motion, accessibility, and useful unavailable states. Set `ui.design_tokens` to `DESIGN.md` and `ui.home` to the ID of the declared native Home element. That element should accomplish a meaningful workflow and show real state. A command listing alone is a fallback.
+3. Author independent HTML blocks at `ui/chunks/<id>.md`. Use `type: ui-chunk:chunk`, `plugin`, `id`, `title`, `description`, an ISO `timestamp`, `intents`, and `surfaces`. Include `page` for Home. Bind `operations` to exact manifest command names. Bind `data` to exact output fields using `operation:/json/pointer`. Verify each pointer against real JSON output. An optional `panel` references a declared native element that renders live data or actions through the authenticated command bridge. Package the design, the blocks, and any native modules.
+4. Use CSS and accessible HTML for presentation. Declare browser-safe operations and their argument types so a block can accept input and run the real owner command in place. For specialized controls, bind the native panel and keep its effect and permission checks. Mutations require deliberate operator input. Keep user records, secrets, executable HTML, and raw provider output out of Decision requests. Send only the approved intent and eligible block metadata. Validate every returned ID before composing the page. Keep the owner Home useful if Decision abstains or is unavailable.
+5. Run `node <skill>/scripts/record.mjs . --home` and compare the bindings from `total-recall plugin chunks coverage --plugin <id> --json` with the owner inventory. A valid schema and a keyword fallback establish local coverage only. Verify a successful authorized Decision request separately when configured, plus the rendered Home and the main workflow in an isolated preview.
+
+For an operation that can return a credential, declare `sensitive_output: true` in its CLI metadata. A block may document the operation. Leave its private response fields out of `data` and route credential work through the owning CLI or Auth controls.
+
+Reserve host file arguments with `terminal_only_args`. Use `terminal_only: true` for a wholly terminal operation, including a positional host path or a foreground server. Its safe response fields can stay indexed. Use `sensitive_output` when the result itself carries credentials or private pairing material.
+
+## Live design
+
+Save design tokens in the YAML frontmatter of `DESIGN.md`. The open Home reads new revisions automatically and applies their CSS while retaining the selected block order. Bind colors, typography, spacing and radii with CSS custom properties. A chunk can opt into a named style using `data-design-component="component-name"`. Shadow DOM panels inherit the published CSS variables and can use `--component-<name>-<property>` in their styles.
+
+For a page region that should grow as the owner adds component definitions, put one owner-designed root element inside `<template data-design-components>` in a chunk. The renderer creates a copy for each supported component in the design. Add `data-design-label` to a text element to show the component name. Reserve this for a region where every definition belongs, such as a reusable design library. Keep operations, live data and HTML structure in the owner panel and SSSS blocks.
+
+Verify a token edit and a new named component with Home open, then save malformed YAML and confirm the last valid design remains. A design save applies locally. Use Decision explicitly when the context calls for a different selection of blocks.
+
+## Agent tool
+
+Use `total-recall decision compose --plugin <id> --intent "<short approved task context>" --json` to publish an agent-selected page to the authenticated dashboard. The command returns the path and ordered SSSS block IDs. The open Home picks up the publication automatically. A provider abstention leaves the current page in place. Avoid adding prompts or provider controls to the Home.
+
+When the user names a brain, pass `--brain <registered ID>` to compose, workspace search, and block add. Use the same ID throughout. In a multi-brain dashboard, choose one destination for publication. The server verifies the selected brain and the enabled owner before exposing or publishing a block.
+
+Declare the bundled Auth plugin for host session verification. Read credential status through Auth and use the installed owning plugin for each other shared capability. A local plugin may use Auth for dashboard access without declaring an external credential.
+
+List reused installed operations in `reuse.commands` and state the plugin's own responsibility in `reuse.owned`. Use `requires` for vendored brick IDs. Validate the package against the Total Recall binary that runs the preview. Set `TOTAL_RECALL_BIN` to that binary if your terminal resolves a different installation.
+
+## Author and place a block
+
+1. Search the selected brain with `total-recall plugin chunks "<intent>" --workspace --surface page --brain <brain> --json`. Use blocks from any enabled plugin that serves the task. An agent can author any missing view or workflow as an SSSS block. Ship broadly useful defaults in the owner repository and publish task-specific views into the selected brain's pool.
+2. For a new pool block, author `<id>.md` with the enabled owner as `plugin`, a unique `id`, verified operation/data bindings where applicable, and `page` in `surfaces`. Use the owner design or the user's approved design. Bind a native panel for real interactive behavior. Run `total-recall plugin chunks add <id.md> --plugin <owner> --brain <brain> --json`. Add validates the SSSS document against its installed owner and returns the stable key. Read it back with `total-recall plugin chunks get <owner>:<id> --workspace --surface page --brain <brain> --json`.
+3. For contextual composition, use `total-recall decision compose --plugin <owner> --intent "<approved context>" --page <id> --title "<title>" --brain <brain> --json`. Jev selects from the published pool. Open the returned path or use Saved pages in the left drawer.
+4. For exact placement, supply the desired ordered keys with `total-recall plugin chunks page <id> <owner>:<block> <other-owner>:<block> --title "<title>" --brain <brain> --json`. For an existing page, read it with `total-recall plugin chunks page <id> --brain <brain> --json` and submit the complete ordered list with `--revision <current-version>` in place of `--title`. Retain the blocks the user wants to keep. A revision conflict means reread the page before retrying. Verify the stored order and render the page.
+
+Keep secret values and private records out of block HTML and routing metadata. Use real owner data and actions. If the owner has no operation for the requested behavior, implement and verify the missing capability at the owner before calling the view functional.