@stackbilt/aegis-core 0.5.1 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbilt/aegis-core",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Persistent AI agent framework for Cloudflare Workers. Multi-tier memory, autonomous goals, dreaming cycles, MCP native.",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -62,7 +62,12 @@
     "./contracts/memory-entry": "./src/contracts/memory-entry.contract.ts",
     "./wiki/client": "./src/wiki/client.ts",
     "./wiki/types": "./src/wiki/types.ts",
-    "./kernel/memory-service": "./src/kernel/memory-service.ts"
+    "./kernel/memory-service": "./src/kernel/memory-service.ts",
+    "./kernel/grounding-layer": "./src/kernel/grounding-layer.ts",
+    "./kernel/grounding/verify": "./src/kernel/grounding/verify.ts",
+    "./kernel/grounding/fanout": "./src/kernel/grounding/fanout.ts",
+    "./kernel/grounding/fabrication-detector": "./src/kernel/grounding/fabrication-detector.ts",
+    "./kernel/grounding/semantic-sanhedrin": "./src/kernel/grounding/semantic-sanhedrin.ts"
   },
   "scripts": {
     "dev": "wrangler dev",

package/src/kernel/dispatch.ts

@@ -62,6 +62,8 @@ export interface EdgeEnv {
   blueskyHandle?: string;
   blueskyAppPassword?: string;
   authBinding?: import('../types.js').AuthServiceBinding;
+  wikiBinding?: Fetcher;
+  wikiToken?: string;
 }
 
 // ─── Intent Construction ─────────────────────────────────────

package/src/kernel/grounding/fabrication-detector.ts

@@ -0,0 +1,377 @@
+// Fabrication detector post-pass for aegis_chat responses.
+//
+// v1 (aegis#447) — mutation-claim class. Scans for present-tense mutation
+// language about agenda items and verifies each against D1 via the
+// #448 helpers. Closes the Chimera failure mode (LLM narrates "resolved #N"
+// while the item is still active).
+//
+// v2 (aegis#500) — referential-claim class. Scans for code-fenced slug-shaped
+// strings asserted as canonical wiki pages and verifies each against the wiki.
+// Note: pattern_id verification is omitted in this core layer (the convergence
+// catalog is daemon/Stackbilt-specific); pattern_id claims are silently skipped.
+//
+// v1 follow-up 1 (aegis#447) — task mutation detection. Scans for UUID-quoted
+// task state claims and verifies each against the cc_tasks D1 table.
+//
+// Shared scope posture for all passes:
+// - Flag, don't strip. Operators see `unverified_claims[]` in the envelope.
+// - Non-fatal on verification error. A single slug lookup failure does not
+//   block the other claims from being reported.
+
+import type { WikiClientEnv } from '../../wiki/client.js';
+import { verifyAgendaClaim, verifyTaskClaim, verifyWikiPageClaim } from './verify.js';
+
+export interface AgendaMutationClaim {
+  kind: 'agenda';
+  id: number;
+  claimedStatus: 'resolved' | 'created' | 'dismissed';
+  snippet: string;
+}
+
+export interface TaskMutationClaim {
+  kind: 'task';
+  id: string;
+  claimedStatus: 'created' | 'completed' | 'cancelled' | 'running';
+  snippet: string;
+}
+
+export type MutationClaim = AgendaMutationClaim | TaskMutationClaim;
+
+export interface ReferentialClaim {
+  kind: 'wiki_page' | 'pattern_id';
+  reference: string;
+  snippet: string;
+}
+
+export interface UnverifiedAgendaMutationClaim {
+  kind: 'agenda';
+  id: number;
+  claimedStatus: AgendaMutationClaim['claimedStatus'];
+  actualStatus: string | null;
+  snippet: string;
+  reason: 'status_mismatch' | 'not_found';
+}
+
+export interface UnverifiedTaskMutationClaim {
+  kind: 'task';
+  id: string;
+  claimedStatus: TaskMutationClaim['claimedStatus'];
+  actualStatus: string | null;
+  snippet: string;
+  reason: 'status_mismatch' | 'not_found';
+}
+
+export type UnverifiedMutationClaim =
+  | UnverifiedAgendaMutationClaim
+  | UnverifiedTaskMutationClaim;
+
+export interface UnverifiedReferentialClaim {
+  kind: ReferentialClaim['kind'];
+  reference: string;
+  snippet: string;
+  reason: 'not_found';
+}
+
+export type UnverifiedClaim = UnverifiedMutationClaim | UnverifiedReferentialClaim;
+
+// ─── Detection ─────────────────────────────────────────────────────
+
+interface AgendaPattern {
+  re: RegExp;
+  status: AgendaMutationClaim['claimedStatus'];
+}
+
+const AGENDA_PATTERNS: AgendaPattern[] = [
+  { re: /marked\s+#(\d+)\s+(?:as\s+)?resolved/gi, status: 'resolved' },
+  { re: /#(\d+)\s+marked\s+(?:as\s+)?resolved/gi, status: 'resolved' },
+  { re: /(?:^|[.\s])resolved\s+#(\d+)/gi, status: 'resolved' },
+  { re: /#(\d+)\s+is\s+(?:now\s+)?resolved/gi, status: 'resolved' },
+  { re: /(?:^|[.\s])closed\s+#(\d+)/gi, status: 'resolved' },
+  { re: /#(\d+)\s+is\s+(?:now\s+)?closed/gi, status: 'resolved' },
+  { re: /created\s+(?:agenda\s+item\s+)?#(\d+)/gi, status: 'created' },
+  { re: /added\s+(?:agenda\s+item\s+)?#(\d+)/gi, status: 'created' },
+  { re: /dismissed\s+#(\d+)/gi, status: 'dismissed' },
+  { re: /#(\d+)\s+is\s+(?:now\s+)?dismissed/gi, status: 'dismissed' },
+];
+
+interface TaskPattern {
+  re: RegExp;
+  status: TaskMutationClaim['claimedStatus'];
+}
+
+const UUID_FRAG = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+
+const TASK_PATTERNS: TaskPattern[] = [
+  { re: new RegExp(`(?:created|queued|added)\\s+task\\s+\`?(${UUID_FRAG})\`?`, 'gi'), status: 'created' },
+  { re: new RegExp(`completed\\s+task\\s+\`?(${UUID_FRAG})\`?`, 'gi'), status: 'completed' },
+  { re: new RegExp(`marked\\s+task\\s+\`?(${UUID_FRAG})\`?\\s+(?:as\\s+)?completed`, 'gi'), status: 'completed' },
+  { re: new RegExp(`task\\s+\`?(${UUID_FRAG})\`?\\s+(?:is|has)\\s+(?:now\\s+|been\\s+)?completed`, 'gi'), status: 'completed' },
+  { re: new RegExp(`cancell?ed\\s+task\\s+\`?(${UUID_FRAG})\`?`, 'gi'), status: 'cancelled' },
+  { re: new RegExp(`task\\s+\`?(${UUID_FRAG})\`?\\s+(?:is|was)\\s+(?:now\\s+)?cancell?ed`, 'gi'), status: 'cancelled' },
+  { re: new RegExp(`task\\s+\`?(${UUID_FRAG})\`?\\s+is\\s+(?:now\\s+)?running`, 'gi'), status: 'running' },
+];
+
+export function detectMutationClaims(text: string): MutationClaim[] {
+  const claims: MutationClaim[] = [];
+  const seen = new Set<string>();
+
+  for (const { re, status } of AGENDA_PATTERNS) {
+    for (const m of text.matchAll(re)) {
+      const id = Number(m[1]);
+      if (!Number.isInteger(id) || id < 1 || id > 1e9) continue;
+      const key = `agenda:${id}:${status}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const startContext = Math.max(0, (m.index ?? 0) - 30);
+      const endContext = Math.min(text.length, (m.index ?? 0) + m[0].length + 30);
+      const snippet = text.slice(startContext, endContext).replace(/\s+/g, ' ').trim();
+      claims.push({ kind: 'agenda', id, claimedStatus: status, snippet });
+    }
+  }
+
+  for (const { re, status } of TASK_PATTERNS) {
+    for (const m of text.matchAll(re)) {
+      const id = m[1].toLowerCase();
+      const key = `task:${id}:${status}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const startContext = Math.max(0, (m.index ?? 0) - 30);
+      const endContext = Math.min(text.length, (m.index ?? 0) + m[0].length + 30);
+      const snippet = text.slice(startContext, endContext).replace(/\s+/g, ' ').trim();
+      claims.push({ kind: 'task', id, claimedStatus: status, snippet });
+    }
+  }
+
+  return claims;
+}
+
+// ─── Referential-claim detection (aegis#500 v2) ────────────────────
+
+const SLUG_RE = /`([a-z][a-z0-9]*(?:-[a-z0-9]+)+)`/g;
+const PATTERN_KEYWORD_RE = /\bpatterns?\b/i;
+const WIKI_KEYWORD_RE = /\b(?:canonical|wiki[\s-]page|wiki[\s-]concept|concepts?\s+page|canonical[\s-]page)\b/i;
+const MAX_REFERENTIAL_CLAIMS = 10;
+
+function sentenceStartBefore(text: string, idx: number): number {
+  for (let i = idx - 1; i >= 0; i--) {
+    const c = text[i];
+    if ((c === '.' || c === '!' || c === '?') && i + 1 < text.length && /\s/.test(text[i + 1])) {
+      return i + 2;
+    }
+  }
+  return 0;
+}
+
+export function detectReferentialClaims(text: string): ReferentialClaim[] {
+  const claims: ReferentialClaim[] = [];
+  const seen = new Set<string>();
+
+  for (const m of text.matchAll(SLUG_RE)) {
+    if (claims.length >= MAX_REFERENTIAL_CLAIMS) break;
+    const slug = m[1];
+    const matchIndex = m.index ?? 0;
+    const sentenceStart = sentenceStartBefore(text, matchIndex);
+    const window = text.slice(sentenceStart, matchIndex);
+
+    const isPattern = PATTERN_KEYWORD_RE.test(window);
+    const isWiki = WIKI_KEYWORD_RE.test(window);
+    if (!isPattern && !isWiki) continue;
+
+    const kind: ReferentialClaim['kind'] = isPattern ? 'pattern_id' : 'wiki_page';
+    const key = `${kind}:${slug}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    const snippetStart = Math.max(0, matchIndex - 30);
+    const snippetEnd = Math.min(text.length, matchIndex + m[0].length + 30);
+    const snippet = text.slice(snippetStart, snippetEnd).replace(/\s+/g, ' ').trim();
+
+    claims.push({ kind, reference: slug, snippet });
+  }
+
+  return claims;
+}
+
+// ─── Verification ──────────────────────────────────────────────────
+
+export interface FabricationReport {
+  checked: number;
+  unverified: UnverifiedClaim[];
+}
+
+export async function verifyMutationClaims(
+  claims: MutationClaim[],
+  db: D1Database,
+): Promise<FabricationReport> {
+  const unverified: UnverifiedClaim[] = [];
+
+  for (const claim of claims) {
+    try {
+      if (claim.kind === 'agenda') {
+        const unv = await verifyAgendaMutation(db, claim);
+        if (unv) unverified.push(unv);
+      } else if (claim.kind === 'task') {
+        const unv = await verifyTaskMutation(db, claim);
+        if (unv) unverified.push(unv);
+      }
+    } catch {
+      // Verification failure is non-fatal — skip this claim rather than
+      // block the entire response.
+    }
+  }
+
+  return { checked: claims.length, unverified };
+}
+
+async function verifyAgendaMutation(
+  db: D1Database,
+  claim: AgendaMutationClaim,
+): Promise<UnverifiedAgendaMutationClaim | null> {
+  const r = await verifyAgendaClaim(db, claim.id);
+  if (!r.exists) {
+    return {
+      kind: 'agenda',
+      id: claim.id,
+      claimedStatus: claim.claimedStatus,
+      actualStatus: null,
+      snippet: claim.snippet,
+      reason: 'not_found',
+    };
+  }
+  const actualStatus = r.item?.status;
+  const mismatch =
+    (claim.claimedStatus === 'resolved' || claim.claimedStatus === 'dismissed') &&
+    actualStatus === 'active';
+  if (mismatch) {
+    return {
+      kind: 'agenda',
+      id: claim.id,
+      claimedStatus: claim.claimedStatus,
+      actualStatus: actualStatus ?? null,
+      snippet: claim.snippet,
+      reason: 'status_mismatch',
+    };
+  }
+  return null;
+}
+
+async function verifyTaskMutation(
+  db: D1Database,
+  claim: TaskMutationClaim,
+): Promise<UnverifiedTaskMutationClaim | null> {
+  const r = await verifyTaskClaim(db, claim.id);
+  if (!r.exists) {
+    return {
+      kind: 'task',
+      id: claim.id,
+      claimedStatus: claim.claimedStatus,
+      actualStatus: null,
+      snippet: claim.snippet,
+      reason: 'not_found',
+    };
+  }
+  const actualStatus = r.task?.status;
+  let mismatch = false;
+  if (claim.claimedStatus === 'completed') {
+    mismatch = actualStatus !== 'completed';
+  } else if (claim.claimedStatus === 'cancelled') {
+    mismatch = actualStatus !== 'cancelled';
+  } else if (claim.claimedStatus === 'running') {
+    mismatch = actualStatus !== 'running';
+  }
+  if (mismatch) {
+    return {
+      kind: 'task',
+      id: claim.id,
+      claimedStatus: claim.claimedStatus,
+      actualStatus: actualStatus ?? null,
+      snippet: claim.snippet,
+      reason: 'status_mismatch',
+    };
+  }
+  return null;
+}
+
+export async function verifyReferentialClaims(
+  claims: ReferentialClaim[],
+  env: WikiClientEnv,
+): Promise<FabricationReport> {
+  const unverified: UnverifiedClaim[] = [];
+
+  for (const claim of claims) {
+    try {
+      if (claim.kind === 'pattern_id') {
+        // Pattern catalog is daemon/consumer-specific; skip verification in core.
+        continue;
+      }
+
+      // kind === 'wiki_page' — needs a live check. Skip silently if no binding.
+      if (!env.wikiBinding || !env.wikiToken) continue;
+      const r = await verifyWikiPageClaim(env, claim.reference);
+      if (!r.exists) {
+        unverified.push({
+          kind: 'wiki_page',
+          reference: claim.reference,
+          snippet: claim.snippet,
+          reason: 'not_found',
+        });
+      }
+    } catch {
+      // Non-fatal per v1 posture.
+    }
+  }
+
+  return { checked: claims.length, unverified };
+}
+
+// ─── Full post-pass ────────────────────────────────────────────────
+
+export interface FabricationCheckEnv extends WikiClientEnv {
+  db: D1Database;
+}
+
+export async function fabricationCheck(
+  responseText: string,
+  env: FabricationCheckEnv,
+): Promise<FabricationReport> {
+  const mutationClaims = detectMutationClaims(responseText);
+  const referentialClaims = detectReferentialClaims(responseText);
+
+  if (mutationClaims.length === 0 && referentialClaims.length === 0) {
+    return { checked: 0, unverified: [] };
+  }
+
+  const [mutationReport, referentialReport] = await Promise.all([
+    mutationClaims.length ? verifyMutationClaims(mutationClaims, env.db) : Promise.resolve<FabricationReport>({ checked: 0, unverified: [] }),
+    referentialClaims.length ? verifyReferentialClaims(referentialClaims, env) : Promise.resolve<FabricationReport>({ checked: 0, unverified: [] }),
+  ]);
+
+  return {
+    checked: mutationReport.checked + referentialReport.checked,
+    unverified: [...mutationReport.unverified, ...referentialReport.unverified],
+  };
+}
+
+// ─── Envelope format ───────────────────────────────────────────────
+
+export function formatUnverifiedClaims(report: FabricationReport): string[] {
+  return report.unverified.map((u) => {
+    if (u.kind === 'agenda') {
+      if (u.reason === 'not_found') {
+        return `agenda#${u.id} (claimed ${u.claimedStatus}, but item does not exist)`;
+      }
+      return `agenda#${u.id} (claimed ${u.claimedStatus}, actual status: ${u.actualStatus})`;
+    }
+    if (u.kind === 'task') {
+      if (u.reason === 'not_found') {
+        return `task \`${u.id}\` (claimed ${u.claimedStatus}, but task does not exist)`;
+      }
+      return `task \`${u.id}\` (claimed ${u.claimedStatus}, actual status: ${u.actualStatus})`;
+    }
+    if (u.kind === 'wiki_page') {
+      return `wiki page \`${u.reference}\` (claimed canonical, but no such page exists)`;
+    }
+    // pattern_id — not verified in core, included for type completeness
+    return `pattern \`${u.reference}\` (claimed canonical, not in convergence catalog)`;
+  });
+}

package/src/kernel/grounding/fanout.ts

@@ -0,0 +1,240 @@
+// Grounding fanout — extracts named entities from a raw intent, runs parallel
+// retrieval against D1 (agenda/task claims) and the wiki, assembles a structured
+// grounding block, and returns it to the caller for prompt injection.
+//
+// Decision-entity fanout (BizOps) is omitted from this generic core layer.
+// Consumers that need it should compose at the call site.
+
+import { searchPages } from '../../wiki/client.js';
+import type { WikiClientEnv } from '../../wiki/client.js';
+import { verifyAgendaClaim, verifyTaskClaim } from './verify.js';
+import type { AgendaClaimResult, TaskClaimResult } from './verify.js';
+
+export interface ExtractedEntities {
+  agendaRefs: number[];
+  taskRefs: string[];
+  namedEntities: string[];
+}
+
+export interface GroundingResult {
+  entities: ExtractedEntities;
+  agendaHits: Array<{ id: number; status: 'verified' | 'unknown'; item?: AgendaClaimResult['item'] }>;
+  taskHits: Array<{ id: string; status: 'verified' | 'unknown'; task?: TaskClaimResult['task'] }>;
+  wikiHits: Array<{ slug: string; scope?: string; summary?: string }>;
+  searched: string[];
+}
+
+// ─── Entity extraction ─────────────────────────────────────────────
+
+const AGENDA_REF_RE = /(?:^|\s|\()#(\d+)(?=\b)/g;
+const TASK_REF_RE = /(?:^|\s|\()task[:_\s-]?([A-Za-z0-9-]{8,})/gi;
+const ORG_REPO_RE = /\b([A-Za-z][\w-]{2,})\/([A-Za-z][\w.-]{2,})\b/g;
+const QUOTED_RE = /"([^"\n]{3,60})"/g;
+
+const STOP_TOKENS = new Set([
+  'it', 'that', 'this', 'the', 'our', 'your', 'their', 'a', 'an',
+  'what', 'which', 'who', 'when', 'where', 'why', 'how',
+  'is', 'are', 'was', 'were', 'do', 'does', 'did',
+]);
+
+export function extractEntities(raw: string): ExtractedEntities {
+  const agendaRefs = new Set<number>();
+  const taskRefs = new Set<string>();
+  const named = new Set<string>();
+
+  for (const m of raw.matchAll(AGENDA_REF_RE)) {
+    const n = Number(m[1]);
+    if (Number.isInteger(n) && n > 0 && n < 1e9) agendaRefs.add(n);
+  }
+
+  for (const m of raw.matchAll(TASK_REF_RE)) {
+    const id = m[1];
+    if (id && id.length >= 8 && id.length <= 64) taskRefs.add(id);
+  }
+
+  for (const m of raw.matchAll(ORG_REPO_RE)) {
+    const org = m[1];
+    if (!STOP_TOKENS.has(org.toLowerCase())) {
+      named.add(`${m[1]}/${m[2]}`);
+    }
+  }
+
+  for (const m of raw.matchAll(QUOTED_RE)) {
+    const phrase = m[1].trim();
+    if (phrase.length >= 3) named.add(phrase);
+  }
+
+  return {
+    agendaRefs: [...agendaRefs],
+    taskRefs: [...taskRefs],
+    namedEntities: [...named],
+  };
+}
+
+// ─── Fanout ────────────────────────────────────────────────────────
+
+export interface GroundingFanoutEnv {
+  db: D1Database;
+  wiki?: WikiClientEnv;
+}
+
+export async function groundIntent(
+  raw: string,
+  env: GroundingFanoutEnv,
+): Promise<GroundingResult> {
+  const entities = extractEntities(raw);
+  const searched: string[] = [];
+
+  const agendaPromise = (async () => {
+    if (entities.agendaRefs.length === 0) return [];
+    searched.push('d1.agenda');
+    const results = await Promise.all(
+      entities.agendaRefs.map(async (id) => {
+        try {
+          const r = await verifyAgendaClaim(env.db, id);
+          return r.exists
+            ? { id, status: 'verified' as const, item: r.item }
+            : { id, status: 'unknown' as const };
+        } catch {
+          return { id, status: 'unknown' as const };
+        }
+      }),
+    );
+    return results;
+  })();
+
+  const taskPromise = (async () => {
+    if (entities.taskRefs.length === 0) return [];
+    searched.push('d1.tasks');
+    const results = await Promise.all(
+      entities.taskRefs.map(async (id) => {
+        try {
+          const r = await verifyTaskClaim(env.db, id);
+          return r.exists
+            ? { id, status: 'verified' as const, task: r.task }
+            : { id, status: 'unknown' as const };
+        } catch {
+          return { id, status: 'unknown' as const };
+        }
+      }),
+    );
+    return results;
+  })();
+
+  const wikiPromise = (async () => {
+    if (!env.wiki || entities.namedEntities.length === 0) return [];
+    searched.push('wiki');
+    const hits: GroundingResult['wikiHits'] = [];
+    for (const entity of entities.namedEntities.slice(0, 5)) {
+      try {
+        const { results } = await searchPages(env.wiki, entity, { limit: 3 });
+        for (const r of results) {
+          hits.push({ slug: r.slug, scope: r.scope, summary: r.summary });
+        }
+      } catch {
+        // non-fatal per-entity
+      }
+    }
+    // Dedupe by slug
+    const seen = new Set<string>();
+    return hits.filter((h) => {
+      if (seen.has(h.slug)) return false;
+      seen.add(h.slug);
+      return true;
+    });
+  })();
+
+  const [agendaHits, taskHits, wikiHits] = await Promise.all([
+    agendaPromise,
+    taskPromise,
+    wikiPromise,
+  ]);
+
+  return { entities, agendaHits, taskHits, wikiHits, searched };
+}
+
+// ─── Envelope summary ──────────────────────────────────────────────
+
+export interface GroundingEnvelope {
+  grounded: boolean;
+  sources: string[];
+  unknowns: string[];
+  searched: string[];
+}
+
+export function summarizeGrounding(result: GroundingResult): GroundingEnvelope {
+  const sources: string[] = [];
+  const unknowns: string[] = [];
+
+  for (const h of result.agendaHits) {
+    if (h.status === 'verified') sources.push(`d1:agenda/${h.id}`);
+    else unknowns.push(`agenda#${h.id}`);
+  }
+  for (const h of result.taskHits) {
+    if (h.status === 'verified') sources.push(`d1:task/${h.id}`);
+    else unknowns.push(`task:${h.id}`);
+  }
+  for (const h of result.wikiHits) {
+    sources.push(`wiki:${h.scope ? `${h.scope}/` : ''}${h.slug}`);
+  }
+
+  return {
+    grounded: sources.length > 0,
+    sources,
+    unknowns,
+    searched: [...result.searched],
+  };
+}
+
+export function formatGroundingBlock(result: GroundingResult): string | null {
+  const hasContent =
+    result.agendaHits.length > 0 ||
+    result.taskHits.length > 0 ||
+    result.wikiHits.length > 0;
+  if (!hasContent) return null;
+
+  const lines: string[] = ['[Grounding — verified facts for entities in this query]'];
+
+  if (result.agendaHits.length > 0) {
+    lines.push('');
+    lines.push('Agenda items:');
+    for (const h of result.agendaHits) {
+      if (h.status === 'verified' && h.item) {
+        lines.push(
+          `  #${h.id} — ${h.item.item} (status: ${h.item.status}, priority: ${h.item.priority}${h.item.resolved_at ? `, resolved ${h.item.resolved_at}` : ''})`,
+        );
+      } else {
+        lines.push(`  #${h.id} — UNKNOWN: no such agenda item exists in D1.`);
+      }
+    }
+  }
+
+  if (result.taskHits.length > 0) {
+    lines.push('');
+    lines.push('Tasks:');
+    for (const h of result.taskHits) {
+      if (h.status === 'verified' && h.task) {
+        lines.push(
+          `  ${h.id} — ${h.task.title} (status: ${h.task.status}${h.task.completed_at ? `, completed ${h.task.completed_at}` : ''})`,
+        );
+      } else {
+        lines.push(`  ${h.id} — UNKNOWN: no such task exists in D1.`);
+      }
+    }
+  }
+
+  if (result.wikiHits.length > 0) {
+    lines.push('');
+    lines.push('Related wiki pages:');
+    for (const h of result.wikiHits.slice(0, 8)) {
+      const summary = h.summary ? ` — ${h.summary.slice(0, 140)}` : '';
+      lines.push(`  ${h.scope ? `${h.scope}/` : ''}${h.slug}${summary}`);
+    }
+  }
+
+  lines.push('');
+  lines.push(
+    '[Instruction: For any entity marked UNKNOWN above, respond "I have no record of X" and do not invent details. Treat verified entries as authoritative; cite wiki pages by slug when used.]',
+  );
+  return lines.join('\n');
+}

package/src/kernel/grounding/semantic-sanhedrin.ts

@@ -0,0 +1,163 @@
+// Semantic Sanhedrin — post-generation wiki-contradiction gate (aegis#573).
+//
+// Catches factual claims that slip past the structured fabrication detector
+// (agenda/task mutation language, referential slugs) because they have no
+// regex signature: "our Worker runs at X", "pricing is $Y", "version is Z".
+//
+// Pipeline:
+//   1. Skip short responses (< MIN_RESPONSE_WORDS) — not worth the model call.
+//   2. wiki_search on the first 200 chars of the response to get domain context.
+//   3. Extract candidate claim sentences (factual markers, non-questions, ≥10 words).
+//   4. Workers AI llama-3.1-8b: "do any of these statements contradict wiki facts?"
+//   5. Parse JSON result, filter by confidence ≥ MIN_CONFIDENCE.
+//
+// Posture: flag, don't strip. Non-fatal.
+
+import { searchPages } from '../../wiki/client.js';
+import type { WikiClientEnv } from '../../wiki/client.js';
+
+const MIN_RESPONSE_WORDS = 150;
+const WIKI_SEARCH_LIMIT = 3;
+const MAX_WIKI_EXCERPT_CHARS = 300;
+const MAX_RESPONSE_CHARS = 800;
+const MAX_CANDIDATE_SENTENCES = 15;
+const MIN_CONFIDENCE = 0.8;
+const SANHEDRIN_MODEL = '@cf/meta/llama-3.1-8b-instruct';
+const MAX_TOKENS = 300;
+
+export interface WikiContradiction {
+  statement: string;
+  wiki_source: string;
+  confidence: number;
+}
+
+export interface WikiContradictionReport {
+  checked: number;
+  contradictions: WikiContradiction[];
+}
+
+export interface SanhedrinEnv extends WikiClientEnv {
+  ai?: Ai;
+}
+
+// ─── Candidate sentence extraction ─────────────────────────────────────
+
+const FACTUAL_SIGNAL_RE = /\b(?:is|are|was|were|costs?|deployed|version|currently|runs?|uses?|our|aegis|worker|pricing|endpoint|url|located|serves?|hosts?|available)\b/i;
+const QUESTION_RE = /\?/;
+const MIN_SENTENCE_WORDS = 10;
+
+export function extractCandidateSentences(text: string): string[] {
+  const sentences = text
+    .replace(/\n+/g, ' ')
+    .split(/(?<=[.!?])\s+/)
+    .map(s => s.trim())
+    .filter(Boolean);
+
+  const candidates: string[] = [];
+  for (const s of sentences) {
+    if (candidates.length >= MAX_CANDIDATE_SENTENCES) break;
+    if (QUESTION_RE.test(s)) continue;
+    if (s.split(/\s+/).length < MIN_SENTENCE_WORDS) continue;
+    if (!FACTUAL_SIGNAL_RE.test(s)) continue;
+    candidates.push(s);
+  }
+  return candidates;
+}
+
+// ─── Workers AI call ────────────────────────────────────────────────────
+
+function buildPrompt(wikiContext: string, candidates: string[]): string {
+  const numbered = candidates.map((s, i) => `${i + 1}. "${s}"`).join('\n');
+  return [
+    'You are a factual accuracy auditor. Check if any candidate statements contradict the wiki facts below.',
+    '',
+    'WIKI FACTS:',
+    wikiContext,
+    '',
+    'CANDIDATE STATEMENTS:',
+    numbered,
+    '',
+    'Respond with ONLY valid JSON — no prose, no markdown fences:',
+    '{"contradictions":[{"statement":"...","wiki_source":"page title","confidence":0.0}]}',
+    'Only include contradictions with confidence >= 0.7. If none found: {"contradictions":[]}',
+  ].join('\n');
+}
+
+function parseAiResponse(raw: string): WikiContradiction[] {
+  const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```\s*$/, '').trim();
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (!match) return [];
+    try {
+      parsed = JSON.parse(match[0]);
+    } catch {
+      return [];
+    }
+  }
+
+  if (!parsed || typeof parsed !== 'object' || !Array.isArray((parsed as Record<string, unknown>).contradictions)) {
+    return [];
+  }
+
+  const raw_list = (parsed as { contradictions: unknown[] }).contradictions;
+  const result: WikiContradiction[] = [];
+  for (const item of raw_list) {
+    if (!item || typeof item !== 'object') continue;
+    const c = item as Record<string, unknown>;
+    const statement = typeof c.statement === 'string' ? c.statement.trim() : '';
+    const wiki_source = typeof c.wiki_source === 'string' ? c.wiki_source.trim() : 'unknown';
+    const confidence = typeof c.confidence === 'number' ? c.confidence : 0;
+    if (!statement) continue;
+    result.push({ statement, wiki_source, confidence });
+  }
+  return result;
+}
+
+async function runWorkersAi(ai: Ai, prompt: string): Promise<WikiContradiction[]> {
+  const result = await (ai.run as (model: string, options: unknown) => Promise<{ response?: string }>)(
+    SANHEDRIN_MODEL,
+    {
+      messages: [{ role: 'user', content: prompt }],
+      max_tokens: MAX_TOKENS,
+    },
+  );
+  const text = result.response ?? '';
+  return parseAiResponse(text);
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────
+
+export async function semanticSanhedrinCheck(
+  responseText: string,
+  env: SanhedrinEnv,
+): Promise<WikiContradictionReport> {
+  const wordCount = responseText.trim().split(/\s+/).length;
+  if (wordCount < MIN_RESPONSE_WORDS) return { checked: 0, contradictions: [] };
+  if (!env.ai || !env.wikiBinding) return { checked: 0, contradictions: [] };
+
+  const searchQuery = responseText.slice(0, 200).replace(/[^\w\s]/g, ' ').trim();
+  const { results } = await searchPages(env, searchQuery, { limit: WIKI_SEARCH_LIMIT });
+  if (results.length === 0) return { checked: 0, contradictions: [] };
+
+  const wikiContext = results
+    .map(p => `[${p.title}]\n${(p.summary || p.snippet || '').slice(0, MAX_WIKI_EXCERPT_CHARS)}`)
+    .join('\n\n');
+
+  const candidates = extractCandidateSentences(responseText.slice(0, MAX_RESPONSE_CHARS * 2));
+  if (candidates.length === 0) return { checked: 0, contradictions: [] };
+
+  const prompt = buildPrompt(wikiContext, candidates);
+  const all = await runWorkersAi(env.ai, prompt);
+  const filtered = all.filter(c => c.confidence >= MIN_CONFIDENCE);
+
+  return { checked: candidates.length, contradictions: filtered };
+}
+
+export function formatContradictions(report: WikiContradictionReport): string[] {
+  return report.contradictions.map(c =>
+    `semantic: "${c.statement.slice(0, 120)}" — contradicts wiki:${c.wiki_source} (confidence: ${c.confidence.toFixed(2)})`,
+  );
+}

package/src/kernel/grounding/verify.ts

@@ -0,0 +1,86 @@
+import type { AgendaPriority, AgendaStatus, TaskStatus } from '../../schema-enums.js';
+import { readPage } from '../../wiki/client.js';
+import type { WikiClientEnv } from '../../wiki/client.js';
+
+// ─── Result Types ───────────────────────────────────────────
+
+export interface AgendaClaimResult {
+  exists: boolean;
+  item?: {
+    id: number;
+    item: string;
+    context: string | null;
+    priority: AgendaPriority;
+    status: AgendaStatus;
+    created_at: string;
+    resolved_at: string | null;
+    business_unit: string;
+  };
+}
+
+export interface TaskClaimResult {
+  exists: boolean;
+  task?: {
+    id: string;
+    title: string;
+    prompt: string;
+    status: TaskStatus;
+    created_at: string;
+    completed_at: string | null;
+  };
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+export async function verifyAgendaClaim(
+  db: D1Database,
+  id: number,
+): Promise<AgendaClaimResult> {
+  if (!Number.isInteger(id) || id < 1) return { exists: false };
+
+  const row = await db
+    .prepare(
+      'SELECT id, item, context, priority, status, created_at, resolved_at, business_unit FROM agent_agenda WHERE id = ?',
+    )
+    .bind(id)
+    .first<AgendaClaimResult['item']>();
+
+  if (!row) return { exists: false };
+  return { exists: true, item: row };
+}
+
+export async function verifyTaskClaim(
+  db: D1Database,
+  id: string,
+): Promise<TaskClaimResult> {
+  if (typeof id !== 'string' || id.length === 0) return { exists: false };
+
+  const row = await db
+    .prepare(
+      'SELECT id, title, prompt, status, created_at, completed_at FROM cc_tasks WHERE id = ?',
+    )
+    .bind(id)
+    .first<TaskClaimResult['task']>();
+
+  if (!row) return { exists: false };
+  return { exists: true, task: row };
+}
+
+// ─── Wiki existence check (aegis#500) ──────────────────────────
+// Verifies that slug-shaped strings asserted as "canonical wiki pages" actually
+// resolve. Returns { exists: false } on 404. Other errors propagate so the
+// caller can decide (the detector wraps in try/catch + treats verification
+// failure as non-fatal, matching v1 posture).
+
+export interface WikiPageClaimResult {
+  exists: boolean;
+}
+
+export async function verifyWikiPageClaim(
+  env: WikiClientEnv,
+  slug: string,
+): Promise<WikiPageClaimResult> {
+  if (typeof slug !== 'string' || slug.length === 0) return { exists: false };
+  const result = await readPage(env, slug);
+  return { exists: result.page !== null };
+}

package/src/kernel/grounding-layer.ts

@@ -0,0 +1,280 @@
+/**
+ * Grounding layer — owns all the "don't hallucinate" machinery the dispatch
+ * loop weaves around an executor call.
+ *
+ * Three pre-execution augmentations:
+ *   - augmentWithInsights     — CRIX (#106) cross-repo intelligence injection
+ *   - augmentWithEntityGrounding — (aegis#446) bizops_read + user_correction
+ *     fanout to D1 + wiki; returns the grounding envelope
+ *   - augmentWithMemoryRecall — (aegis#457 Phase 5) memory_recall reads
+ *     from the wiki and prepends a "relevant pages" block
+ *
+ * Two post-execution passes:
+ *   - applyFabricationCheck  — fabrication-detector (#447 v1)
+ *   - applyGapSignal         — gap-signal bookkeeping (#497)
+ *
+ * And one outcome adjudicator:
+ *   - applyGroundingProof    — redefines "success" in procedural_memory
+ *     so fabrications on grounding-gated classes count as partial_failure.
+ *
+ * Everything non-fatal logs and falls through to the ungrounded path —
+ * grounding must never block dispatch.
+ *
+ * Circuit-breaker wrapping is intentionally absent from this core layer.
+ * Consumers wanting auto-disable-after-N-failures should compose their own
+ * circuit breaker at the call site.
+ */
+import { groundIntent, formatGroundingBlock, summarizeGrounding } from './grounding/fanout.js';
+import type { GroundingEnvelope } from './grounding/fanout.js';
+import { fabricationCheck, formatUnverifiedClaims } from './grounding/fabrication-detector.js';
+import { semanticSanhedrinCheck, formatContradictions } from './grounding/semantic-sanhedrin.js';
+import { searchPages } from '../wiki/client.js';
+import type { WikiClientEnv } from '../wiki/client.js';
+import { memoryServiceFor } from './memory-service.js';
+import type { KernelIntent, DispatchResult } from './types.js';
+import type { EdgeEnv } from './dispatch.js';
+
+// ─── Classifications that participate in grounding ─────────
+
+export const GROUNDING_GATED_CLASSIFICATIONS = new Set<string>([
+  'bizops_read', 'user_correction', 'memory_recall',
+]);
+
+// ─── CRIX insight cache ─────────────────────────────────────
+
+const INSIGHT_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const MAX_INSIGHTS_PER_DISPATCH = 3;
+
+interface InsightEntry { fact: string; type: string; origin: string }
+let insightCache: { entries: InsightEntry[]; fetchedAt: number } | null = null;
+
+/** Testing hook — reset the module-level cache between runs. */
+export function __resetInsightCache(): void {
+  insightCache = null;
+}
+
+async function fetchRelevantInsights(
+  env: EdgeEnv,
+  _classification: string,
+  rawQuery: string,
+): Promise<string | null> {
+  const now = Date.now();
+  if (!insightCache || (now - insightCache.fetchedAt) > INSIGHT_CACHE_TTL_MS) {
+    try {
+      const wikiEnv: WikiClientEnv = { wikiBinding: env.wikiBinding, wikiToken: env.wikiToken };
+      const { results } = await searchPages(wikiEnv, 'cross_repo_insights', { limit: 20 });
+      insightCache = {
+        entries: results.map(page => ({
+          fact: page.summary || page.snippet || page.title,
+          type: page.type || 'pattern',
+          origin: page.scope || 'core',
+        })),
+        fetchedAt: now,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  if (!insightCache || insightCache.entries.length === 0) return null;
+
+  const queryWords = new Set(
+    rawQuery.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/).filter(w => w.length > 3),
+  );
+
+  const scored = insightCache.entries
+    .map(entry => {
+      const factWords = entry.fact.toLowerCase().split(/\s+/);
+      const matches = factWords.filter(w => queryWords.has(w)).length;
+      return { ...entry, relevance: matches };
+    })
+    .filter(e => e.relevance > 0);
+
+  scored.sort((a, b) => b.relevance - a.relevance);
+  const top = scored.slice(0, MAX_INSIGHTS_PER_DISPATCH);
+  if (top.length === 0) return null;
+
+  const lines = top.map(i => `- [${i.type}] (from ${i.origin}) ${i.fact}`);
+  return `[Cross-Repo Intelligence — validated patterns]\n${lines.join('\n')}`;
+}
+
+/**
+ * Prepend cross-repo insights to the intent when applicable. In-place mutation
+ * of intent.raw. Skips greeting + heartbeat and when no wiki binding is
+ * configured. Non-fatal.
+ */
+export async function augmentWithInsights(
+  intent: KernelIntent,
+  classification: string,
+  env: EdgeEnv,
+): Promise<void> {
+  if (!env.wikiBinding) return;
+  if (classification === 'greeting' || classification === 'heartbeat') return;
+  try {
+    const insightContext = await fetchRelevantInsights(env, classification, intent.raw);
+    if (insightContext) {
+      intent.raw = `${insightContext}\n\n${intent.raw}`;
+    }
+  } catch (err) {
+    console.warn('[grounding-layer] Insight fetch failed (non-fatal):', err instanceof Error ? err.message : String(err));
+  }
+}
+
+/**
+ * Fanout entity grounding for bizops_read + user_correction. Extracts entity
+ * refs, queries D1 + wiki in parallel, injects a verified-facts block. Returns
+ * the grounding envelope when a block was injected, or undefined. Non-fatal.
+ */
+export async function augmentWithEntityGrounding(
+  intent: KernelIntent,
+  classification: string,
+  env: EdgeEnv,
+): Promise<GroundingEnvelope | undefined> {
+  if (classification !== 'bizops_read' && classification !== 'user_correction') return undefined;
+
+  try {
+    const wikiEnv: WikiClientEnv | undefined = env.wikiBinding
+      ? { wikiBinding: env.wikiBinding, wikiToken: env.wikiToken }
+      : undefined;
+    const grounding = await groundIntent(intent.raw, {
+      db: env.db,
+      wiki: wikiEnv,
+    });
+    const block = formatGroundingBlock(grounding);
+    if (block) {
+      intent.raw = `${block}\n\n[Operator query]\n${intent.raw}`;
+    }
+    return summarizeGrounding(grounding);
+  } catch (err) {
+    console.warn('[grounding-layer] Entity grounding failed (non-fatal):', err instanceof Error ? err.message : String(err));
+  }
+  return undefined;
+}
+
+/**
+ * Memory_recall augmentation — search the wiki for pages matching the
+ * intent.raw and prepend a block of hits for the executor to quote. Non-fatal.
+ */
+export async function augmentWithMemoryRecall(
+  intent: KernelIntent,
+  classification: string,
+  env: EdgeEnv,
+): Promise<void> {
+  if (classification !== 'memory_recall') return;
+  try {
+    if (!env.wikiBinding) {
+      console.warn('[grounding-layer] Wiki binding unavailable — skipping memory recall augmentation');
+      return;
+    }
+    const wikiEnv: WikiClientEnv = { wikiBinding: env.wikiBinding, wikiToken: env.wikiToken };
+    const { results } = await searchPages(wikiEnv, intent.raw, { limit: 10 });
+    if (results.length > 0) {
+      const memLines = results.map(p =>
+        `- [${p.scope || p.type || 'wiki'}] ${p.summary || p.title} (confidence: ${p.confidence || 'medium'})`,
+      ).join('\n');
+      intent.raw = `[Relevant wiki pages matching this query]\n${memLines}\n\n[User's question]\n${intent.raw}`;
+    }
+  } catch (err) {
+    console.warn('[grounding-layer] Wiki search failed (non-fatal):', err instanceof Error ? err.message : String(err));
+  }
+}
+
+// ─── Post-execution passes ─────────────────────────────────
+
+/**
+ * Downgrade successful outcomes to `partial_failure` when the response
+ * carries unverified_claims on a grounding-gated classification. This stops
+ * the procedural_memory learning loop from probating procedures upward on
+ * fabrications that happen to not throw.
+ */
+export function applyGroundingProof(
+  execOutcome: 'success' | 'failure' | 'partial_failure',
+  classification: string,
+  dispatchResult: DispatchResult,
+): 'success' | 'failure' | 'partial_failure' {
+  if (execOutcome !== 'success') return execOutcome;
+  if (!GROUNDING_GATED_CLASSIFICATIONS.has(classification)) return execOutcome;
+  if (dispatchResult.unverified_claims && dispatchResult.unverified_claims.length > 0) {
+    return 'partial_failure';
+  }
+  return execOutcome;
+}
+
+/**
+ * Record or clear the gap_signal_count for this procedureKey. Only runs for
+ * grounding-gated classes. Non-fatal.
+ */
+export async function applyGapSignal(
+  dispatchResult: DispatchResult,
+  procKey: string,
+  classification: string,
+  env: EdgeEnv,
+): Promise<void> {
+  if (!GROUNDING_GATED_CLASSIFICATIONS.has(classification)) return;
+
+  const hasGap =
+    (dispatchResult.unverified_claims?.length ?? 0) > 0 ||
+    (dispatchResult.unknowns?.length ?? 0) > 0;
+
+  try {
+    const memory = memoryServiceFor(env);
+    if (hasGap) {
+      await memory.recordGapSignal(procKey);
+    } else {
+      await memory.clearGapSignal(procKey);
+    }
+  } catch (err) {
+    console.warn('[grounding-layer] Gap signal update failed (non-fatal):', err instanceof Error ? err.message : String(err));
+  }
+}
+
+/**
+ * Fabrication-detector post-pass (#447 v1 + semantic Sanhedrin #573).
+ *
+ * Runs two checks independently (Promise.allSettled so one failure doesn't
+ * cancel the other):
+ *   - Structured pass: agenda/task mutation claims + referential slug verification
+ *   - Semantic pass: Workers AI wiki-contradiction gate
+ *
+ * Contradictions from either pass land in `unverified_claims[]`. Response text
+ * is never stripped — diagnostic posture until false-positive rates are known.
+ */
+export async function applyFabricationCheck(
+  result: DispatchResult,
+  responseText: string,
+  env: EdgeEnv,
+): Promise<void> {
+  try {
+    const [structuredResult, semanticResult] = await Promise.allSettled([
+      fabricationCheck(responseText, {
+        db: env.db,
+        wikiBinding: env.wikiBinding,
+        wikiToken: env.wikiToken,
+      }),
+      semanticSanhedrinCheck(responseText, {
+        wikiBinding: env.wikiBinding,
+        wikiToken: env.wikiToken,
+        ai: env.ai,
+      }),
+    ]);
+
+    const structuredReport = structuredResult.status === 'fulfilled'
+      ? structuredResult.value
+      : { checked: 0, unverified: [] };
+    const semanticReport = semanticResult.status === 'fulfilled'
+      ? semanticResult.value
+      : { checked: 0, contradictions: [] };
+
+    const allClaims: string[] = [
+      ...formatUnverifiedClaims(structuredReport),
+      ...formatContradictions(semanticReport),
+    ];
+
+    if (allClaims.length > 0) {
+      result.unverified_claims = allClaims;
+      result.grounded = false;
+    }
+  } catch (err) {
+    console.warn('[grounding-layer] Fabrication check failed (non-fatal):', err instanceof Error ? err.message : String(err));
+  }
+}

package/src/kernel/memory/blocks.ts

@@ -36,8 +36,10 @@ const EXECUTOR_ATTACHMENTS: Record<Executor, readonly BlockId[]> = {
   gpt_oss:      ['identity', 'operator_profile', 'operating_rules'],
   groq:         CORE_BLOCKS,
   workers_ai:   MINIMAL_BLOCKS,
-  direct:       [],
-  tarotscript:  [],
+  direct:           [],
+  tarotscript:      [],
+  cerebras_mid:     CORE_BLOCKS,
+  cerebras_reasoning: CORE_BLOCKS,
 };
 
 // ─── CRUD ────────────────────────────────────────────────────

package/src/kernel/types.ts

@@ -88,7 +88,7 @@ export interface MemoryEntry {
 
 // ─── Execution Plan ──────────────────────────────────────────
 
-export type Executor = 'claude' | 'groq' | 'direct' | 'claude_code' | 'workers_ai' | 'claude_opus' | 'gpt_oss' | 'composite' | 'tarotscript';
+export type Executor = 'claude' | 'groq' | 'direct' | 'claude_code' | 'workers_ai' | 'claude_opus' | 'gpt_oss' | 'composite' | 'tarotscript' | 'cerebras_mid' | 'cerebras_reasoning';
 
 export interface ExecutionPlan {
   executor: Executor;
@@ -147,4 +147,10 @@ export interface DispatchResult {
   reclassified?: boolean;
   probeResult?: 'agreed' | 'split' | 'escalated';
   meta?: unknown;
+  // Grounding fields (populated by grounding-layer when active)
+  grounded?: boolean;
+  sources?: string[];
+  unknowns?: string[];
+  searched?: string[];
+  unverified_claims?: string[];
 }