futura-scion 0.2.2 → 0.2.3

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

package/config/scion.config.yaml

@@ -11,8 +11,12 @@ ladder:
   min_insight_confidence: 0.55  # reasoner rung admission floor
 
 llm:
-  daily_tokens: 0               # 0 = LLM rung off (zero-LLM doctrine)
+  daily_tokens: 500
 
+  apiKey: null
+  model: "qwen2.5-coder:7b"
+  baseUrl: "http://localhost:11434/v1"
+  provider: "ollama"
 bounds:
   max_turns: 25
   timeout_ms: 300000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "futura-scion",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "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",

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/nlu.js

@@ -154,6 +154,12 @@ export const INTENT_LEXICON = Object.freeze([
   { intent: 'analyze',  words: ['analyze', 'scan', 'inspect', 'audit', 'lint'] },
   { intent: 'fix',      words: ['fix', 'repair', 'patch', 'resolve', 'clean', 'solve'] },
   { intent: 'run',      words: ['run', 'execute', 'do', 'perform', 'start'] },
+  // The brief intent: a chat message that CARRIES requirements ("the report
+  // must contain totals", "users must not be deleted without audit") is a
+  // problem-understanding utterance, not a fix/run command. Routed to the
+  // brief organ: the requirements are ingested into the active brief and
+  // compiled to Gate checks — in the chat, no file needed.
+  { intent: 'brief',    words: ['must', 'must not', 'shall', 'should', 'requirement', 'requirements', 'acceptance', 'criteria', 'brief'] },
 ]);
 
 /**
@@ -376,6 +382,18 @@ export function interpret(utterance, opts = {}) {
     const specific = bestOf(tier1, 1);
     if (specific) {
       intent = specific.intent; matchedWord = specific.w;
+      // Brief-context precedence: when the utterance ALSO carries rule
+      // modality ("must"/"shall"/"never"), it is a requirements utterance
+      // even if a task verb appears in it — "fix the login bug, the report
+      // must contain totals" carries a requirement; the verb describes the
+      // work the requirements govern. The brief organ ingests the whole
+      // message; the verb is preserved as evidence.
+      const hasBrief = intentEvidence.some(e => e.intent === 'brief');
+      const hasActionVerb = intent !== 'brief' && ['fix', 'analyze', 'plan', 'run'].includes(intent);
+      if (hasBrief && hasActionVerb) {
+        intent = 'brief';
+        matchedWord = intentEvidence.find(e => e.intent === 'brief')?.word ?? matchedWord;
+      }
     } else {
       const generic = bestOf(tier2, 2);
       if (generic) { intent = generic.intent; matchedWord = generic.w; }