futura-scion 0.2.2 → 0.2.4

package/bin/scion.js

@@ -84,6 +84,33 @@ const oracle = realVerifiers ? { verifiers: realVerifiers } : { verifyFn };
  */
 const CLARIFY_MAX_DEPTH = 3;
 
+/** Human chat summary of a brief model (+ optional verification). */
+function briefSummary(model, verification, intake) {
+  const reqs = model.requirements || [];
+  const lines = [];
+  if (intake) {
+    lines.push(intake.added > 0
+      ? `Noted — ${intake.added} new requirement${intake.added > 1 ? 's' : ''} added to brief #${model.id} (${intake.total} total).`
+      : `Already captured — brief #${model.id} has ${intake.total} requirement${intake.total === 1 ? '' : 's'}.`);
+  } else {
+    lines.push(`Brief #${model.id}: ${reqs.length} requirement${reqs.length === 1 ? '' : 's'}.`);
+  }
+  for (const r of reqs.slice(0, 8)) {
+    const mark = r.status === 'pass' ? '✓' : r.status === 'fail' ? '✗' : r.checkable ? '◇' : '·';
+    lines.push(`  ${mark} ${r.kind}: ${String(r.text).slice(0, 90)}${r.checkable ? '' : '  (judgment — needs a human or a model)'}`);
+  }
+  if (reqs.length > 8) lines.push(`  …and ${reqs.length - 8} more`);
+  if (verification) {
+    lines.push(`Gate verification: ${verification.passed} passed, ${verification.failed} failed` +
+      (verification.coverage != null ? `, coverage ${(verification.coverage * 100).toFixed(0)}%` : '') +
+      (verification.failed > 0 ? ' — failing requirements block completion.' :
+        verification.passed > 0 ? ' — the contract holds.' : ''));
+  } else {
+    lines.push('Say "verify the brief" to run the checks against the tree.');
+  }
+  return lines.join('\n');
+}
+
 async function oneShot(text, opts = {}, depth = 0) {
   const { interpret, slotsToPayload, clarify, resolveClarification, resetLearnedTermsCache } = await import('../src/mind/nlu.js');
   const { getProjectScopes, resolveScopes } = await import('../src/mind/scopes.js');
@@ -142,6 +169,29 @@ async function oneShot(text, opts = {}, depth = 0) {
     const saved = save({ type: 'observation', title: content.slice(0, 80), content, tags: ['remembered'], confidence: 90, provenance: 'explicit' });
     return { ok: true, intent: 'remember', result: saved };
   }
+  // Brief intent — context arrives IN THE CHAT, not as a file. The message
+  // itself is ingested into the active brief (accumulated across turns);
+  // "verify"/"check" phrasing settles the active brief instead.
+  if (interp.intent === 'brief') {
+    const briefs = await import('../src/mind/brief.js');
+    if (arg === 'verify' || restArgs.includes('--verify') || /\b(verify|check|settle)\b/i.test(text)) {
+      const id = briefs.activeBriefId();
+      if (!id) return { ok: false, intent: 'brief', reply: 'no active brief — state a requirement first (e.g. "the report must contain totals").' };
+      const c = briefs.compileBrief(id);
+      const v = await briefs.verifyBrief(id);
+      return {
+        ok: true, intent: 'brief',
+        reply: briefSummary(briefs.getBrief(id), v),
+        result: { briefId: id, compiled: c.compiled, verification: v },
+      };
+    }
+    const intake = await briefs.chatIntake(text);
+    return {
+      ok: true, intent: 'brief',
+      reply: briefSummary(intake.model, null, intake),
+      result: { briefId: intake.briefId, added: intake.added, total: intake.total },
+    };
+  }
 
   // Ambiguous: ask ONE deterministic question with the top-N ranked
   // interpretations instead of a cold escalation or a silent guess. Every
@@ -741,6 +791,98 @@ switch (cmd || '') {
     console.log(JSON.stringify(out, null, 2));
     break;
   }
+  case 'scaffold': {
+    // CONSTRUCTION: compose a template into a project skeleton, gated by
+    // the stack's real verifier recipe before success is reported.
+    const { scaffold, listTemplates, loadTemplate } = await import('../src/mind/scaffold.js');
+    if (!arg || arg === 'list' || arg === '--list') {
+      const tpls = listTemplates();
+      if (tpls.length === 0) { console.log('no templates in templates/ — add YAML manifests'); break; }
+      for (const t of tpls) console.log(`${t.id.padEnd(16)} ${(t.stack ?? '-').toString().padEnd(8)} ${t.description}`);
+      break;
+    }
+    const flags = restArgs.filter((a) => a.startsWith('--'));
+    const positional = restArgs.filter((a) => !a.startsWith('--'));
+    const target = positional[0];   // output directory
+    if (!target) {
+      console.error('usage: scion scaffold <template|list> <target-dir> [--name x] [--title y] [--port N] [--param k=v] [--no-verify]');
+      process.exitCode = 2;
+      break;
+    }
+    const tpl = loadTemplate(arg);
+    const params = {};
+    for (const f of flags) {
+      const m = f.match(/^--([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (m) params[m[1]] = m[2];
+    }
+    // Default missing params to sensible template-agnostic values instead
+    // of a raw throw — the CLI user should see WHICH param is missing in a
+    // friendly line, not a stack trace.
+    for (const req of ['name', 'title', 'port', 'description']) {
+      if (!(req in params)) {
+        if (req === 'port') params.port = '3000';
+        else if (req === 'title') params.title = params.name ?? arg;
+        else if (req === 'name') params.name = params.name ?? 'app';
+        else params.description ??= `built with FS scaffold (${arg})`;
+      }
+    }
+    let r;
+    try {
+      r = await scaffold(arg, { params, cwd: resolve(target), verify: !flags.includes('--no-verify') });
+    } catch (err) {
+      console.error(`scaffold failed: ${err.message}`);
+      process.exitCode = 1;
+      break;
+    }
+    if (r.ok === false && r.error) {
+      console.error(`scaffold failed: ${r.error}`);
+      process.exitCode = 1;
+      break;
+    }
+    console.log(`scaffold ${r.template} → ${target}`);
+    for (const f of r.files) console.log(`  + ${f}`);
+    if (r.gate) {
+      console.log(`gate: ${r.gate.verified ? 'VERIFIED' : 'FAILED'} — [${r.gate.evidence.exit_codes.join(',')}]`);
+      if (!r.gate.verified) process.exitCode = 1;
+    } else {
+      console.log('gate: skipped (no stack recipe)');
+    }
+    break;
+  }
+  case 'research': {
+    // The research rung, driven from the CLI (webresearcher lineage):
+    // deterministic-first web research with a completion gate.
+    const q = [arg, ...restArgs.filter((a) => !a.startsWith('--'))].filter(Boolean).join(' ').trim();
+    const flags = restArgs.filter((a) => a.startsWith('--')) || [];
+    const { runResearch } = await import('../src/mind/research/index.js');
+    if (!q) {
+      console.error('usage: scion research "<question>" [--no-persist] [--pages N] [--deep] [--learn]');
+      process.exitCode = 2;
+      break;
+    }
+    const recipe = flags.includes('--deep')
+      ? { id: 'deep-dive', parameters: { max_pages: 16 }, verify: { min_pages: 2, min_items: 5, min_corroborated: 1 } }
+      : undefined;
+    const report = await runResearch(q, {
+      recipe,
+      persist: !flags.includes('--no-persist'),
+      max_pages: Number((flags.find((f) => f.startsWith('--pages')) ?? '').split('=')[1]) || (flags.includes('--pages') ? Number(restArgs[restArgs.indexOf('--pages') + 1]) : undefined) || undefined,
+    });
+    console.log(`research: ${report.pages} pages → ${report.items.length} items ` +
+      `(${report.census.SUPPORTED} corroborated, ${report.census.CONFLICTING} conflicting)`);
+    console.log(`gate: ${report.gate.verdict} — ${report.gate.checks.map((c) => `${c.check}:${c.pass ? 'ok' : 'fail'}(${c.actual})`).join(' ')}`);
+    for (const f of report.summary.KEY_FACT.slice(0, 5)) console.log(`  ✓ ${f.slice(0, 140)}`);
+    for (const c of report.summary.CONTRADICTION.slice(0, 3)) console.log(`  ⚡ ${c.slice(0, 140)}`);
+    for (const e of report.summary.EVIDENCE.slice(0, 3)) console.log(`  · ${e.slice(0, 140)}`);
+    if (report.fallback) console.log(`  [llm-fallback] ${report.fallback.synthesis.slice(0, 200)}`);
+    if (flags.includes('--learn')) {
+      const { learnResearchLoops } = await import('../src/mind/research/loop-learner.js');
+      const learned = learnResearchLoops();
+      console.log(`loop-learner: ${learned.length} lesson(s) persisted`);
+    }
+    process.exitCode = report.gate.verdict === 'PASS' ? 0 : 1;
+    break;
+  }
   case 'conventions': {
     // Measure + persist project conventions (cortex convention-detector
     // lineage, as EVIDENCE): discovered, never enforced.
@@ -834,6 +976,10 @@ switch (cmd || '') {
       leaseMs, pollMs,
       primaryUrl: followerMode || primaryUrl ? (primaryUrl || null) : null,
     });
+    // Lever 3: the capability tools (web-search, scholar-search, scaffold-*)
+    // register at boot so serve/UI/MCP all share the widened hands.
+    const { registerBuiltinCapabilities } = await import('../src/mind/builtins-register.js');
+    registerBuiltinCapabilities();
     const api = await startApi({ port: Number(arg) || undefined, leader });
     leader.start();
     // FS Desktop support: provider-backed generator (rung G) from config,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "futura-scion",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "The fused scion of cortex-os-agent + persona: one zero-LLM-dependent agent stack — Mind proposes, Muscle executes, Gate disposes.",
   "type": "module",
   "main": "src/index.js",
@@ -13,6 +13,7 @@
     "bin/",
     "src/",
     "recipes/",
+    "templates/",
     "config/",
     "knowledge/",
     "README.md",

package/src/brain/memory.js

@@ -368,6 +368,30 @@ export function list(opts = {}) {
   return rows.map(r => ({ ...r, tags: JSON.parse(r.tags || '[]') }));
 }
 
+/**
+ * reinforce — DEDUP-REINFORCE (webresearcher cortex_bridge lineage): when
+ * new evidence matches an existing memory, STRENGTHEN it instead of
+ * duplicating. Confidence rises by delta (capped at 100), importance to at
+ * least the floor, and the access counter ticks. Repeated corroboration is
+ * a trust signal — the memory-graph weights read it on every recall.
+ * @param {number} id — existing memory id
+ * @param {object} [opts] — { confidence_delta=5, importance_floor=null }
+ * @returns {{ id, confidence, importance, reinforced: true }}
+ */
+export function reinforce(id, opts = {}) {
+  const db = getDb();
+  const row = db.prepare('SELECT confidence, importance FROM memories WHERE id = ?').get(id);
+  if (!row) throw new Error(`memory.reinforce: no memory ${id}`);
+  const delta = opts.confidence_delta ?? 5;
+  const confidence = Math.min(100, row.confidence + delta);
+  const importance = opts.importance_floor != null
+    ? Math.max(row.importance, opts.importance_floor)
+    : Math.min(10, row.importance + (delta >= 5 ? 1 : 0));
+  db.prepare('UPDATE memories SET confidence = ?, importance = ?, access_count = access_count + 1 WHERE id = ?')
+    .run(confidence, importance, id);
+  return { id, confidence, importance, reinforced: true };
+}
+
 export function stats() {
   const db = getDb();
   const row = db.prepare(

package/src/config.js

@@ -59,6 +59,22 @@ function parseScalar(raw) {
   return v.replace(/^['"]|['"]$/g, '');
 }
 
+/**
+ * Strip a block scalar's BASE indentation while preserving relative
+ * indentation (Python code in templates lives or dies by its indents).
+ * The base is the indentation of the FIRST content line; subsequent lines
+ * are dedented by the same amount. `|` literal blocks are exact; `>` folded
+ * blocks joined with spaces downstream, so per-line dedent is harmless.
+ */
+function dedentBlockLine(line, blockScalar) {
+  if (blockScalar.folded) return line.trim();
+  if (blockScalar.baseIndent === undefined) {
+    blockScalar.baseIndent = line.match(/^\s*/)[0].length;
+  }
+  const cut = Math.min(blockScalar.baseIndent, line.match(/^\s*/)[0].length);
+  return line.slice(cut);
+}
+
 /**
  * Minimal YAML-subset parser: nested maps by indentation, scalars, inline
  * arrays, `#` comments. Deliberately NOT full YAML — unsupported syntax
@@ -144,11 +160,23 @@ export function parseYaml(text, source = CONFIG_PATH) {
     if (!match) {
       // Continuation line of a block scalar ("key: >" folded text)?
       if (blockScalar !== null && /^\s+\S/.test(line)) {
-        blockScalar.text.push(line.trim());
+        blockScalar.text.push(dedentBlockLine(line, blockScalar));
         continue;
       }
       throw new Error(`config: ${source}:${lineno} unsupported syntax — ${JSON.stringify(line.trim())}`);
     }
+    // A block scalar is OPEN and this line is deeper-indented than its key:
+    // it is SCALAR TEXT, never a new key — even when it looks like
+    // "word: value" (template manifests embed whole files in block scalars;
+    // their `port: 3000`-shaped lines are content, not structure). Leading
+    // indentation is PRESERVED relative to the block's first content line —
+    // Python files in templates live or die by their indentation.
+    if (blockScalar !== null
+        && match[1].length > (blockScalar.indent ?? 0)
+        && !/^\s*-\s/.test(line)) {
+      blockScalar.text.push(dedentBlockLine(line, blockScalar));
+      continue;
+    }
     const [, ws, key, rest] = match;
     const indent = ws.length;
 

package/src/http.js

@@ -275,7 +275,32 @@ export function createApiServer(opts = {}) {
 
         let reply; let meta;
         try {
-        if (interp.intent === 'show' || interp.intent === 'search' || interp.intent === 'remember' || mode === 'chat') {
+        // Brief intent: requirements arrive IN THE CHAT — ingest with
+        // streamed stage events (parsed → compiled), or verify on request.
+        if (interp.intent === 'brief') {
+          const briefs = await import('./mind/brief.js');
+          if (/\b(verify|check|settle)\b/i.test(body.text)) {
+            const id = briefs.activeBriefId();
+            if (!id) {
+              reply = 'No active brief yet — state a requirement first (e.g. "the report must contain a totals row").';
+              meta = { rung: 'brief' };
+            } else {
+              emit('progress', { stage: 'brief-compile', detail: `compiling brief ${id}` });
+              const c = briefs.compileBrief(id);
+              emit('progress', { stage: 'brief-verify', detail: `${c.compiled} checks through the Gate` });
+              const v = await briefs.verifyBrief(id);
+              briefs.setActiveBrief(null); // settled — matches chatIntake settle semantics
+              reply = briefChatSummary(briefs.getBrief(id), v);
+              meta = { rung: 'brief', detail: `brief ${id}: ${v.passed}✓ ${v.failed}✗` };
+            }
+          } else {
+            emit('progress', { stage: 'brief-parse', detail: 'parsing requirements from the message' });
+            const intake = await briefs.chatIntake(body.text);
+            emit('progress', { stage: 'brief-compiled', detail: `${intake.model.requirements.filter(r => r.checkable).length} machine-checkable` });
+            reply = briefChatSummary(intake.model, null, intake);
+            meta = { rung: 'brief', detail: `brief ${intake.briefId}: +${intake.added} (${intake.total} total)` };
+          }
+        } else if (interp.intent === 'show' || interp.intent === 'search' || interp.intent === 'remember' || mode === 'chat') {
           reply = await chatAnswer(interp, body.text);
           meta = { rung: 'nlu', detail: `intent: ${interp.intent} (${Math.round(interp.confidence * 100)}%)` };
         } else {
@@ -325,6 +350,25 @@ export function createApiServer(opts = {}) {
         const { interpret, slotsToPayload } = await nlu();
         const interp = interpret(body.text);
         const mode = body.mode === 'agent' || body.mode === 'chat' ? body.mode : 'chat';
+        // Brief intent: requirements arrive IN THE CHAT — ingest into the
+        // active brief (accumulated across turns), or verify on request.
+        if (interp.intent === 'brief') {
+          const briefs = await import('./mind/brief.js');
+          if (/\b(verify|check|settle)\b/i.test(body.text)) {
+            const id = briefs.activeBriefId();
+            if (!id) {
+              return send(res, 200, { reply: 'No active brief yet — state a requirement first (e.g. "the report must contain a totals row").', meta: { rung: 'brief' } });
+            }
+            const c = briefs.compileBrief(id);
+            const v = await briefs.verifyBrief(id);
+            return send(res, 200, { reply: briefChatSummary(briefs.getBrief(id), v), meta: { rung: 'brief', detail: `brief ${id}: ${v.passed}✓ ${v.failed}✗` } });
+          }
+          const intake = await briefs.chatIntake(body.text);
+          return send(res, 200, {
+            reply: briefChatSummary(intake.model, null, intake),
+            meta: { rung: 'brief', detail: `brief ${intake.briefId}: +${intake.added} (${intake.total} total)` },
+          });
+        }
         if (interp.intent === 'show' || interp.intent === 'search' || interp.intent === 'remember' || mode === 'chat') {
           const reply = await chatAnswer(interp, body.text);
           return send(res, 200, { reply, meta: { rung: 'nlu', detail: `intent: ${interp.intent} (${Math.round(interp.confidence * 100)}%)` } });
@@ -489,6 +533,33 @@ async function nlu() {
 }
 
 /** Chat mode: answer from kernel state — never invents, never mutates. */
+/** Human chat summary of a brief model (shared by /ui/act and stream). */
+function briefChatSummary(model, verification, intake) {
+  const reqs = model.requirements || [];
+  const lines = [];
+  if (intake) {
+    lines.push(intake.added > 0
+      ? `Noted — ${intake.added} new requirement${intake.added > 1 ? 's' : ''} added to brief #${model.id} (${intake.total} total).`
+      : `Already captured — brief #${model.id} has ${intake.total} requirement${intake.total === 1 ? '' : 's'}.`);
+  } else {
+    lines.push(`Brief #${model.id}: ${reqs.length} requirement${reqs.length === 1 ? '' : 's'}.`);
+  }
+  for (const r of reqs.slice(0, 8)) {
+    const mark = r.status === 'pass' ? '✓' : r.status === 'fail' ? '✗' : r.checkable ? '◇' : '·';
+    lines.push(`${mark} ${r.kind}: ${String(r.text).slice(0, 90)}${r.checkable ? '' : '  (judgment — needs a human or a model)'}`);
+  }
+  if (reqs.length > 8) lines.push(`…and ${reqs.length - 8} more`);
+  if (verification) {
+    lines.push(`Gate verification: ${verification.passed} passed, ${verification.failed} failed` +
+      (verification.coverage != null ? `, coverage ${(verification.coverage * 100).toFixed(0)}%` : '') +
+      (verification.failed > 0 ? ' — failing requirements block completion.' :
+        verification.passed > 0 ? ' — the contract holds.' : ''));
+  } else {
+    lines.push('Say "verify the brief" to run the checks against the tree.');
+  }
+  return lines.join('\n');
+}
+
 async function chatAnswer(interp, text) {
   if (interp.intent === 'show') {
     const what = interp.target || '';

package/src/mind/brief.js

@@ -119,12 +119,26 @@ export function ingest(opts) {
       continue;
     }
 
-    // Rule sentences: MUST/SHALL/SHOULD/cannot/never/always…
+    // Rule sentences: MUST/SHALL/SHOULD/cannot/never/always… Compound
+    // chat lines ("X must exist and the customer wants a nicer UI") are
+    // split on conjunctions so each requirement stands alone — a checkable
+    // rule is never muddled with an adjacent wish.
     if (RULE_MODAL_RE.test(line)) {
       const modality = /must\s+not|shall\s+not|cannot|can't|can’t|never|forbidden|not\s+be\s+allowed/i.test(line) ? 'must-not'
         : /must|shall|requires/i.test(line) ? 'must'
         : /should/i.test(line) ? 'should' : 'always';
-      requirements.push({ kind: 'rule', text: line, subject: line, modality });
+      const conjuncts = line
+        // sentence boundaries are the primary split inside a chat line
+        .split(/(?<=[.!?])\s+/)
+        .flatMap(s => s.split(/\s+(?:and|also|plus)\s+(?=(?:the\s+|a\s+|an\s+|all\s+|every\s+)?\w+\s+(?:must|shall|should|cannot|never|wants?|needs?|is\s+not\s+allowed))/i))
+        .map(s => s.trim().replace(/[.]$/, '')).filter(Boolean);
+      for (const part of conjuncts) {
+        const m = /must\s+not|shall\s+not|cannot|can't|can’t|never|forbidden/i.test(part) ? 'must-not'
+          : /must|shall|requires/i.test(part) ? 'must'
+          : /should/i.test(part) ? 'should'
+          : /^(the\s+)?(customer|user|client|team)/i.test(part) ? 'wish' : modality;
+        requirements.push({ kind: m === 'wish' ? 'judgment' : 'rule', text: part, subject: part, modality: m });
+      }
       continue;
     }
   }
@@ -171,6 +185,21 @@ export function ingest(opts) {
 export function classify(req) {
   const t = String(req?.text || '');
 
+  // Compound sentences split FIRST: chat lines carry several requirements
+  // joined by "and"/"also" — each conjunct is classified on its own, so
+  // "X must exist and the customer wants a nicer UI" yields one checkable
+  // rule and one judgment, not one muddled compound.
+  const conjuncts = t.split(/\s+(?:and|also|plus|;)\s+/i).map(s => s.trim()).filter(s => s.length >= 8);
+  if (conjuncts.length > 1) {
+    const parts = conjuncts.map(conj => classify({ ...req, text: conj }));
+    if (parts.some(p => p.checkable)) {
+      // Prefer the checkable part as THIS requirement's spec; the other
+      // conjuncts are re-emitted by the caller via splitConjuncts().
+      const hit = parts.find(p => p.checkable);
+      return { ...hit, conjuncts };
+    }
+  }
+
   // Explicit directive wins: "check: <shell command>" or a backticked
   // command anchored to an exit-code phrase — the author says exactly how
   // to verify; the Gate runs it verbatim.
@@ -184,12 +213,14 @@ export function classify(req) {
     || t.match(/\b(?:must|shall|should)\s+(?:exist|be\s+present)[^.]*\b([\w./\\-]+\.[a-z0-9]{1,6})\b/i);
   if (exists) return { checkable: true, spec: { type: 'file-exists', target: exists[1] } };
 
-  // file-lacks / file-contains: "X must not contain/contain Y".
-  const contains = t.match(/\b([\w./\\-]+\.[a-z0-9]{1,6})\b[^.]*?\b(?:must|shall|should)\s+not\s+(?:contain|include|reference|log)\s+(?:the\s+)?(?:word\s+|string\s+|secret[s]?\s+)?["'`]([^"'`\n]+)["'`]/i)
-    || t.match(/\b([\w./\\-]+\.[a-z0-9]{1,6})\b[^.]*?\b(?:must|shall|should)\s+(?:contain|include|reference)\s+(?:the\s+)?(?:word\s+|string\s+)?["'`]([^"'`\n]+)["'`]/i);
+  // file-lacks / file-contains: "X must not contain/contain Y". The needle
+  // may be bare (no quotes) in chat speech: "must not contain the word ZZZZ".
+  const contains = t.match(/\b([\w./\\-]+\.[a-z0-9]{1,6})\b[^.]*?\b(?:must|shall|should)\s+not\s+(?:contain|include|reference|log)\s+(?:the\s+)?(?:word\s+|string\s+|secret[s]?\s+)?(?:["'`]([^"'`\n]+)["'`]|([A-Za-z0-9_]{3,})\b)/i)
+    || t.match(/\b([\w./\\-]+\.[a-z0-9]{1,6})\b[^.]*?\b(?:must|shall|should)\s+(?:contain|include|reference)\s+(?:the\s+)?(?:word\s+|string\s+)?(?:["'`]([^"'`\n]+)["'`]|([A-Za-z0-9_]{3,})\b)/i);
   if (contains) {
     const negative = /must\s+not|shall\s+not|never/i.test(contains.input);
-    return { checkable: true, spec: { type: negative ? 'file-lacks' : 'file-contains', target: contains[1], needle: contains[2] } };
+    const needle = contains[2] ?? contains[3];
+    return { checkable: true, spec: { type: negative ? 'file-lacks' : 'file-contains', target: contains[1], needle } };
   }
 
   // regex: "must match /re/"
@@ -377,9 +408,117 @@ export function listBriefs(limit = 20) {
   ).all(limit);
 }
 
+// ─── Chat accumulation: the ACTIVE brief ────────────────────────────
+
+const ACTIVE_KEY = 'active_brief';
+
+/**
+ * The active brief: requirements arriving in CHAT accumulate onto one
+ * brief (the conversation's working contract) until it is verified or
+ * explicitly replaced. Persisted in the brain meta table — restart-safe.
+ *
+ * @returns {number|null} brief id
+ */
+export function activeBriefId() {
+  try {
+    const row = getDb().prepare('SELECT value FROM meta WHERE key = ?').get(ACTIVE_KEY);
+    if (!row) return null;
+    const id = Number(JSON.parse(row.value));
+    return getDb().prepare('SELECT id FROM briefs WHERE id = ?').get(id) ? id : null;
+  } catch { return null; }
+}
+
+/** Point the accumulator at a brief (or clear with null). */
+export function setActiveBrief(briefId) {
+  const db = getDb();
+  if (briefId == null) {
+    db.prepare('DELETE FROM meta WHERE key = ?').run(ACTIVE_KEY);
+    return { active: null };
+  }
+  if (!db.prepare('SELECT id FROM briefs WHERE id = ?').get(briefId)) {
+    throw new Error(`brief.setActiveBrief: no brief ${briefId}`);
+  }
+  db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value')
+    .run(ACTIVE_KEY, JSON.stringify(Number(briefId)));
+  return { active: Number(briefId) };
+}
+
+/**
+ * Chat intake: append a message to the active brief (creating one on
+ * first requirement), re-parse, and report the accumulated model. Short
+ * messages add requirements; the message itself is the context, not a
+ * file path.
+ *
+ * @param {string} message — the raw chat text
+ * @param {Object} [opts] — { title? }
+ * @returns {{ briefId, added: number, total: number, newRequirements: Array, model: Object }}
+ */
+const SETTLE_RE = /^(verify|check|settle|run)( the)? brief\b/i;
+export async function chatIntake(message, opts = {}) {
+  const db = getDb();
+  let briefId = activeBriefId();
+
+  if (!briefId) {
+    const b = ingest({ text: message, title: opts.title || message.slice(0, 80), source: 'chat' });
+    briefId = b.brief.id;
+    setActiveBrief(briefId);
+    const model = getBrief(briefId);
+    trailJournal('brief.chat-intake', { brief_id: briefId, added: model.requirements.length, created: true });
+    return { briefId, added: model.requirements.length, total: model.requirements.length, newRequirements: model.requirements, model };
+  }
+
+  // Append to the active brief WITHOUT re-ingesting the whole document —
+  // re-parse drifts (the goal paragraph mutates as text grows, old rules
+  // resurface as "new"). Only the NEW message is parsed; dedup by exact
+  // text keeps repeats honest.
+  const existing = new Set(
+    db.prepare('SELECT text FROM requirements WHERE brief_id = ?').all(briefId).map(r => r.text)
+  );
+  const parsed = ingest({ text: message, title: opts.title, source: 'chat', persist: false });
+  // Goals are only minted at brief creation (the goal paragraph is the
+  // whole accumulated text — re-adding it per turn duplicates noise).
+  // Settle phrases route to verification, never into the contract.
+  if (SETTLE_RE.test(message.trim())) {
+    const model = getBrief(briefId);
+    trailJournal('brief.chat-settle', { brief_id: briefId });
+    const verification = await verifyBrief(briefId);
+    setActiveBrief(null); // settled — the next context starts a fresh brief
+    return { briefId, verified: true, added: 0, total: model.requirements.length, newRequirements: [], verification, model };
+  }
+  const fresh = parsed.requirements.filter(r => r.kind !== 'goal' && !existing.has(r.text));
+  const ins = db.prepare('INSERT INTO requirements (brief_id, kind, text, subject) VALUES (?, ?, ?, ?)');
+  for (const r of fresh) ins.run(briefId, r.kind, r.text, r.subject ?? null);
+  const prev = db.prepare('SELECT text FROM briefs WHERE id = ?').get(briefId);
+  db.prepare('UPDATE briefs SET text = ? WHERE id = ?').run(`${prev.text}\n${message}`, briefId);
+
+  const model = getBrief(briefId);
+  // Auto-compile any newly checkable requirements.
+  let compiledNew = 0;
+  for (const row of model.requirements) {
+    if (row.kind !== 'goal' && !row.check_spec) {
+      const cls = classify(row);
+      const cmd = cls.checkable ? compileCheck(cls.spec) : null;
+      const spec = cls.checkable ? (cmd ? JSON.stringify(typeof cmd === 'string' ? { cmd } : cmd) : null) : null;
+      db.prepare('UPDATE requirements SET checkable = ?, check_spec = ?, compiled_cmd = ? WHERE id = ?')
+        .run(cls.checkable ? 1 : 0, cls.checkable ? JSON.stringify(cls.spec) : null, spec, row.id);
+      if (spec) compiledNew++;
+    }
+  }
+  trailJournal('brief.chat-intake', { brief_id: briefId, added: fresh.length, compiled_new: compiledNew });
+  return {
+    briefId,
+    added: fresh.length,
+    total: model.requirements.length,
+    newRequirements: fresh,
+    compiledNew,
+    model: getBrief(briefId),
+  };
+}
+
 /** Reset (tests). */
 export function reset() {
   const db = getDb();
   db.prepare('DELETE FROM requirements').run();
   db.prepare('DELETE FROM briefs').run();
+  db.prepare('DELETE FROM meta WHERE key = ?').run(ACTIVE_KEY);
 }

package/src/mind/builtins-register.js

@@ -0,0 +1,88 @@
+/**
+ * mind/builtins-register.js — LEVER 3 (tool-calling breadth): registers the
+ * network + construction capabilities as FIRST-CLASS registry tools so the
+ * research rung (`research()`) and the swarm can invoke them by name like
+ * any shell tool. Import once at boot/serve; registration is idempotent.
+ *
+ * These are ASYNC capability tools (functions, not argv templates) — the
+ * registry stores their runner and runTool dispatches to it. Same rails
+ * apply: journaled, redacted, bounded.
+ *
+ * @module mind/builtins-register
+ */
+
+'use strict';
+
+import { registerTool } from './tools.js';
+import { searchWeb } from './research/search.js';
+import { listTemplates, loadTemplate } from './scaffold.js';
+
+let registered = false;
+
+/** Idempotently register the capability tools. */
+export function registerBuiltinCapabilities() {
+  if (registered) return listTemplates();
+  registered = true;
+
+  registerTool({
+    name: 'web-search',
+    description: 'search the web (DuckDuckGo keyless / Tavily keyed); {topic} is the query',
+    tags: ['web', 'research', 'network'],
+    capability: async (opts = {}) => {
+      const r = await searchWeb(opts.topic ?? '', { max_results: opts.max_results ?? 5 });
+      return {
+        ok: r.results.length > 0,
+        stdout: r.results.map((x) => `- ${x.title}\n  ${x.url}\n  ${String(x.snippet ?? '').slice(0, 160)}`).join('\n').slice(0, 8000),
+        meta: { provider: r.provider, count: r.results.length, attempts: r.attempts.length },
+      };
+    },
+  });
+
+  registerTool({
+    name: 'scholar-search',
+    description: 'search scholarship (arXiv/Semantic Scholar/CrossRef); {topic} is the query',
+    tags: ['academic', 'research', 'network'],
+    capability: async (opts = {}) => {
+      const { searchScholar } = await import('./research/academic.js');
+      const papers = await searchScholar(opts.topic ?? '', { max_results: 5 });
+      return {
+        ok: papers.length > 0,
+        stdout: papers.map((p) => `- ${p.title} (${p.year ?? 'n.d.'}, cites: ${p.citation_count ?? '?'})\n  ${p.url}`).join('\n').slice(0, 8000),
+        meta: { count: papers.length },
+      };
+    },
+  });
+
+  registerTool({
+    name: 'scaffold-list',
+    description: 'list constructable project templates (what FS can BUILD)',
+    tags: ['construction'],
+    capability: async () => {
+      const tpls = listTemplates();
+      return {
+        ok: tpls.length > 0,
+        stdout: tpls.map((t) => `${t.id.padEnd(16)} ${(t.stack ?? '-').padEnd(8)} ${t.description}`).join('\n'),
+        meta: { count: tpls.length },
+      };
+    },
+  });
+
+  registerTool({
+    name: 'scaffold-inspect',
+    description: 'show a template manifest (files, post commands, stack) for {topic}=template id',
+    tags: ['construction'],
+    capability: async (opts = {}) => {
+      try {
+        const t = loadTemplate(opts.topic ?? '');
+        return {
+          ok: true,
+          stdout: `${t.name} (stack: ${t.stack ?? 'none'})\n${t.description}\nfiles:\n${t.files.map((f) => `  + ${f.path}`).join('\n')}\npost:\n${(t.post ?? []).map((c) => `  $ ${c}`).join('\n') || '  (none)'}`,
+        };
+      } catch (err) {
+        return { ok: false, error: String(err?.message || err).slice(0, 200) };
+      }
+    },
+  });
+
+  return listTemplates();
+}