rewritable 0.13.0 → 0.15.0

package/README.md

@@ -261,6 +261,19 @@ rwa host notes.html --url https://host.example --json   # {"id":"…","token":"
 
 This command is **network-bearing** (like `rwa clone` / `rwa publish-site`), so the offline-first rule does not apply to it.
 
+### `rwa intelligence new <role>`
+
+Mint a **droppable intelligence** — a signed `rwa-agent/1` role packaged as a *carrier* rewritable you can drop onto another rewritable to retune its ⌘K editor (intelligence/0.2). It generates a fresh Ed25519 keypair, signs the role, and scaffolds a self-describing `skill-host` carrier. The **private key** is written to a sibling `<name>.key.json`, kept out of the carrier — keep it to publish updates under the same author identity.
+
+```
+rwa intelligence new concise \
+  --prompt "Tighten prose: shorter sentences, fewer hedges, meaning preserved." \
+  --model anthropic/claude-sonnet-4-6 --backend openrouter \
+  --affinity document,presentation
+```
+
+Flags: `--prompt` (required — the role's system prompt), `--description`, `--model` / `--backend` (a *recommended* model offered on activation behind consent — never auto-applied, never carries your key), `--affinity` (comma-separated document kinds; advisory — a mismatch only warns), `--vault` (comma-separated namespaces the role may reach), `--out <path>`, `--force`. Offline; the carrier holds only the public key + signature.
+
 ### `rwa skin <path> <name>`
 
 Pick a **named look** for a rewritable instead of hand-styling it from the blank lens. A skin is one self-contained `<style data-rwa-skin="NAME">` block — system fonts only, no web fonts or remote assets — that the command splices into the **document body**. So it commits with the document, ships inside the exported `.html`, survives sharing, and one in-browser undo (`⌘Z`) reverts it. Five presets ship today: `notion-clean`, `linear-dark`, `editorial-serif`, `stripe-docs`, `terminal-mono` (clean · dark · editorial · docs · terminal).

package/bin/rwa.mjs

@@ -728,6 +728,36 @@ function detectProductKind(fileText) {
     // `rwa skill publish <file.rwa-skill.json> [--url base] [--json]` — publish a SIGNED skill
     // envelope to the marketplace index (POST /skills/publish, I6 §11). The envelope is already
     // signed (no key needed). Online by design; exit 4 labeled `publish_error` (like `publish`).
+    // `rwa intelligence new <role> --prompt "..." [--description ..] [--model id] [--backend name]
+    //  [--affinity kind,kind] [--vault ns,ns] [--out file] [--force]` — I-C (intelligence/0.2 §6):
+    // mint a signed rwa-agent/1 role and scaffold a carrier rewritable (private key → sibling file).
+    if (verb === 'intelligence') {
+      const sub = rest[0];
+      if (sub !== 'new') {
+        process.stderr.write("rwa intelligence: unknown subcommand '" + (sub || '') + "' (try: rwa intelligence new <role> --prompt \"...\")\n");
+        process.exitCode = 1;
+        return;
+      }
+      const subRest = rest.slice(1);
+      const valFlags = ['--prompt', '--description', '--model', '--backend', '--affinity', '--vault', '--out'];
+      const role = subRest.find((a, i) => !a.startsWith('-') && !valFlags.includes(subRest[i - 1]));
+      const g = (n) => getFlag(n, subRest).value;
+      const list = (n) => { const v = g(n); return v ? v.split(',').map(s => s.trim()).filter(Boolean) : []; };
+      try {
+        const { intelligenceNewCmd } = await import('../src/intelligence.mjs');
+        await intelligenceNewCmd({
+          role, prompt: g('--prompt'), description: g('--description'),
+          model: g('--model'), backend: g('--backend'),
+          affinity: list('--affinity'), vault: list('--vault'),
+          outPath: g('--out'), force: subRest.includes('--force') || subRest.includes('-f'),
+        });
+      } catch (e) {
+        process.stderr.write('rwa intelligence: ' + ((e && e.message) || e) + '\n');
+        process.exitCode = (e && e.exitCode) || 1;
+      }
+      return;
+    }
+
     if (verb === 'skill') {
       const sub = rest[0];
       const subRest = rest.slice(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rewritable",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "CLI for re-writeable: emit and import single-file rwa documents.",
   "type": "module",
   "bin": {

package/seeds/rewritable.html

@@ -2326,13 +2326,23 @@ async function renderActionsModePanel(panel) {
   // recommended model (intelligence/0.2 I-A). A verified role can be activated; unverified cannot.
   const agentList = (typeof runtimeListAgents === 'function') ? runtimeListAgents() : [];
   const activeRole = (runtimeAgentActive() || {}).role || null;
+  const advisorSet = (typeof runtimeListAdvisors === 'function') ? runtimeListAdvisors() : [];
+  const advisorFull = advisorSet.length >= 3;
   const agentRows = agentList.length ? agentList.map(a => {
     const isActive = a.role === activeRole;
-    const meta = (a.verified ? 'verified' : 'unverified') + (isActive ? ' · active' : '');
-    const btn = !a.verified ? '' : (isActive
-      ? '<button type="button" data-agent-off="1">Deactivate</button>'
-      : '<button type="button" data-agent-on="' + escRuntimeHtml(a.role) + '">Activate</button>');
-    return '<div class="rwa-mode-row"><div><div class="rwa-mode-title">' + escRuntimeHtml(a.role) + '</div><div class="rwa-mode-meta">' + escRuntimeHtml('intelligence · ' + meta) + '</div></div>' + btn + '</div>';
+    const isAdvisor = advisorSet.indexOf(a.role) >= 0;
+    const state = isActive ? 'primary' : (isAdvisor ? 'advisor' : '');
+    const aff = (a.affinity && a.affinity.length) ? ' · for ' + a.affinity.join('/') : '';
+    const meta = (a.verified ? 'verified' : 'unverified') + (state ? ' · ' + state : '') + aff;
+    let btns = '';
+    if (a.verified) {
+      const r = escRuntimeHtml(a.role);
+      if (isActive) btns = '<button type="button" data-agent-off="1">Deactivate</button>';
+      else if (isAdvisor) btns = '<button type="button" data-agent-advoff="' + r + '">Remove advisor</button>';
+      else btns = '<button type="button" data-agent-on="' + r + '">Activate</button>'
+        + (advisorFull ? '<button type="button" disabled title="advisor limit reached">Add advisor</button>' : '<button type="button" data-agent-advon="' + r + '">Add advisor</button>');
+    }
+    return '<div class="rwa-mode-row"><div><div class="rwa-mode-title">' + escRuntimeHtml(a.role) + '</div><div class="rwa-mode-meta">' + escRuntimeHtml('intelligence · ' + meta) + '</div></div>' + btns + '</div>';
   }).join('') : '<div class="rwa-mode-empty">No intelligences installed.</div>';
   panel.innerHTML = [
     '<div class="rwa-mode-section">',
@@ -2366,12 +2376,20 @@ async function renderActionsModePanel(panel) {
     btn.addEventListener('click', () => runtimeSetMode('skills'));
   });
   panel.querySelectorAll('[data-agent-on]').forEach(btn => btn.addEventListener('click', () => {
-    try { runtimeActivateAgent(btn.getAttribute('data-agent-on')); } // setActive + offer recommended model
+    const role = btn.getAttribute('data-agent-on');
+    try { runtimeActivateAgent(role); const aw = affinityWarning(role); if (aw && typeof setStatus === 'function') setStatus('', aw); } // setActive + offer model; advisory affinity warn (I-D)
     catch (e) { if (typeof setStatus === 'function') setStatus('err', '✗ ' + (e && (e.code || e.message))); }
     renderActionsModePanel(panel);
   }));
   const agentOff = panel.querySelector('[data-agent-off]');
   if (agentOff) agentOff.addEventListener('click', () => { runtimeSetActiveAgent(null); renderActionsModePanel(panel); });
+  panel.querySelectorAll('[data-agent-advon]').forEach(btn => btn.addEventListener('click', () => {
+    const role = btn.getAttribute('data-agent-advon');
+    try { runtimeAddAdvisor(role); const aw = affinityWarning(role); if (aw && typeof setStatus === 'function') setStatus('', aw); } // I-E: layer an advisory lens; I-D affinity warn
+    catch (e) { if (typeof setStatus === 'function') setStatus('err', '✗ ' + (e && (e.code || e.message))); }
+    renderActionsModePanel(panel);
+  }));
+  panel.querySelectorAll('[data-agent-advoff]').forEach(btn => btn.addEventListener('click', () => { runtimeRemoveAdvisor(btn.getAttribute('data-agent-advoff')); renderActionsModePanel(panel); }));
 }
 
 // ─── Agent (rwa-edit/1) ─────────────────────────────────────────────
@@ -5613,11 +5631,26 @@ function getActiveActor() {
 // system_prompt swaps the per-kind FRAMING; the shared SYSTEM_PROMPT_RULES (tool protocol, frozen-
 // zone rules, data-rwa-id) are always appended so editing still works. No agent → the singleton.
 function resolveSystemPrompt() {
+  let base = SYSTEM_PROMPT;
   if (activeAgentRole) {
     const rec = Array.from(installedAgents.values()).find(a => a.role === activeAgentRole && a.verified);
-    if (rec && typeof rec.manifest.system_prompt === 'string') return rec.manifest.system_prompt + '\n' + SYSTEM_PROMPT_RULES;
+    if (rec && typeof rec.manifest.system_prompt === 'string') base = rec.manifest.system_prompt + '\n' + SYSTEM_PROMPT_RULES;
+  }
+  return base + _agAdvisorBlock(); // I-E: append any advisory lenses (secondary; empty → byte-identical)
+}
+// I-E (intelligence/0.2 §6) — blended overlays. The PRIMARY is activeAgentRole (framing/actor/vault,
+// unchanged). advisorRoles add advisory PROSE only — never capabilities, so the vault gate
+// (_agVaultAllowed, keyed on the active record) stays primary-only by construction. Verified-only,
+// ephemeral (never serialized), capped. Block is omitted when empty (single-role prompt unchanged).
+function _agAdvisorBlock() {
+  if (!advisorRoles.size) return '';
+  const lines = [];
+  for (const role of advisorRoles) {
+    if (role === activeAgentRole) continue; // a role is primary XOR advisor, never both
+    const rec = Array.from(installedAgents.values()).find(a => a.role === role && a.verified);
+    if (rec && typeof rec.manifest.system_prompt === 'string') lines.push('- ' + role + ': ' + rec.manifest.system_prompt);
   }
-  return SYSTEM_PROMPT;
+  return lines.length ? '\n\nAdditional advisory lenses (secondary — apply only where they don\'t conflict with the above):\n' + lines.join('\n') : '';
 }
 // I12 — the role-scoped vault gate: exact vault:<ns> membership in the agent's vault_namespace_set
 // (mirrors _skVaultAllowed against the agent record instead of the skill's permissions).
@@ -6832,6 +6865,10 @@ const installedSkills = new Map();
 // starts with no agent active per §12).
 const installedAgents = new Map();
 let activeAgentRole = null;
+// I-E — advisory roles layered atop the primary (in-memory, ephemeral, never serialized — like the
+// active role). Capped for prompt coherence/size. Advisors contribute prose only (see _agAdvisorBlock).
+const advisorRoles = new Set();
+const ADVISOR_CAP = 3;
 // I8 (v0.9 §9) — hook firing state. activeHooks holds skillIds currently executing (re-entrancy
 // guard, Inv 23); _lastHookMode tracks the prior mode for on-mode-change's `previous`; _hookSeq
 // makes rwa_hook_log keys unique within a millisecond.
@@ -7810,7 +7847,7 @@ function _agAgentsRegion() {
   };
 }
 function runtimeListAgents() {
-  return Array.from(installedAgents.values()).map(a => ({ role: a.role, author_pubkey: a.manifest && a.manifest.author_pubkey, verified: a.verified }));
+  return Array.from(installedAgents.values()).map(a => ({ role: a.role, author_pubkey: a.manifest && a.manifest.author_pubkey, verified: a.verified, affinity: getAffinity(a.envelope) }));
 }
 function runtimeAgentActive() {
   if (!activeAgentRole) return null;
@@ -7826,6 +7863,19 @@ function runtimeSetActiveAgent(role) {
   if (!rec.verified) throw new RwaEditError('unverified_agent', null, { role });
   activeAgentRole = role;
 }
+// I-E — add/remove an advisory role. Verified-only (its prompt drives modify), not-the-primary,
+// capped. Checks order so unverified/not-found beat the cap. Returns the current advisor list.
+function runtimeAddAdvisor(role) {
+  const rec = Array.from(installedAgents.values()).find(a => a.role === role);
+  if (!rec) throw new RwaEditError('agent_not_found', null, { role });
+  if (!rec.verified) throw new RwaEditError('unverified_agent', null, { role });
+  if (role === activeAgentRole || advisorRoles.has(role)) return Array.from(advisorRoles); // primary / already → no-op
+  if (advisorRoles.size >= ADVISOR_CAP) throw new RwaEditError('advisor_cap_reached', null, { cap: ADVISOR_CAP });
+  advisorRoles.add(role);
+  return Array.from(advisorRoles);
+}
+function runtimeRemoveAdvisor(role) { advisorRoles.delete(role); return Array.from(advisorRoles); }
+function runtimeListAdvisors() { return Array.from(advisorRoles); }
 // §12 — validate + verify + register an agent, then persist the #rwa-agents zone (same discipline as
 // runtimeInstallSkill: rollback the in-memory map on a persist failure). A signed-but-unverified
 // agent registers (verified:false) but can't activate.
@@ -7851,6 +7901,7 @@ async function runtimeUninstallAgent(agentId) {
   if (!prev) return { ok: false, errors: ['not_installed'] };
   installedAgents.delete(agentId);
   if (activeAgentRole && prev.role === activeAgentRole && !Array.from(installedAgents.values()).some(a => a.role === activeAgentRole)) activeAgentRole = null;
+  if (prev.role && !Array.from(installedAgents.values()).some(a => a.role === prev.role)) advisorRoles.delete(prev.role); // I-E: drop a removed role from advisors
   try {
     await runtimeRegionCommit({ regions: [_agAgentsRegion()], actor: 'agent:uninstall', reachability: 'frozen' });
   } catch (e) {
@@ -8118,6 +8169,24 @@ function getRecommendation(envelope) {
   if (typeof e.recommended_backend === 'string' && REC_BACKENDS.includes(e.recommended_backend.trim())) out.backend = e.recommended_backend.trim();
   return (out.model || out.backend) ? out : null;
 }
+// I-D (intelligence/0.2 §6) — advisory kind-affinity. A role may declare an UNSIGNED `affinity`
+// envelope field (the document kinds it is tuned for). Activating/advising it on a mismatched
+// PRODUCT_KIND only WARNS — never blocks (spec §4: affinity is a soft note). Advisory by design.
+function getAffinity(envelope) {
+  const a = envelope && envelope.affinity;
+  if (Array.isArray(a)) return a.filter(x => typeof x === 'string' && x);
+  if (typeof a === 'string' && a) return [a];
+  return [];
+}
+function affinityWarning(role) {
+  const rec = Array.from(installedAgents.values()).find(x => x.role === role);
+  if (!rec) return null;
+  const aff = getAffinity(rec.envelope);
+  if (!aff.length || aff.indexOf(PRODUCT_KIND) >= 0) return null;
+  return '⚠ “' + role + '” is tuned for ' + aff.join('/') + ' documents, but this is a ' + PRODUCT_KIND + ' — applied anyway.';
+}
+window.__rwaGetAffinity = getAffinity;
+window.__rwaAffinityWarning = affinityWarning;
 function applyRecommendation(rec) {
   const r = rec || {};
   const applied = {};
@@ -8161,6 +8230,8 @@ window.__rwaGetRecommendation = getRecommendation;
 window.__rwaApplyRecommendation = applyRecommendation;
 window.__rwaOfferRecommendedModel = offerRecommendedModel;
 window.__rwaActivateAgent = runtimeActivateAgent;
+window.__rwaResolveSystemPrompt = resolveSystemPrompt; // I-E test hook — the assembled modify() prompt
+window.__rwaGetActiveActor = getActiveActor;
 
 // §4/§5a — does a network: host pattern admit a host? Mirror of cli/src/skill-manifest.mjs
 // matchNetworkOrigin (keep in step). The bridge's per-call origin check.
@@ -9694,7 +9765,7 @@ document.addEventListener('keydown', e => {
       discoverSkills: runtimeDiscoverSkills, // v0.9 §11 (I6) — GET the marketplace index (opt-in network)
       fetchSkillFromIndex: runtimeFetchSkillFromIndex, // v0.9 §11 (I6) — fetch + client-side-verify an indexed skill
       vault: { get: runtimeVaultGet, set: runtimeVaultSet, has: runtimeVaultHas, namespaces: runtimeVaultNamespaces, unlock: runtimeVaultUnlock, lock: runtimeVaultLock, isLocked: runtimeVaultIsLocked, export: runtimeVaultExport, import: runtimeVaultImport }, // v0.8 §6 + v0.9 §14 (I13) portable export/import
-      agents: { list: runtimeListAgents, active: runtimeAgentActive, setActive: runtimeSetActiveAgent, activate: runtimeActivateAgent, install: runtimeInstallAgent, uninstall: runtimeUninstallAgent, message: runtimeAgentMessage, showInstallDialog: showAgentInstallDialog, offerModel: offerRecommendedModel }, // v0.9 §12 — multi-agent roles; `activate` = setActive + offer recommended model (intelligence/0.2 I-A)
+      agents: { list: runtimeListAgents, active: runtimeAgentActive, setActive: runtimeSetActiveAgent, activate: runtimeActivateAgent, install: runtimeInstallAgent, uninstall: runtimeUninstallAgent, message: runtimeAgentMessage, showInstallDialog: showAgentInstallDialog, offerModel: offerRecommendedModel, addAdvisor: runtimeAddAdvisor, removeAdvisor: runtimeRemoveAdvisor, advisors: runtimeListAdvisors }, // v0.9 §12 — multi-agent roles; `activate` = setActive + offer recommended model (I-A); addAdvisor/removeAdvisor/advisors = blended overlays (I-E)
       hookLog: runtimeHookLog, // v0.9 §9 — the hook audit trail (rwa_hook_log)
     };
     // `status` is a getter so each read returns a fresh snapshot of

package/src/intelligence.mjs

@@ -0,0 +1,79 @@
+// I-C (intelligence/0.2 §6) — `rwa intelligence new <role>`: mint a signed rwa-agent/1 role and
+// scaffold a CARRIER rewritable (a skill-host holding the record + a self-describing card). The
+// carrier ships only the PUBLIC key + signature; the PRIVATE key is written to a sibling .key.json
+// (keep it to publish updates under the same author identity). Offline; reuses the agent canon
+// (skill-manifest) and the seed bootstrap (seed.mjs) — no new wire-type, no canon fork.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { webcrypto, randomUUID } from 'node:crypto';
+import { SEED_CANDIDATES } from './commands.mjs';
+import { loadSeed, applySeedSubs, kindOverrides, replaceInlineDoc } from './seed.mjs';
+import { agentSigningMessage } from './skill-manifest.mjs';
+
+const ROLE_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const REC_MODEL_RE = /^[A-Za-z0-9._:\/-]{1,200}$/;
+const REC_BACKENDS = ['openrouter', 'ollama', 'lmstudio', 'atomic', 'bridge', 'bridge-session'];
+const b64 = (u8) => Buffer.from(u8).toString('base64');
+const rel = (p) => path.relative(process.cwd(), p) || p;
+const esc = (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const fail = (msg, code = 2) => { const e = new Error(msg); e.exitCode = code; throw e; };
+
+export async function intelligenceNewCmd(opts = {}) {
+  const role = opts.role, prompt = opts.prompt;
+  if (!role || !ROLE_RE.test(role)) fail('intelligence: <role> must be lowercase a-z0-9_- (≤64, leading alphanumeric)');
+  if (!prompt || typeof prompt !== 'string') fail('intelligence: --prompt "<system prompt>" is required');
+  if (prompt.includes('`') || prompt.includes('${') || /<\/?DOC>/i.test(prompt)) fail('intelligence: --prompt must not contain ` ${ or <DOC>');
+  if (opts.model != null && !REC_MODEL_RE.test(String(opts.model))) fail('intelligence: --model is not a valid model id');
+  if (opts.backend != null && !REC_BACKENDS.includes(String(opts.backend))) fail('intelligence: --backend must be one of ' + REC_BACKENDS.join('/'));
+  const vault = (opts.vault || []).map(v => /^vault:/.test(v) ? v : 'vault:' + v);
+  const affinity = (opts.affinity || []).filter(Boolean);
+
+  // Mint + sign the rwa-agent/1 record. The signature is over `agent` (the canon); the
+  // recommendation/affinity ride OUTSIDE it (unsigned envelope fields, per I-A/I-D).
+  const kp = await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']);
+  const author_pubkey = b64(new Uint8Array(await webcrypto.subtle.exportKey('raw', kp.publicKey)));
+  const agent = { author_pubkey, description: opts.description || ('The ' + role + ' role.'), role, system_prompt: prompt, vault_namespace_set: vault, version: 'rwa-agent/1' };
+  const signature = b64(new Uint8Array(await webcrypto.subtle.sign({ name: 'Ed25519' }, kp.privateKey, agentSigningMessage(agent))));
+  const envelope = { agent, signature };
+  if (opts.model) envelope.recommended_model = String(opts.model);
+  if (opts.backend) envelope.recommended_backend = String(opts.backend);
+  if (affinity.length) envelope.affinity = affinity;
+
+  // Scaffold the carrier — a skill-host bootstrap + card + frozen #rwa-agents zone.
+  const out = path.resolve(opts.outPath || ('./' + role + '.intelligence.html'));
+  if (!opts.force) { let exists = false; try { await fs.access(out); exists = true; } catch (_) {} if (exists) fail('intelligence: ' + rel(out) + ' exists (use --force)'); }
+  const seed = await loadSeed(SEED_CANDIDATES);
+  const ov = kindOverrides('skill-host');
+  let result = applySeedSubs(seed, { uuid: randomUUID(), title: 'Intelligence — ' + role, fileMeta: path.basename(out), productKind: 'skill-host', lensPlaceholder: ov.lensPlaceholder, palPlaceholder: ov.palPlaceholder, productHeader: ov.productHeader, lensClickToAnchor: ov.lensClickToAnchor });
+  const zone = '<div data-rwa-frozen id="rwa-agents"><script type="application/rwa-agent+json">' + b64(Buffer.from(JSON.stringify(envelope))) + '</script></div>';
+  result = replaceInlineDoc(result, buildCard({ role, prompt, model: opts.model, backend: opts.backend, affinity, vault }) + '\n' + zone);
+  await fs.writeFile(out, result, 'utf8');
+
+  // The private key — needed to re-sign updates under the same author identity. Sibling file, loud.
+  const fingerprint = Buffer.from(await webcrypto.subtle.digest('SHA-256', Buffer.from(author_pubkey, 'base64'))).toString('hex').slice(0, 16);
+  const keyOut = out.replace(/\.html?$/i, '') + '.key.json';
+  // 0600: the file holds the PRIVATE key — owner read/write only, never world-readable.
+  await fs.writeFile(keyOut, JSON.stringify({
+    role, author_pubkey, fingerprint,
+    private_key_pkcs8_b64: b64(new Uint8Array(await webcrypto.subtle.exportKey('pkcs8', kp.privateKey))),
+    warning: 'SECRET. Keep this to publish updates to this intelligence under the same author identity. Never commit or share it. The carrier .html holds only the public key.',
+  }, null, 2) + '\n', { mode: 0o600 });
+  try { await fs.chmod(keyOut, 0o600); } catch (_) {} // guarantee owner-only even if the file pre-existed (writeFile mode applies only on create; best-effort on non-POSIX)
+
+  console.log('wrote ' + rel(out) + ' (intelligence "' + role + '")');
+  console.log('author ' + fingerprint + ' — private key saved to ' + rel(keyOut) + ' (keep secret; needed to update this intelligence)');
+  return { out, keyOut, fingerprint, envelope };
+}
+
+function buildCard({ role, prompt, model, backend, affinity, vault }) {
+  const recLine = model ? '\n<li><strong>Recommended model:</strong> <code>' + esc(model) + '</code>' + (backend ? ' on <code>' + esc(backend) + '</code>' : '') + ' — offered on activation, behind consent (your session only; key untouched).</li>' : '';
+  const affLine = affinity.length ? '\n<li><strong>Affinity:</strong> ' + esc(affinity.join(', ')) + ' (advisory — a mismatch only warns).</li>' : '';
+  const vaultLine = '\n<li><strong>Vault namespaces:</strong> ' + (vault.length ? esc(vault.join(', ')) : 'none') + '.</li>';
+  return '<article>\n' +
+    '<h1>Intelligence — &ldquo;' + esc(role) + '&rdquo;</h1>\n' +
+    '<p class="lede">A droppable <strong>intelligence</strong> (intelligence/0.2): a signed <code>rwa-agent/1</code> role you can drop onto another rewritable to retune its &#8984;K editor. This file is the carrier — open it, read it, drop it.</p>\n' +
+    '<h2>What it does</h2>\n<p>' + esc(prompt) + '</p>\n' +
+    '<h2>What it carries</h2>\n<ul>\n<li><strong>Role:</strong> <code>' + esc(role) + '</code></li>' + recLine + affLine + vaultLine + '\n</ul>\n' +
+    '<h2>How to use it</h2>\n<p>Drop this file onto another rewritable to install the role (behind the consent dialog), then activate it from the Activity panel&rsquo;s <em>Intelligences</em> section. This carrier is itself a skill-host, so the role is already installed here — try it directly.</p>\n' +
+    '</article>';
+}